namespace Common.Hardware.SIRT
{
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.IO.Ports;
    using System.Threading;

    public class SIRTPort
    {
        private readonly SerialPort serialPort;
        private readonly bool log_RX_TX;

        public SIRTPort(string portName, bool log_RX_TX = true)
        {
            this.serialPort = new SerialPort(portName, 112500, Parity.None, 8, StopBits.One);
            this.log_RX_TX = log_RX_TX;
        }

        public bool IsOpen => this.serialPort.IsOpen;

        public string PortName => this.serialPort.PortName;

        public void Close()
        {
            this.LogMessage($"Closing: {this}");

            var waitEvent = new ManualResetEventSlim();
            var disposed = false;

            void SerialPortDisposed(object sender, EventArgs args)
            {
                disposed = true;
                this.LogMessage($"Disposed: {this}");
                waitEvent.Set();
            }

            this.serialPort.Disposed += SerialPortDisposed;

            try
            {
                this.serialPort.Close();
                waitEvent.Wait(5000);
            }
            catch (Exception e)
            {
                this.LogMessage(e);
            }

            this.serialPort.Disposed -= SerialPortDisposed;

            if (disposed)
            {
                this.LogMessage($"Closed: {this}");
            }
        }

        public void Open()
        {
            this.LogMessage($"Opening: {this}");

            try
            {
                this.serialPort.Open();
            }
            catch (Exception e)
            {
                this.LogMessage(e);
            }

            if (this.IsOpen)
            {
                this.LogMessage($"Opened: {this}");
            }
            else
            {
                this.Close();
            }
        }

        public IEnumerable<byte[]> GetEnumerable()
        {
            var manualResetEventSlim = new ManualResetEventSlim();

            void DataReceived(object sender, SerialDataReceivedEventArgs args)
            {
                if (args.EventType == SerialData.Chars)
                {
                    manualResetEventSlim.Set();
                }
            }

            this.serialPort.DataReceived += DataReceived;

            var bufferSize = this.serialPort.ReadBufferSize;
            var buffer = new byte[bufferSize];
            var length = default(int);

            while (this.serialPort.IsOpen)
            {
                buffer = new byte[bufferSize];
                length = this.serialPort.Read(buffer, 0, bufferSize);

                Array.Resize(ref buffer, length);

                yield return buffer;

                manualResetEventSlim.Reset();
                manualResetEventSlim.Wait();
            }

            this.serialPort.DataReceived -= DataReceived;
        }

        public IEnumerable<byte[]> ReadBytes()
        {
            var bufferSize = this.serialPort.ReadBufferSize;
            var buffer = default(byte[]);
            var length = default(int);

            while (this.serialPort.IsOpen)
            {
                buffer = new byte[bufferSize];

                try
                {
                    length = this.serialPort.Read(buffer, 0, bufferSize);
                }
                catch (IOException e)
                {
                    break;
                }
                catch (Exception e)
                {
                    this.LogMessage(e);

                    continue;
                }

                Array.Resize(ref buffer, length);

                yield return buffer;

                if (this.log_RX_TX)
                {
                    this.LogMessage($"RX|{BitConverter.ToString(buffer)}");
                }
            }
        }

        public override string ToString()
            => $"{this.serialPort.PortName}, " 
             + $"{this.serialPort.BaudRate}, " 
             + $"{this.serialPort.Parity}, " 
             + $"{this.serialPort.DataBits}, " 
             + $"{this.serialPort.StopBits}";

        public void Write(byte[] bytes)
        {
            try
            {
                this.serialPort.Write(bytes, 0, bytes.Length);

                if (this.log_RX_TX)
                {
                    this.LogMessage($"TX|{BitConverter.ToString(bytes)}");
                }
            }
            catch (Exception e)
            {
                this.LogMessage(e);
            }
        }

        private void LogMessage(object message)
            => SIRTLogger.LogMessage($"{nameof(SIRTPort)}|{this.PortName}|{message}");
    }
}