//            Copyright Keysight Technologies 2012-2019
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
using System;
using System.IO;

namespace OpenTap
{
    internal class HybridStream : Stream
    {
        private class MemViewStream : Stream
        {
            private byte[] data;
            private long length, position;

            public MemViewStream(byte[] data, long length)
            {
                this.data = data;
                this.length = length;
            }

            public override bool CanRead { get { return true; } }
            public override bool CanSeek { get { return true; } }
            public override bool CanWrite { get { return false; } }
            public override long Length { get { return length; } }

            public override long Position
            {
                get { return position; }
                set
                {
                    if (value != position)
                    {
                        if (value < 0) throw new InvalidOperationException("Invalid position.");
                        if (value > length) throw new InvalidOperationException("Invalid position.");

                        position = value;
                    }
                }
            }

            public override void Flush()
            {
            }

            public override int Read(byte[] buffer, int offset, int count)
            {
                if (count < 0) throw new ArgumentOutOfRangeException("count");
                if (offset < 0) throw new ArgumentOutOfRangeException("count");

                long rest = length - position;
                if (count > rest) count = (int)rest;

                if (count > 0)
                {
                    Array.Copy(data, position, buffer, offset, count);
                    position += count;
                }

                return count;
            }

            public override long Seek(long offset, SeekOrigin origin)
            {
                long newpos = position;

                switch (origin)
                {
                    case SeekOrigin.Begin:
                        newpos = offset;
                        break;
                    case SeekOrigin.Current:
                        newpos = position + offset;
                        break;
                    case SeekOrigin.End:
                        newpos = length + offset;
                        break;
                }

                if (newpos < 0) newpos = 0;
                else if (newpos > length) newpos = length;

                position = newpos;
                return position;
            }

            public override void SetLength(long value)
            {
                throw new NotSupportedException();
            }

            public override void Write(byte[] buffer, int offset, int count)
            {
                throw new NotSupportedException();
            }
        }

        #region Private
        private object lockObject = new object();

        private Stream stream = new MemoryStream();

        /// <summary> Create a new instance with default parameters. </summary>
        public HybridStream() : this(FileSystemHelper.CreateTempFile(".opentap-log.txt"), 1024 * 1024)
        {

        }

        public HybridStream(string filename, int threshold)
        {
            this.Filename = filename;
            this.MemoryThreshold = threshold;
        }
        #endregion

        public long MemoryThreshold { get; set; }
        public string Filename { get; set; }

        #region Overrides
        public override bool CanRead { get { return false; } }
        public override bool CanSeek { get { return false; } }
        public override bool CanWrite { get { return true; } }

        public override int Read(byte[] buffer, int offset, int count) { throw new NotSupportedException(); }
        public override long Seek(long offset, SeekOrigin origin) { throw new NotSupportedException(); }
        public override void SetLength(long value) { throw new NotSupportedException(); }

        public override long Length { get { return GetLength(); } }
        public override long Position { get { return GetPosition(); } set { throw new NotSupportedException(); } }
        #endregion

        private long GetPosition()
        {
            lock (lockObject)
                return stream.Length;
        }

        private long GetLength()
        {
            lock (lockObject)
                return stream.Length;
        }

        public override void Flush()
        {
            lock (lockObject)
                stream.Flush();
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            lock (lockObject)
            {
                stream.Write(buffer, offset, count);
                if (stream is MemoryStream)
                    checkTrigger();
            }
        }

        private void checkTrigger()
        {
            if (stream.Length >= MemoryThreshold)
                ConvertToFile();
        }

        public void ConvertToFile()
        {
            lock (lockObject)
            {
                var fileStream = new FileStream(Filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite, 1024 * 16, FileOptions.DeleteOnClose);
                fileStream.Write(((MemoryStream)stream).GetBuffer(), 0, (int)stream.Length);
                stream.Dispose();
                stream = fileStream;
            }
        }

        public Stream GetViewStream()
        {
            lock (lockObject)
            {
                if (stream is FileStream)
                    return new FileStream(Filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
                return new MemViewStream(((MemoryStream)stream).GetBuffer(), stream.Length);
            }
        }

        public override void Close()
        {
            lock (lockObject)
            {
                if (stream != null)
                {
                    stream.Close();
                    stream = null;
                }
            }

            base.Close();
        }
    }

}