using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.IO;

namespace Biff8Excel.COM
{
    [ClassInterface(ClassInterfaceType.AutoDispatch)]
    public class AxMemoryStream : MemoryStream, IStream
    {
        void IStream.Clone(out IStream clone)
        {
            clone = this.MemberwiseClone() as IStream;
        }

        void IStream.Commit(int flags)
        {
            throw new NotImplementedException("AxMemoryStream is not transactional");
        }

        void IStream.CopyTo(IStream destination, long count, IntPtr pcbRead, IntPtr pcbWritten)
        {
            /**///////////
            // Copy the lot using 4k chunks
            /**///////////
            byte[] _buffer = new byte[4096];
            int _cbRead = 0;
            int _cbWritten = 0;
            IntPtr p = IntPtr.Zero;
            while (count > 0)
            {
                int _chunk = (int)Math.Min(count, _buffer.Length);
                int _chunkRead = this.Read(_buffer, _cbRead, _chunk);

                destination.Write(_buffer, _chunk, ref p);

                _cbRead += _chunkRead;
                _cbWritten += _chunkRead;
            }

            /**///////////
            // Update the counts, if they were provided
            /**///////////
            if (pcbRead != IntPtr.Zero)
            {
                Marshal.WriteInt64(pcbRead, _cbRead);
            }

            if (pcbWritten != IntPtr.Zero)
            {
                Marshal.WriteInt64(pcbWritten, _cbWritten);
            }
        }

        void IStream.LockRegion(long offset, long count, int lockType)
        {
            throw new NotImplementedException("AxMemoryStream does not support locking");
        }

        void IStream.Read(byte[] buffer, int count,ref IntPtr pcbRead)
        {
            long _cbRead = 0;
            int offset = 0;
            int cnt = int.MaxValue;
            byte[] tmp = new byte[cnt];

            while (count > 0)
            {
                _cbRead += this.Read(tmp, offset, cnt);

                tmp.CopyTo(buffer, offset);

                offset += cnt;
                count -= cnt;

                if ((count - cnt) < int.MaxValue)
                {
                    _cbRead += this.Read(tmp, offset, (int)(count) );
                    tmp.CopyTo(buffer, offset);
                    break;
                }
            }

            if (pcbRead != IntPtr.Zero)
            {
                //Marshal.WriteInt32(pcbRead, _cbRead);
                Marshal.WriteInt64(pcbRead, _cbRead);
            }
            //throw new NotImplementedException("AxMemoryStream does not support Read");
        }

        void IStream.Revert()
        {
            throw new NotImplementedException("AxMemoryStream is not transactional");
        }

        void IStream.Seek(long offset, int origin,ref IntPtr pcbPos)
        {
            long _position = this.Seek(offset, (SeekOrigin)origin);

            if (pcbPos != IntPtr.Zero)
            {
                Marshal.WriteInt64(pcbPos, _position);
            }
        }

        void IStream.SetSize(long newSize)
        {
            this.SetLength(newSize);
        }

        void IStream.Stat(out STATSTG stat, int flags)
        {
            stat = new STATSTG();
            stat.cbSize = Marshal.SizeOf(stat);
            stat.grfLocksSupported = 0;
        }

        void IStream.UnlockRegion(long offset, long count, int lockType)
        {
            throw new NotImplementedException("AxMemoryStream does not support locking");
        }

        void IStream.Write(byte[] buffer, int count,ref IntPtr pcbWritten)
        {
            this.Write(buffer, 0, count);

            if (pcbWritten != IntPtr.Zero)
            {
                Marshal.WriteInt32(pcbWritten, count);
            }
        }
    }

}