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

namespace OnlineStore.Common
{
    public class SerialBean
    {
        #region 全部变量
        public static readonly ILog LOGGER = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
        private SerialPort _serialPort = null;
        //定义委托
        public delegate void SerialPortDataReceiveEventArgs(string portName, object sender, SerialDataReceivedEventArgs e, byte[] bits);
        //定义接收数据事件
        public event SerialPortDataReceiveEventArgs DataReceived;
        //定义接收错误事件
        //public event SerialErrorReceivedEventHandler Error;
        //接收事件是否有效 false表示有效
        public bool ReceiveEventFlag = false;
        
        #endregion

        #region 获取串口名
        private string protName;
        public string PortName
        {
            get { return _serialPort.PortName; }
            set
            {
                _serialPort.PortName = value;
                protName = value;
            }
        }
        #endregion

        #region 获取比特率
        private int baudRate;
        public int BaudRate
        {
            get { return _serialPort.BaudRate; }
            set
            {
                _serialPort.BaudRate = value;
                baudRate = value;
            }
        }
        #endregion
        
        #region 默认构造函数
        ///// <summary>
        ///// 默认构造函数，操作COM1，速度为9600，没有奇偶校验，8位字节，停止位为1 "COM1", 9600, Parity.None, 8, StopBits.One
        ///// </summary>
        //public SerialBean()
        //{
        //    _serialPort = new SerialPort();
        //}
        #endregion
        
        #region 构造函数
        ///// <summary>
        ///// 构造函数,
        ///// </summary>
        ///// <param name="comPortName"></param>
        //public SerialBean(string comPortName)
        //{
        //    _serialPort = new SerialPort(comPortName);
        //    _serialPort.BaudRate = 9600;
        //    _serialPort.Parity = Parity.Even;
        //    _serialPort.DataBits = 8;
        //    _serialPort.StopBits = StopBits.One;
        //    _serialPort.Handshake = Handshake.None;
        //    _serialPort.RtsEnable = true;
        //    _serialPort.ReadTimeout = 2000;
        //    setSerialPort();
        //}
        #endregion
        
        #region 构造函数,可以自定义串口的初始化参数
        /// <summary>
        /// 构造函数,可以自定义串口的初始化参数
        /// </summary>
        /// <param name="comPortName">需要操作的COM口名称</param>
        /// <param name="baudRate">COM的速度</param>
        /// <param name="parity">奇偶校验位</param>
        /// <param name="dataBits">数据长度</param>
        /// <param name="stopBits">停止位</param>
        public SerialBean(string comPortName, int baudRate, Parity parity, int dataBits, StopBits stopBits)
        {
            _serialPort = new SerialPort(comPortName, baudRate, parity, dataBits, stopBits);
            _serialPort.RtsEnable = true;  //自动请求
            _serialPort.ReadTimeout = 3000;//超时
            setSerialPort();
        }
        #endregion
       
        #region 析构函数
        /// <summary>
        /// 析构函数，关闭串口
        /// </summary>
        ~SerialBean()
        {
            if (_serialPort.IsOpen)
                _serialPort.Close();
        }
        #endregion
       
        #region 设置串口参数
        /// <summary>
        /// 设置串口参数
        /// </summary>
        /// <param name="comPortName">需要操作的COM口名称</param>
        /// <param name="baudRate">COM的速度</param>
        /// <param name="dataBits">数据长度</param>
        /// <param name="stopBits">停止位</param>
        public void setSerialPort(string comPortName, int baudRate, int dataBits, int stopBits)
        {

            if (_serialPort.IsOpen)
                _serialPort.Close();
            _serialPort.PortName = comPortName;

            _serialPort.BaudRate = baudRate;
            _serialPort.Parity = Parity.None;
            _serialPort.DataBits = dataBits;
            _serialPort.StopBits = (StopBits)stopBits;
            _serialPort.Handshake = Handshake.None;
            _serialPort.RtsEnable = false;
            _serialPort.ReadTimeout = 3000;
            _serialPort.NewLine = "/r/n";
            setSerialPort();
        }
        #endregion
        #region 设置接收函数
        /// <summary>
        /// 设置串口资源,还需重载多个设置串口的函数
        /// </summary>
        void setSerialPort()
        {
            if (_serialPort != null)
            {
                //设置触发DataReceived事件的字节数为1
                _serialPort.ReceivedBytesThreshold = 1;
                //接收到一个字节时，也会触发DataReceived事件
                _serialPort.DataReceived += new SerialDataReceivedEventHandler(_serialPort_DataReceived);
                //接收数据出错,触发事件
                _serialPort.ErrorReceived += new SerialErrorReceivedEventHandler(_serialPort_ErrorReceived);
                //打开串口
                //openPort();
            }
        }

        #endregion

