using System;
using System.Diagnostics.Contracts;
using System.Text;
using Windows.Storage.Streams;

namespace IO
{
    /// <summary>
    /// Indicates whether an <see cref="IDataStream"/> is reading or writing.
    /// </summary>
    public enum DataStreamMode
    {
        /// <summary>
        /// The <see cref="IDataStream"/> is reading from an underlying stream.
        /// </summary>
        Read,

        /// <summary>
        /// The <see cref="IDataStream"/> is writing to the underlying stream.
        /// </summary>
        Write,
    }

    /// <summary>
    /// Provides an implementation of the <see cref="IDataStream"/> interface that streams to and from
    /// binary data.
    ///
    /// This class cannot be inherited.
    /// </summary>
    public sealed class BinaryDataStream
        : IDataStream, IDisposable
    {
        private readonly DataStreamMode mode;
        private readonly DataReader reader;
        private readonly DataWriter writer;
        private readonly bool leaveOpen;
        private bool isDisposed;

        /// <summary>
        /// Initializes a new instance of the <see cref="BinaryDataStream"/> class based on the given
        /// <see cref="DataReader"/>, and sets <see cref="StreamMode"/> to <see cref="DataStreamMode.Read"/>.
        /// </summary>
        /// <param name="reader">
        /// The <see cref="DataReader"/> to use as the underlying stream.
        /// </param>
        /// <param name="leaveOpen">
        /// <c>true</c> to not dispose <paramref name="reader"/> when this instance is disposed;
        /// otherwise, <c>false</c>.
        /// </param>
        public BinaryDataStream(DataReader reader, bool leaveOpen = false)
        {
            Contract.Requires<ArgumentNullException>(reader != null);

            this.reader = reader;
            this.mode = DataStreamMode.Read;
            this.leaveOpen = leaveOpen;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="BinaryDataStream"/> class based on the given
        /// <see cref="DataWriter"/>, and sets <see cref="StreamMode"/> to <see cref="DataStreamMode.Write"/>.
        /// </summary>
        /// <param name="writer">
        /// The <see cref="DataWriter"/> to use as the underlying stream.
        /// </param>
        /// <param name="leaveOpen">
        /// <c>true</c> to not dispose <paramref name="writer"/> when this instance is disposed;
        /// otherwise, <c>false</c>.
        /// </param>
        public BinaryDataStream(DataWriter writer, bool leaveOpen = false)
        {
            Contract.Requires<ArgumentNullException>(writer != null);

            this.writer = writer;
            this.mode = DataStreamMode.Write;
            this.leaveOpen = leaveOpen;
        }

        /// <inheritdoc cref="IDataStream.StreamMode"/>
        public DataStreamMode StreamMode
        {
            get { return this.mode; }
        }

        public bool IsReading
        {
            get { return this.mode == DataStreamMode.Read; }
        }

        public bool IsWriting
        {
            get { return this.mode == DataStreamMode.Write; }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref bool)"/>
        public void Stream(ref bool value)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read: { value = this.reader.ReadBoolean(); } break;
                case DataStreamMode.Write: { this.writer.WriteBoolean(value); } break;
            }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref byte)"/>
        public void Stream(ref byte value)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read: { value = this.reader.ReadByte(); } break;
                case DataStreamMode.Write: { this.writer.WriteByte(value); } break;
            }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref sbyte)"/>
        public void Stream(ref sbyte value)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read: { value = unchecked((sbyte) this.reader.ReadByte()); } break;
                case DataStreamMode.Write: { this.writer.WriteByte(unchecked((byte) this.reader.ReadByte())); } break;
            }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref short)"/>
        public void Stream(ref short value)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read: { value = this.reader.ReadInt16(); } break;
                case DataStreamMode.Write: { this.writer.WriteInt16(value); } break;
            }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref ushort)"/>
        public void Stream(ref ushort value)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read: { value = this.reader.ReadUInt16(); } break;
                case DataStreamMode.Write: { this.writer.WriteUInt16(value); } break;
            }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref int)"/>
        public void Stream(ref int value)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read: { value = this.reader.ReadInt32(); } break;
                case DataStreamMode.Write: { this.writer.WriteInt32(value); } break;
            }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref uint)"/>
        public void Stream(ref uint value)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read: { value = this.reader.ReadUInt32(); } break;
                case DataStreamMode.Write: { this.writer.WriteUInt32(value); } break;
            }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref long)"/>
        public void Stream(ref long value)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read: { value = this.reader.ReadInt64(); } break;
                case DataStreamMode.Write: { this.writer.WriteInt64(value); } break;
            }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref ulong)"/>
        public void Stream(ref ulong value)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read: { value = this.reader.ReadUInt64(); } break;
                case DataStreamMode.Write: { this.writer.WriteUInt64(value); } break;
            }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref float)"/>
        public void Stream(ref float value)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read: { value = this.reader.ReadSingle(); } break;
                case DataStreamMode.Write: { this.writer.WriteSingle(value); } break;
            }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref double)"/>
        public void Stream(ref double value)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read: { value = this.reader.ReadDouble(); } break;
                case DataStreamMode.Write: { this.writer.WriteDouble(value); } break;
            }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref Guid)"/>
        public void Stream(ref Guid value)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read: { value = this.reader.ReadGuid(); } break;
                case DataStreamMode.Write: { this.writer.WriteGuid(value); } break;
            }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref DateTimeOffset)"/>
        public void Stream(ref DateTimeOffset value)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read: { value = this.reader.ReadDateTime(); } break;
                case DataStreamMode.Write: { this.writer.WriteDateTime(value); } break;
            }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref TimeSpan)"/>
        public void Stream(ref TimeSpan value)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read: { value = this.reader.ReadTimeSpan(); } break;
                case DataStreamMode.Write: { this.writer.WriteTimeSpan(value); } break;
            }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref string)"/>
        public void Stream(ref string value)
        {
            // NOTE: null string = (value.charAt(0) == '\0x00' AND strlen(value) == 1)
            switch (this.mode)
            {
                case DataStreamMode.Read:
                {
                    byte[] buffer = new byte[this.reader.ReadUInt32()];
                    this.reader.ReadBytes(buffer);
                    if (buffer.Length == 1 && buffer[0] == 0x00) // read null string
                    {
                        value = null;
                    }
                    else
                    {
                        value = Encoding.Unicode.GetString(buffer);
                    }
                }
                break;

                case DataStreamMode.Write:
                {
                    if (value == null) // write null string
                    {
                        this.writer.WriteUInt32(1);
                        this.writer.WriteBytes(new[] { (byte) 0x00 });
                    }
                    else
                    {
                        uint stringSize = (uint) Encoding.Unicode.GetByteCount(value);
                        this.writer.WriteUInt32(stringSize);
                        this.writer.WriteBytes(Encoding.Unicode.GetBytes(value));
                    }
                }
                break;
            }
        }

        /// <inheritdoc cref="IDataStream.Stream(ref IBuffer)"/>
        public void Stream(ref IBuffer buffer)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read:
                {
                    uint length = this.reader.ReadUInt32();
                    buffer = this.reader.ReadBuffer(length);
                }
                break;

                case DataStreamMode.Write:
                {
                    this.writer.WriteUInt32(buffer.Length);
                    this.writer.WriteBuffer(buffer);
                }
                break;
            }
        }

        /// <inheritdoc cref="IDataStream.StreamBytes(byte[], uint, uint)"/>
        public void StreamBytes(byte[] value, int offset, int length)
        {
            switch (this.mode)
            {
                case DataStreamMode.Read:
                {
                    byte[] buffer = new byte[length];
                    this.reader.ReadBytes(buffer);
                    Array.Copy(buffer, 0, value, offset, length);
                }
                break;

                case DataStreamMode.Write:
                {
                    byte[] buffer = new byte[length];
                    Array.Copy(value, offset, buffer, 0, length);
                    this.writer.WriteBytes(buffer);
                }
                break;
            }
        }

        /// <inheritdoc cref="IDisposable.Dispose"/>
        public void Dispose()
        {
            if (!this.isDisposed)
            {
                if (!this.leaveOpen)
                {
                    if (this.mode == DataStreamMode.Read) this.reader.Dispose();
                    if (this.mode == DataStreamMode.Write) this.writer.Dispose();
                }
                this.isDisposed = true;
            }
        }
    }
}