// Written by Christopher E. Miller
// See the included license.txt for copyright and license details.

module dfl.internal.com;

import core.sys.windows.windows;
import core.sys.windows.com;
import core.sys.windows.objidl; // IStream

// FIX: import dfl.internal.winapi;
// FIX: import dfl.internal.wincom;
import dfl.internal.dlib;

// Importing dfl.application here causes the compiler to crash.
//import dfl.application;
private extern(C) {
   size_t C_refCountInc(void* p);
   size_t C_refCountDec(void* p);
}


// Won't be killed by GC if not referenced in D and the refcount is > 0.
class DflComObject: ComObject {
   extern(Windows) {
      override ULONG AddRef() {
         //cprintf("AddRef `%.*s`\n", cast(int)toString().length, toString().ptr);
         return C_refCountInc(cast(void*)this);
      }

      override ULONG Release() {
         //cprintf("Release `%.*s`\n", cast(int)toString().length, toString().ptr);
         return C_refCountDec(cast(void*)this);
      }
   }
}

class DStreamToIStream: DflComObject, IStream {
   this(DStream sourceDStream) {
      this.stm = sourceDStream;
   }


   extern(Windows):
      override HRESULT QueryInterface(IID* riid, void** ppv) {
         if(*riid == IID_IStream) {
            *ppv = cast(void*)cast(IStream)this;
            AddRef();
            return S_OK;
         } else if(*riid == IID_ISequentialStream) {
            *ppv = cast(void*)cast(ISequentialStream)this;
            AddRef();
            return S_OK;
         } else if(*riid == IID_IUnknown) {
            *ppv = cast(void*)cast(IUnknown)this;
            AddRef();
            return S_OK;
         } else {
            *ppv = null;
            return E_NOINTERFACE;
         }
      }


   HRESULT Read(void* pv, ULONG cb, ULONG* pcbRead) {
      ULONG read;
      HRESULT result = S_OK;

      try {
         read = stm.readBlock(pv, cb);
      } catch(DStreamException e) {
         result = S_FALSE; // ?
      }

      if(pcbRead) {
         *pcbRead = read;
      }
      //if(!read)
      // result = S_FALSE;
      return result;
   }


   HRESULT Write(void* pv, ULONG cb, ULONG* pcbWritten) {
      ULONG written;
      HRESULT result = S_OK;

      try {
         if(!stm.writeable) {
            return E_NOTIMPL;
         }
         written = stm.writeBlock(pv, cb);
      } catch(DStreamException e) {
         result = S_FALSE; // ?
      }

      if(pcbWritten) {
         *pcbWritten = written;
      }
      //if(!written)
      // result = S_FALSE;
      return result;
   }


   version(DFL_TANGO_NO_SEEK_COMPAT) {
   } else {
      long _fakepos = 0;
   }


   HRESULT Seek(LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition) {
      HRESULT result = S_OK;

      //cprintf("seek move=%u, origin=0x%x\n", cast(uint)dlibMove.QuadPart, dwOrigin);

      try {
         if(!stm.seekable) {
            //return S_FALSE; // ?
            return E_NOTIMPL;   // ?
         }

         ulong pos;
         switch (dwOrigin) with (STREAM_SEEK) {
            case STREAM_SEEK_SET:
               pos = stm.seekSet(dlibMove.QuadPart);
               if(plibNewPosition) {
                  plibNewPosition.QuadPart = pos;
               }
               break;

            case STREAM_SEEK_CUR:
               pos = stm.seekCur(dlibMove.QuadPart);
               if(plibNewPosition) {
                  plibNewPosition.QuadPart = pos;
               }
               break;

            case STREAM_SEEK_END:
               pos = stm.seekEnd(dlibMove.QuadPart);
               if(plibNewPosition) {
                  plibNewPosition.QuadPart = pos;
               }
               break;

            default:
               result = STG_E_INVALIDFUNCTION;
         }
      } catch(DStreamException e) {
         result = S_FALSE; // ?
      }

      return result;
   }


   HRESULT SetSize(ULARGE_INTEGER libNewSize) {
      return E_NOTIMPL;
   }


   HRESULT CopyTo(IStream pstm, ULARGE_INTEGER cb, ULARGE_INTEGER* pcbRead, ULARGE_INTEGER* pcbWritten) {
      // TODO: implement.
      return E_NOTIMPL;
   }