        #region 打开串口资源
        /// <summary> 
        /// 打开串口资源 
        /// <returns>返回bool类型</returns>  
        /// </summary> 
        public bool openPort()
        {
            bool ok = false;
            //如果串口是打开的，先关闭 
            if (_serialPort.IsOpen)
                _serialPort.Close();
            try
            {
                //打开串口
                _serialPort.Open();
                ok = true;
            }
            catch (Exception Ex)
            {
                LogUtil.error(LOGGER, Ex.ToString());
                //throw Ex;
            }
            return ok;
        }
        #endregion
     
        #region 关闭串口
        /// <summary> 
        /// 关闭串口资源,操作完成后,一定要关闭串口 
        /// </summary> 
        public void closePort()
        {
            //如果串口处于打开状态,则关闭 
            if (_serialPort.IsOpen)
                _serialPort.Close();
        }

        public void clearInBuffer()
        {
            if (_serialPort.IsOpen)
            {
                _serialPort.DiscardInBuffer();
            }
        }
        public void clearOutBuffer()
        {
            if (_serialPort.IsOpen)
            {
                _serialPort.DiscardOutBuffer();
            }
        }
        #endregion

        #region 接收串口数据事件

        private object LockReviceObj = "";
        /// <summary>
        /// 接收串口数据事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void _serialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            lock (LockReviceObj)
            {
                //禁止接收事件时直接退出
                if (ReceiveEventFlag)
                {
                    return;
                }
                try
                {
                    System.Threading.Thread.Sleep(20);
                    byte[] _data = new byte[_serialPort.BytesToRead];
                    _serialPort.Read(_data, 0, _data.Length);
                    if (_data.Length == 0) { return; }
                    if (DataReceived != null)
                    {
                        DataReceived(_serialPort.PortName, sender, e, _data);
                    }
                    _serialPort.DiscardInBuffer();  //清空接收缓冲区  
                }
                catch (Exception ex)
                {
                    LogUtil.error(LOGGER, ex.ToString());
                }
            }
        }

        #endregion
        #region 接收数据出错事件
        /// <summary>
        /// 接收数据出错事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void _serialPort_ErrorReceived(object sender, SerialErrorReceivedEventArgs e)
        {
        }

        #endregion

        /// <summary>
        /// 发送命令
        /// </summary>
        /// <param name="SendData">发送数据</param>
        /// <param name="ReceiveData">接收数据</param>
        /// <param name="Overtime">超时时间</param>
        /// <param name="ReceiveLength">接收数据长度</param>
        /// <returns></returns>
        public int SendCommand(byte[] SendData, ref  byte[] ReceiveData, int Overtime, int ReceiveLength)
        {
            if (_serialPort.IsOpen)
            {
                try
                {
                    lock (LockReviceObj)
                    {
                        ReceiveEventFlag = true;        //关闭接收事件
                        _serialPort.DiscardInBuffer();  //清空接收缓冲区           
                        _serialPort.Write(SendData, 0, SendData.Length);
                        int num = 0, ret = 0;
                        System.Threading.Thread.Sleep(10);
                        ReceiveEventFlag = false;      //打开事件
                        if (ReceiveData == null)
                        {
                            ReceiveData = new byte[ReceiveLength];
                        }
                        while (num++ < Overtime)
                        {

                            if (_serialPort.BytesToRead >= ReceiveData.Length)
                                break;
                            System.Threading.Thread.Sleep(10);
                        }
                        if (_serialPort.BytesToRead >= ReceiveData.Length)
                        {

                            ret = _serialPort.Read(ReceiveData, 0, ReceiveData.Length);
                        }
                        else
                        {
                            ret = _serialPort.Read(ReceiveData, 0, _serialPort.BytesToRead);
                        }

                        ReceiveEventFlag = false;      //打开事件
                        return ret;
                    }
                }
                catch (Exception ex)
                {
                    ReceiveEventFlag = false;
                    throw ex;
                }
            }
            return -1;
        }

        #region 发送数据string类型
        public void SendData(string data)
        {                        //发送数据
            //禁止接收事件时直接退出
            if (ReceiveEventFlag)
            {
                return;
            }

            if (_serialPort.IsOpen)
            {
                _serialPort.Write(data);
            }
        }
        #endregion
        #region 发送数据byte类型

