using System;
using System.IO.Ports;
using System.Linq;

namespace XImaging.Automation.Library.HxDriverLib
{
    public class SerialHelper
    {
        private object m_wLock = new Object();
        private object m_rLock = new Object();
        private SerialPort serialPort;

        public string PortName
        {
            get
            {
                return serialPort.PortName;
            }
        }

        private SerialHelper(string port, int baudrate, 
            int databits, 
            StopBits stopbits,
            Parity parity)
        {
            serialPort = new SerialPort();

            serialPort.PortName = port;
            serialPort.BaudRate = baudrate;
            serialPort.DataBits = databits;
            serialPort.StopBits = stopbits;
            serialPort.Parity = parity;
            serialPort.ReadTimeout = 1000;
        }

        public static SerialHelper Create(string port, int baudrate,
            int databits=8,
            StopBits stopbits = System.IO.Ports.StopBits.One,
            Parity parity = System.IO.Ports.Parity.None)
        {
            return new SerialHelper(port, baudrate, databits, stopbits, parity);
        }

        public bool Open()
        {
            try
            {
                if (!IsOpen)
                {
                    serialPort.Open();
                }
                return true;
            }
            catch (UnauthorizedAccessException uex)
            {
                LogConstant.logger.Print(string.Format("无法打开串口连接-证权限错误:{0}", uex.ToString()));
                return false;
            }
            catch (System.IO.IOException iex)
            {
                LogConstant.logger.Print(string.Format("无法打开串口连接-IO通信错误:{0}", iex.ToString()));
                return false;
            }
            catch (Exception ex)
            {
                LogConstant.logger.Print(string.Format("无法打开串口连接:{0}", ex.ToString()));
                return false;
            }
        }

        public void Close()
        {
            if (IsOpen)
            {
                serialPort.Close();
            }
        }

        public bool IsOpen
        {
            get
            {
                return serialPort.IsOpen;
            }
        }

        public void Write(string command, bool hex=false, char sep=' ')
        {
            lock (m_wLock)
            {
                try
                {
                    if (hex)
                    {
                        byte[] b = command.Split(sep).AsParallel().Select(x => Convert.ToByte(x, 16)).ToArray();
                        serialPort.Write(b, 0, b.Length);
                    }
                    else
                    {
                        serialPort.Write(command);
                    }
                }
                catch (TimeoutException tex)
                {
                    LogConstant.logger.Print(string.Format("串口通信超时:{0}", tex.ToString()));
                    throw tex;
                }
                catch (Exception ex)
                {
                    LogConstant.logger.Print(ex.ToString());
                    throw ex;
                }
            }
        }

        public void Write(byte[] command, int offset, int length)
        {
            lock (m_wLock)
            {
                try
                {
                    serialPort.Write(command, offset, length);
                }
                catch (TimeoutException tex)
                {
                    LogConstant.logger.Print(string.Format("串口通信超时:{0}", tex.ToString()));
                    throw tex;
                }
                catch (Exception ex)
                {
                    LogConstant.logger.Print(ex.ToString());
                    throw ex;
                }
            }
        }

        public string Read()
        {
            lock (m_rLock)
            {
                try
                {
                    var response = serialPort.ReadLine();
                    return response;
                }
                catch (TimeoutException tex)
                {
                    LogConstant.logger.Print(string.Format("串口通信超时:{0}", tex.ToString()));
                    throw tex;
                }
                catch (Exception ex)
                {
                    LogConstant.logger.Print(ex.ToString());
                    throw ex;
                }
            }
        }

        public void Read(byte[] b, int offset, int count)
        {
            lock (m_rLock)
            {
                try
                {
                    this.serialPort.Read(b, offset, count);
                }
                catch (TimeoutException tex)
                {
                    LogConstant.logger.Print(string.Format("串口通信超时:{0}", tex.ToString()));
                    throw tex;
                }
                catch (Exception ex)
                {
                    LogConstant.logger.Print(ex.ToString());
                    throw ex;
                }
            }
        }

        public int ReadByte()
        {
            lock (m_rLock)
            {
                try
                {
                    int b = this.serialPort.ReadByte();
                    return b;
                }
                catch (TimeoutException tex)
                {
                    LogConstant.logger.Print(string.Format("串口通信超时:{0}", tex.ToString()));
                    throw tex;
                }
                catch (Exception ex)
                {
                    LogConstant.logger.Print(ex.ToString());
                    throw ex;
                }
            }
        }
    }
}