   HRESULT Commit(DWORD grfCommitFlags) {
      // Ignore -grfCommitFlags- and just flush the stream..
      //stm.flush();
      stm.flush();
      return S_OK; // ?
   }


   HRESULT Revert() {
      return E_NOTIMPL; // ? S_FALSE ?
   }


   HRESULT LockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType) {
      return E_NOTIMPL;
   }


   HRESULT UnlockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType) {
      return E_NOTIMPL;
   }


   HRESULT Stat(STATSTG* pstatstg, DWORD grfStatFlag) {
      return E_NOTIMPL; // ?
   }


   HRESULT Clone(IStream* ppstm) {
      // Cloned stream needs its own seek position.
      return E_NOTIMPL; // ?
   }


   extern(D):
      private DStream stm;
}

class MemoryIStream: DflComObject, IStream {
   this(void[] memory) {
      this.mem = memory;
   }


   extern(Windows):

      override HRESULT QueryInterface(IID* riid, void** ppv) {
         if(*riid == IID_IStream) {
            *ppv = cast(void*)cast(IStream)this;
            AddRef();
            return S_OK;
         } else if(*riid == IID_ISequentialStream) {
            *ppv = cast(void*)cast(ISequentialStream)this;
            AddRef();
            return S_OK;
         } else if(*riid == IID_IUnknown) {
            *ppv = cast(void*)cast(IUnknown)this;
            AddRef();
            return S_OK;
         } else {
            *ppv = null;
            return E_NOINTERFACE;
         }
      }


   HRESULT Read(void* pv, ULONG cb, ULONG* pcbRead) {
      // Shouldn't happen unless the mem changes, which doesn't happen yet.
      if(seekpos > mem.length) {
         return S_FALSE;   // ?
      }

      size_t count = mem.length - seekpos;
      if(count > cb) {
         count = cb;
      }

      pv[0 .. count] = mem[seekpos .. seekpos + count];
      seekpos += count;

      if(pcbRead) {
         *pcbRead = count;
      }
      return S_OK;
   }


   HRESULT Write(void* pv, ULONG cb, ULONG* pcbWritten) {
      //return STG_E_ACCESSDENIED;
      return E_NOTIMPL;
   }


   HRESULT Seek(LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition) {
      //cprintf("seek move=%u, origin=0x%x\n", cast(uint)dlibMove.QuadPart, dwOrigin);

      auto toPos = cast(long)dlibMove.QuadPart;
      switch (dwOrigin) with (STREAM_SEEK) {
         case STREAM_SEEK_SET:
            break;

         case STREAM_SEEK_CUR:
            toPos = cast(long)seekpos + toPos;
            break;

         case STREAM_SEEK_END:
            toPos = cast(long)mem.length - toPos;
            break;

         default:
            return STG_E_INVALIDFUNCTION;
      }

      if(withinbounds(toPos)) {
         seekpos = cast(size_t)toPos;
         if(plibNewPosition) {
            plibNewPosition.QuadPart = seekpos;
         }
         return S_OK;
      } else {
         return 0x80030005; //STG_E_ACCESSDENIED; // Seeking past end needs write access.
      }
   }


   HRESULT SetSize(ULARGE_INTEGER libNewSize) {
      return E_NOTIMPL;
   }


   HRESULT CopyTo(IStream pstm, ULARGE_INTEGER cb, ULARGE_INTEGER* pcbRead, ULARGE_INTEGER* pcbWritten) {
      // TODO: implement.
      return E_NOTIMPL;
   }


   HRESULT Commit(DWORD grfCommitFlags) {
      return S_OK; // ?
   }


   HRESULT Revert() {
      return E_NOTIMPL; // ? S_FALSE ?
   }


   HRESULT LockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType) {
      return E_NOTIMPL;
   }


   HRESULT UnlockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType) {
      return E_NOTIMPL;
   }


   HRESULT Stat(STATSTG* pstatstg, DWORD grfStatFlag) {
      return E_NOTIMPL; // ?
   }


   HRESULT Clone(IStream* ppstm) {
      // Cloned stream needs its own seek position.
      return E_NOTIMPL; // ?
   }


   extern(D) {
      private void[] mem;
      private size_t seekpos = 0;


      private bool withinbounds(long pos) {
         if(pos < seekpos.min || pos > seekpos.max) {
            return false;
         }
         // Note: it IS within bounds if it's AT the end, it just can't read there.
         return cast(size_t)pos <= mem.length;
      }
   }
}