        /// <summary>
        /// 数据发送
        /// </summary>
        /// <param name="data">要发送的数据字节</param>
        public void SendData(byte[] data, int offset, int count)
        {

            string strSend = "";
            for (int i = 0; i < data.Length; i++)
            {
                strSend += string.Format("{0:X2} ", data[i]);
            }
            LOGGER.Debug("【" + _serialPort.PortName + "】发送数据【" + strSend + "】");
            //禁止接收事件时直接退出
            if (ReceiveEventFlag)
            {
                return;
            }
            try
            {
                if (_serialPort.IsOpen)
                {
                    //_serialPort.DiscardInBuffer();//清空接收缓冲区
                    _serialPort.Write(data, offset, count);
                }
            }
            catch (Exception ex)
            {
                _serialPort.DiscardOutBuffer();
                throw ex;
            }
        }
        #endregion
        #region 发送命令
        /// <summary>
        /// 发送命令
        /// </summary>
        /// <param name="SendData">发送数据</param>
        /// <param name="ReceiveData">接收数据</param>
        /// <param name="Overtime">超时时间</param>
        /// <returns></returns>
        public int SendCommand(byte[] SendData, ref  byte[] ReceiveData, int Overtime)
        {
            if (_serialPort.IsOpen)
            {
                try
                {
                    ReceiveEventFlag = true;        //关闭接收事件
                    _serialPort.DiscardInBuffer();  //清空接收缓冲区           
                    _serialPort.Write(SendData, 0, SendData.Length);
                    int num = 0, ret = 0;
                    System.Threading.Thread.Sleep(10);
                    ReceiveEventFlag = false;      //打开事件
                    while (num++ < Overtime)
                    {

                        if (_serialPort.BytesToRead >= ReceiveData.Length)
                            break;
                        System.Threading.Thread.Sleep(10);
                    }
                    if (_serialPort.BytesToRead >= ReceiveData.Length)
                    {

                        ret = _serialPort.Read(ReceiveData, 0, ReceiveData.Length);
                    }
                    else
                    {
                        ret = _serialPort.Read(ReceiveData, 0, _serialPort.BytesToRead);
                    }

                    ReceiveEventFlag = false;      //打开事件
                    return ret;
                }
                catch (Exception ex)
                {
                    ReceiveEventFlag = false;
                    throw ex;
                }
            }
            return -1;
        }
        #endregion
        #region 获取串口
        /// <summary>
        /// 获取所有已连接短信猫设备的串口
        /// </summary>
        /// <returns></returns>
        public string[] serialsIsConnected()
        {
            List<string> lists = new List<string>();
            string[] seriallist = getSerials();
            foreach (string s in seriallist)
            {
            }
            return lists.ToArray();
        }
        #endregion
        #region 获取当前全部串口资源
        /// <summary>
        /// 获得当前电脑上的所有串口资源
        /// </summary>
        /// <returns></returns>
        public string[] getSerials()
        {
            return SerialPort.GetPortNames();
        }
        #endregion
        #region 字节型转换16
        /// <summary>
        /// 把字节型转换成十六进制字符串
        /// </summary>
        /// <param name="InBytes"></param>
        /// <returns></returns>
        public static string ByteToString(byte[] InBytes)
        {
            string StringOut = "";
            foreach (byte InByte in InBytes)
            {
                StringOut = StringOut + String.Format("{0:X2} ", InByte);
            }
            return StringOut;
        }
        #endregion

        #region 十六进制字符串转字节型
        
        /// <summary>
        /// 打包方法，可以将十六制字符串转成byte[] ，字符串没有空格
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        //public static byte[] StringToByte(string s)
        //{
        //    string temps = ReplaceSpace(s);
        //    if (temps.Length % 2 != 0)
        //    {
        //        temps = "0" + temps;
        //    }
        //    byte[] tempb = new byte[50];
        //    int j = 0;
        //    for (int i = 0; i < temps.Length; i = i + 2, j++)
        //    {
        //        tempb[j] = Convert.ToByte(temps.Substring(i, 2), 16);
        //    }
        //    byte[] send = new byte[j];
        //    Array.Copy(tempb, send, j);
        //    return send;
        //}

        //除去空格
        public static string ReplaceSpace(string str)
        {
            string putout = "";
            for (int i = 0; i < str.Length; i++)
            {
                if (str[i] != ' ')
                { putout += str[i]; }
            }
            return putout;
        }
        #endregion
       
        #region 字节型转十六进制字符串
        /// <summary>
        /// 字节数组转16进制字符串
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static string byteToHexStr(byte[] bytes)
        {
            string returnStr = "";
            if (bytes != null)
            {
                for (int i = 0; i < bytes.Length; i++)
                {
                    returnStr += bytes[i].ToString("X2");
                }
            }
            return returnStr;
        }
        #endregion

        #region 计算校验码

        public static void CalculateBCC(byte[] pByte, int nNumberOfBytes, out ushort pChecksum)
        {
            byte check = 0;
            check = (byte)(pByte[0] ^ (pByte[1]));
            for (int i = 2; i < pByte.Length; i++)
            {
                check = (byte)(check ^ (pByte[i]));
            }
            pChecksum = check;
        }

        //public static void CalculateCRC(byte[] pByte, int nNumberOfBytes, out ushort pChecksum)
        //{
        //    int nBit;
        //    ushort nShiftedBit;
        //    pChecksum = 0xFFFF;

        //    for (int nByte = 0; nByte < nNumberOfBytes; nByte++)
        //    {
        //        pChecksum ^= pByte[nByte];
        //        for (nBit = 0; nBit < 8; nBit++)
        //        {
        //            if ((pChecksum & 0x1) == 1)
        //            {
        //                nShiftedBit = 1;
        //            }
        //            else
        //            {
        //                nShiftedBit = 0;
        //            }
        //            pChecksum >>= 1;
        //            if (nShiftedBit != 0)
        //            {
        //                pChecksum ^= 0xA001;
        //            }
        //        }
        //    }
        //}

        #endregion
    }
}