using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.IO.Ports;

namespace StandardLibrary
{
    interface IUART
    {
        /// <summary>
        /// 获取或设置串口的串口号
        /// </summary>
        string PortName { get; set; }

        /// <summary>
        /// 获取或设置波特率
        /// </summary>
        int BaudRate { get; set; }

        /// <summary>
        /// 获取或设置串口的校验位
        /// </summary>
        Parity Parity { get; set; }

        /// <summary>
        /// 获取或设置串口的数据位
        /// </summary>
        int DataBits { get; set; }

        /// <summary>
        /// 获取或设置串口的停止位
        /// </summary>
        StopBits StopBits { get; set; }

        /// <summary>
        /// 获取串口的打开状态
        /// </summary>
        bool OpenStatus { get; }

        /// <summary>
        /// 打开串口
        /// </summary>
        /// <returns>true 打开成功，false 打开失败</returns>
        bool Open();

        /// <summary>
        /// 关闭串口
        /// </summary>
        /// <returns>true 关闭成功，false 关闭异常</returns>
        bool Close();

        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="message">字符串数据</param>
        /// <returns>true 发送成功，false 发送失败</returns>
        bool Send(string message);

        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="message">字节数组数据</param>
        /// <returns>true 发送成功，false 发送失败</returns>
        bool Send(byte[] message);

        /// <summary>
        /// 接收数据解码
        /// </summary>
        /// <param name="data">接收数据字节数组</param>
        void ReceiveDataDecode(byte[] data);
    }

   public class UART : IUART
    {
        public int UartIndex;
        public object obj = null;
        #region 字段
        /// <summary>
        /// 实例化串口
        /// </summary>
        protected SerialPort serialPort = new SerialPort();

        /// <summary>
        /// 接收数据事件
        /// </summary>
        public Action<int, byte[]> ReceiveDataDecodeEvent;
        #endregion

        #region 属性
        /// <summary>
        /// 获取或设置串口的串口号
        /// </summary>
        public string PortName
        {
            get { return serialPort.PortName; }
            set { serialPort.PortName = value; }
        }

        /// <summary>
        /// 获取或设置串口的波特率
        /// </summary>
        public int BaudRate
        {
            get { return serialPort.BaudRate; }
            set { serialPort.BaudRate = value; }
        }

        /// <summary>
        /// 获取或设置串口的校验位
        /// </summary>
        public Parity Parity
        {
            get { return serialPort.Parity; }
            set { serialPort.Parity = value; }
        }

        /// <summary>
        /// 获取或设置串口的数据位
        /// </summary>
        public int DataBits
        {
            get { return serialPort.DataBits; }
            set { serialPort.DataBits = value; }
        }

        /// <summary>
        /// 获取或设置串口的停止位
        /// </summary>
        public StopBits StopBits
        {
            get { return serialPort.StopBits; }
            set { serialPort.StopBits = value; }
        }

        /// <summary>
        /// 获取串口的打开状态
        /// </summary>
        public bool OpenStatus
        {
            get { return serialPort.IsOpen; }
        }
        #endregion

        /// <summary>
        /// 构造函数,设置串口属性及订阅接收事件
        /// </summary>
        /// <param name="portName">串口号</param>
        /// <param name="baudRate">波特率</param>
        /// <param name="parity">校验位</param>
        /// <param name="dataBits">数据位</param>
        /// <param name="stopBits">停止位</param>
        public UART(string portName, int baudRate, Parity parity, int dataBits, StopBits stopBits, int uartIndex)
        {
            this.UartIndex = uartIndex; //编号
            this.PortName = portName;   //串口号
            this.BaudRate = baudRate;   //波特率
            this.Parity = parity;       //校验位
            this.DataBits = dataBits;   //数据位
            this.StopBits = stopBits;   //停止位
            serialPort.DataReceived += Received;//订阅串口接收事件
        }

        /// <summary>
        /// 打开串口
        /// </summary>
        /// <returns>true 打开成功，false 打开失败</returns>
        public virtual bool Open()
        {
            string[] str = SerialPort.GetPortNames();   //获取当前计算机的所有串口号
            if (str != null && str.Contains(PortName))  //判断当前计算机是否有串口以及是否存在将要打开的串口
            {
                try
                {
                    serialPort.ReceivedBytesThreshold = 1;  //设置接收事件字节数
                    if (serialPort.IsOpen) serialPort.Close();
                    serialPort.Open();                      //打开串口
                    serialPort.DiscardInBuffer();           //清空接收缓存区的数据
                    return true;                            //串口打开成功
                }
                catch (Exception) { return false; }         //异常，串口打开失败
            }
            else { return false; }                          //当前计算机没有串口或将要打开的串口不存在，串口打开失败
        }

        /// <summary>
        /// 关闭串口
        /// </summary>
        /// <returns>true 关闭成功，false 关闭失败</returns>
        public virtual bool Close()
        {
            try
            {
                serialPort.Close();     //关闭串口连接
                return true;            //关闭成功
            }
            catch { return false; }     //异常，关闭失败
        }

        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="message">字符串数据</param>
        /// <returns>true 发送成功，false 发送失败</returns>
        public virtual bool Send(string message)
        {
            try
            {
                serialPort.Write(message);  //发送字符串数据
                return true;                //发送成功
            }
            catch { return false; }         //异常，发送失败
        }

        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="message">字节数组数据</param>
        /// <returns>true 发送成功，false 发送失败</returns>
        public virtual bool Send(byte[] message)
        {
            try
            {
                serialPort.Write(message, 0, message.Length);   //发送字节数组数据
                return true;                //发送成功
            }
            catch { return false; }         //异常，发送失败
        }

        /// <summary>
        /// 接收数据
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        //protected virtual void Received(object sender, SerialDataReceivedEventArgs e)
        //{
        //    int length = serialPort.BytesToRead;
        //    byte[] buf = new byte[length];  //创建接收数据存储区
        //    serialPort.Read(buf, 0, length);            //将接收缓存区中的数据读取到数据存储区
        //    serialPort.DiscardInBuffer();                   //清空接收缓存区的数据
        //    ReceiveDataDecode(buf);                         //调用接收数据解码函数，处理接收数据
        //}
        protected virtual void Received(object sender, SerialDataReceivedEventArgs e)
        {
            List<byte> tempBytes = new List<byte>();
            while(serialPort.BytesToRead > 0)
            {
                byte[] buffer = new byte[serialPort.BytesToRead];
                serialPort.Read(buffer, 0, buffer.Length);
                foreach(byte b in  buffer)
                {
                    tempBytes.Add(b);
                }
                Thread.Sleep(20);
            }
            byte[] dataBuf = tempBytes.ToArray();
            ReceiveDataDecode(dataBuf);                         //调用接收数据解码函数，处理接收数据
        }

        /// <summary>
        /// 接收数据解码
        /// </summary>
        /// <param name="data">接收到的数据</param>
        public virtual void ReceiveDataDecode(byte[] data)
        {
            if (ReceiveDataDecodeEvent != null)     //判断事件是否被订阅
                ReceiveDataDecodeEvent(this.UartIndex,data);       //如果被订阅，就发布事件
        }
    }
}