#ifndef PERSISTFILEIMPL_H
#define PERSISTFILEIMPL_H
/////////////////////////////////////////////////////////////////
//  PersistFileImpl.h -  Implements IPersistFile               //
//                                                             //
//  Platform:     Dell Dimension 8100, Windows 2000, SP2       //
//  Application:  Demonstration of ATL 7.0 for CSE775          //
//  Modified:     Jim Fawcett, Syracuse Univ, CST 2-187        //
//                (315) 443-3948, fawcett@ecs.syr.edu          //
/////////////////////////////////////////////////////////////////

#include <atlctl.h>
#include <windows.h>
#include <iostream>

template <typename T>
class IPersistFileImpl : public IPersistFile
{
public:

  IPersistFileImpl() : m_Name("Fred"),m_Color("Orange"),m_pFileMoniker(0) {}

  // IPersistFile Interface Implementation

  STDMETHOD(GetClassID(CLSID * pClassID));
  STDMETHOD(IsDirty(void));
  STDMETHOD(Load(LPCOLESTR pszFileName, DWORD dwMode));
  STDMETHOD(Save(LPCOLESTR pszFileName, BOOL fRemember));
  STDMETHOD(SaveCompleted(LPCOLESTR pszFileName));
  STDMETHOD(GetCurFile(LPOLESTR * ppszFileName));

  void setColor(const CString& color)
  {
    m_Color = color;
  }
  void setName(const CString& name)
  {
    m_Name = name;
  }
protected:
  HANDLE hfile_;
  CString m_Name;
  CString m_Color;
  IMoniker* m_pFileMoniker;
  DWORD m_ROTFile;
};

//
template <typename T>
STDMETHODIMP IPersistFileImpl<T>::GetClassID(CLSID * pClassID)
{ 
  *pClassID = __uuidof(Csimpletest);
  return S_OK; 
}

template <typename T>
STDMETHODIMP IPersistFileImpl<T>::IsDirty(void) 
{ 
  return S_OK; 
}

STDMETHODIMP ReadStream(IStorage* pIStorage, OLECHAR* pStreamName, CString& streamBuffer);

//
template <typename T>
STDMETHODIMP IPersistFileImpl<T>::Load(LPCOLESTR pszFileName, DWORD dwMode) 
{
  IStorage* pIStorage;
  HRESULT hr = StgOpenStorage
  (
    pszFileName,
    NULL,
    STGM_TRANSACTED | STGM_READ,
    NULL,
    0,
    &pIStorage
  );
  if(SUCCEEDED(hr))
  {
    std::cout << "\n  opened storage";
    hr = ReadStream(pIStorage,OLESTR("Name"),m_Name);
  }
  if(SUCCEEDED(hr))
  {
    std::cout << "\n  read name:  " << m_Name;
    hr = ReadStream(pIStorage,OLESTR("Color"),m_Color);
  }
  if(SUCCEEDED(hr))
  {
    std::cout << "\n  read color: " << m_Color;
  }
  if(!m_pFileMoniker)
  {
    hr = CreateFileMoniker(pszFileName,&m_pFileMoniker);
    if(SUCCEEDED(hr))
    {
      IRunningObjectTable *pROT;
      hr = GetRunningObjectTable(0,&pROT);
      if(SUCCEEDED(hr))
      {
        pROT->Register
        (
          0,
          (IUnknown*)(Isimpletest*)this,
          m_pFileMoniker,
          &m_ROTFile
        );
        pROT->Release();
      }
    }
  }
  pIStorage->Release();
  return hr; 
}

//
template <typename T>
STDMETHODIMP IPersistFileImpl<T>::Save(LPCOLESTR pszFileName, BOOL fRemember)
{ 
  USES_CONVERSION;
  HRESULT hr;
  IStorage* pIStorage;

  hr = StgCreateDocfile
       (
         pszFileName, 
         STGM_DIRECT | STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
         0,
         &pIStorage
       );
  if(SUCCEEDED(hr))
  {
    std::cout << "\n  opened storage";
    LPSTREAM pStream = NULL;
    LPCOLESTR streamName = A2W("Name");
    hr = pIStorage->
         CreateStream
         (
           streamName,
           STGM_DIRECT | STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
           0,
           0,
           &pStream
         );
//
    if(SUCCEEDED(hr))
    {
      std::cout << "\n  created stream";
      ULONG Written;
      hr = pStream->Write
                    (
                      (void const*)(LPCSTR)m_Name,
                      (ULONG)m_Name.GetLength(),
                      &Written
                    );
      if(SUCCEEDED(hr))
      {
        std::cout << "\n  wrote name: " << m_Name;
      }
      pStream->Release();
      pStream = NULL;
      streamName = A2W("Color");
      hr = pIStorage->
        CreateStream
        (
          streamName,
          STGM_DIRECT | STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
          0,
          0,
          &pStream
        );
      if(SUCCEEDED(hr) && (pStream != NULL))
      {
        std::cout << "\n  created stream";
        ULONG Written;
        hr = pStream->Write
                      (
                        (void const*)(LPCSTR)m_Color,
                        (ULONG)m_Color.GetLength(),
                        &Written
                      );
        if(SUCCEEDED(hr))
        {
          std::cout << "\n  wrote color: " << m_Color;
        }
        pStream->Release();
        pStream = NULL;

        LPOLESTR pszUserType = NULL;
        hr = OleRegGetUserType(__uuidof(Isimpletest),USERCLASSTYPE_FULL,&pszUserType);
        if(SUCCEEDED(hr))
        {
          hr = WriteFmtUserTypeStg(pIStorage,CF_TEXT,pszUserType);
          CoTaskMemFree(pszUserType);
        }
      }
      else
      {
        std::cout << "\n  stream creation failed";
      }
      pIStorage->Release();
    }
    else
    {
      std::cout << "\n  stream creation failed";
    }
  }
  return hr;
}

//
template <typename T>
STDMETHODIMP IPersistFileImpl<T>::SaveCompleted(LPCOLESTR pszFileName)
{ 
  return S_OK; 
}

template <typename T>
STDMETHODIMP IPersistFileImpl<T>::GetCurFile(LPOLESTR * ppszFileName)
{ 
  return S_OK; 
}

#endif