using DevicesService.Commen;
using Functions.FileExt;
using NAudio.CoreAudioApi;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using SkiaSharp;
using System;
using System.Buffers.Text;
using System.Collections.Generic;
using System.ComponentModel.Design;
using System.Configuration;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.IO.Ports;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Timers;
using System.Xml.Linq;
using static System.Net.Mime.MediaTypeNames;
using Timer = System.Timers.Timer;
namespace DevicesService.Common
{
    public class COMUtils
    {
        private SerialPort serialPort = new SerialPort();
        private ScriptCallbackObject scriptCallback = new ScriptCallbackObject();
        private int maxChunkSize = 10240;
        public string _json = string.Empty;
        public COMUtils()
        {
            try
            {
                string COMName = ConfigurationManager.AppSettings["COMName"].ToString();
                // 设置COM口，波特率，奇偶校验，数据位，停止位
                serialPort.PortName = COMName; // 请替换为你的串口名称
                serialPort.BaudRate = 115200; // 设置波特率
                serialPort.Parity = Parity.None;
                serialPort.DataBits = 8;
                //serialPort.WriteBufferSize =40960;
                // serialPort.ReadBufferSize = 40960;
                serialPort.StopBits = StopBits.One;
                serialPort.Handshake = Handshake.None;
                serialPort.Encoding = Encoding.UTF8; // 设置正确的编码
                serialPort.DtrEnable = true; //启用控制终端就续信号
                //serialPort.RtsEnable = true; //启用请求发送信号
                serialPort.NewLine = "\n";
                serialPort.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
                if (!serialPort.IsOpen)
                {
                    serialPort.Open();
                }
                Timer timer = new Timer(1000);//1秒钟的时间间隔
                timer.Elapsed += OnTimedEvent;
                timer.AutoReset = true;//重复执行
                timer.Enabled = true;//启动定时器
                ////Log.Info("硬件服务启动成功");
            }
            catch (Exception ex)
            {
                Log.Error("服务启动异常: " + ex.Message + "");
            }
        }

        /// <summary>
        /// 接受数据
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public static string bsid = string.Empty;
        public static string bsext = string.Empty;
        public static string bspath = string.Empty;
        public static bool sfjswc = false;
        private void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            try
            {
                SerialPort sp = (SerialPort)sender;
                string indata = sp.ReadExisting();
                if (!string.IsNullOrEmpty(indata))
                {
                    if (indata.Contains("\n"))
                    {
                        indata = _json + indata;
                        string result = Util.Base64str2(indata);
                        ////Log.Info("接收到COM口传来数据：" + result);
                        if (!string.IsNullOrEmpty(result))
                        {
                            JObject jo = (JObject)JsonConvert.DeserializeObject(result);
                            int type = Convert.ToInt32(jo["type"].ToString());
                            string param = jo["param"].ToString();
                            string resultback = string.Empty;
                            string base64 = string.Empty;
                            string data = string.Empty;
                            string callback = jo["callback"].ToString();
                            JObject joparam;
                            switch (type)
                            {
                                //{"type":"1","param":{"data":""}}
                                case Func.IDCardRead:
                                    #region 读取身份证
                                    joparam = (JObject)JsonConvert.DeserializeObject(param);
                                    data = joparam["data"].ToString();
                                    resultback = scriptCallback.IDCardRead(data, callback);
                                   Console.WriteLine(resultback);
                                    //Log.Info("读取身份证 返回数据：" + resultback);
                                    base64 = Util.str2Base64(resultback);
                                    //向com对方发送数据
                                    SendData(base64);
                                    #endregion
                                    break;
                                //{"type":"2","param":{"ph":"A012","ddrs":"10","qrcode":"www.baidu.com/s?wd=国家赔偿","ywmc":"国家赔偿"}}
                                case Func.SendByPrint:
                                    #region 打印排队票据
                                    joparam = (JObject)JsonConvert.DeserializeObject(param);
                                    string ph = joparam["ph"].ToString();
                                    string ddrs = joparam["ddrs"].ToString();
                                    string qrcode = joparam["qrcode"].ToString();
                                    string ywmc = joparam["ywmc"].ToString();
                                    resultback = scriptCallback.SendByPrint(ph, ddrs, qrcode, ywmc, callback);
                                    ////Log.Info("打印排队票据 返回数据：" + resultback);
                                    base64 = Util.str2Base64(resultback);
                                    //向com对方发送数据
                                    SendData(base64);
                                    #endregion
                                    break;
                                //{"type":"4","param":{"content":"欢迎使用阿凯思控诉业务一体机","phone":"13333333333"}}
                                case Func.SendSSM:
                                    #region 发送短信
                                    joparam = (JObject)JsonConvert.DeserializeObject(param);
                                    string content = joparam["content"].ToString();
                                    string phone = joparam["phone"].ToString();
                                    resultback = scriptCallback.SendSSM(content, phone, callback);
                                    ////Log.Info("发送短信 返回数据：" + resultback);
                                    base64 = Util.str2Base64(resultback);
                                    //向com对方发送数据
                                    SendData(base64);
                                    #endregion
                                    break;
                                //{"type":"5","param":{"url":"http://192.168.0.34:92/api/UploadFP/UploadFP"}}
                                case Func.openCamera:
                                    #region 打开高拍仪并且进行快速扫描文件
                                    joparam = (JObject)JsonConvert.DeserializeObject(param);
                                    data = joparam["url"].ToString();
                                    resultback = scriptCallback.openCamera(data, callback);
                                    ////Log.Info("打开高拍仪并且进行快速扫描文件 返回数据：" + resultback);
                                    //base64 = Util.str2Base64(resultback);
                                    //向com对方发送数据
                                    SendData(resultback);
                                    #endregion
                                    break;
                                //{"type":"6","param":{"data":""}}
                                case Func.OpenSign:
                                    #region 打开签字版数据
                                    joparam = (JObject)JsonConvert.DeserializeObject(param);
                                    data = joparam["data"].ToString();
                                    resultback = scriptCallback.OpenSign(data, callback);
                                    ////Log.Info("打开签字版数据 返回数据：" + resultback);
                                    base64 = Util.str2Base64(resultback);
                                    //向com对方发送数据
                                    SendData(base64);
                                    #endregion
                                    break;
                                //{"type":"7","param":{"data":""}}
                                case Func.CloseSign:
                                    #region 关闭签字版数据
                                    joparam = (JObject)JsonConvert.DeserializeObject(param);
                                    data = joparam["data"].ToString();
                                    resultback = scriptCallback.CloseSign(data, callback);
                                    ////Log.Info("关闭签字版数据 返回数据：" + resultback);
                                    base64 = Util.str2Base64(resultback);
                                    //向com对方发送数据
                                    SendData(base64);
                                    #endregion
                                    break;
                                //{"type":"8","param":{"url":"http://192.168.0.34:92/api/UploadFP/UploadFP"}}
                                case Func.GetSignData:
                                    #region 获取签字版数据
                                    string sourcepaht = Environment.CurrentDirectory + "\\fiveInch.png";
                                    FileInfo fileInfo = new FileInfo(sourcepaht);
                                    if (fileInfo.Exists)
                                    {
                                        double size = fileInfo.Length / 1024.0;
                                        if (size > 10)
                                        {
                                            FileStream fs1 = fileInfo.OpenRead();
                                            fs1.Close();
                                            resultback = Util.ImgToBase64String(sourcepaht);
                                            int width = 800;
                                            int height = 394;
                                            using (Bitmap blankImage = new Bitmap(width, height))
                                            {
                                                // 设置图片背景为完全透明
                                                using (Graphics g = Graphics.FromImage(blankImage))
                                                {
                                                    // 使用白色背景填充图片
                                                    g.Clear(Color.Transparent);
                                                }
                                                // 保存图片到文件系统
                                                blankImage.Save(sourcepaht);
                                            }
                                        }
                                        else
                                        {
                                            resultback = Util.str2Base64("400");
                                        }
                                    }
                                    else
                                    {
                                        resultback = Util.str2Base64("400");
                                    }
                                    ////Log.Info("获取签字版数据 返回数据：" + resultback);
                                    // base64 = Util.str2Base64(resultback);
                                    //向com对方发送数据
                                    SendData(resultback);
                                    #endregion
                                    break;
                                default:
                                    string str = "{\"callback\":\"" + "callback" + "\",\"message\":\"fali\",\"code\":\"400\",\"status\":false,\"data\":\"" + "调用方法不存在" + "\"}";
                                    base64 = Util.str2Base64(str);
                                    SendData(base64);
                                    break;
                            }
                        }
                        else
                        {
                            string str = "{\"callback\":\"" + "callback" + "\",\"message\":\"fali\",\"code\":\"400\",\"status\":false,\"data\":\"" + "参数不能为空" + "\"}";
                            string base64 = Util.str2Base64(str);
                            SendData(base64);
                        }
                        _json = string.Empty;
                    }
                    else
                    {
                        _json = _json + indata;
                    }
                }

            }
            catch (Exception ex)
            {
                _json = string.Empty;
                string str = "{\"callback\":\"" + "callback" + "\",\"message\":\"fali\",\"code\":\"400\",\"status\":false,\"data\":\"" + ex.Message + "\"}";
                string base64 = Util.str2Base64(str);
                SendData(base64);
                Log.Error("接受数据异常: " + ex.Message + "");
            }
        }

        /// <summary>
        /// COM接收文件
        /// </summary>
        private void NewMethod1(SerialPort sp, string path)
        {
            byte[] buffer = new byte[sp.BytesToRead];
            sp.Read(buffer, 0, buffer.Length);

            // 保存或处理接收到的字节数据，不做任何编码转换
            File.WriteAllBytes(path, buffer);
        }

        /// <summary>
        /// COM口公共发送文件
        /// </summary>
        /// <param name="url"></param>
        private void NewMethod(string url, string id)
        {
            string ext = Path.GetExtension(url);
            serialPort.WriteLine("Start_" + id + "_" + ext);
            //读取文件开始传输文件
            using (FileStream fileStream = new FileStream(url, FileMode.Open))
            {
                byte[] buffer = new byte[serialPort.WriteBufferSize];
                int bytesRead = 0;
                while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) > 0)
                {
                    serialPort.Write(buffer, 0, bytesRead);
                }
                fileStream.Close();
                fileStream.Dispose();
            }
            serialPort.WriteLine("End");
        }

        /// <summary>
        /// 打开串口
        /// </summary>
        /// <param name="source"></param>
        /// <param name="e"></param>
        private void OnTimedEvent(Object source, ElapsedEventArgs e)
        {
            try
            {
                if (!serialPort.IsOpen)
                {
                    serialPort.Open();
                }
            }
            catch (Exception ex)
            {
                Log.Error("打开串口异常: " + ex.Message + "");
            }
        }

        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="data"></param>
        public void SendData(string data)
        {
            try
            {
                if (serialPort.IsOpen)
                {
                    if (data.Length <= maxChunkSize)
                    {
                        serialPort.WriteLine(data);
                    }
                    else
                    {
                        Task.Run(() =>
                        {
                            byte[] buffer = Encoding.UTF8.GetBytes(data);
                            int dataIndex = 0;
                            int chunkSize;

                            while (dataIndex < buffer.Length)
                            {
                                chunkSize = Math.Min(buffer.Length - dataIndex, maxChunkSize);
                                serialPort.Write(buffer, dataIndex, chunkSize);
                                dataIndex += chunkSize;
                            }
                            serialPort.WriteLine("");
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error("发送数据异常3: " + ex.Message + "");
            }
        }

        /// <summary>
        /// 关闭
        /// </summary>
        public void ClosePort()
        {
            try
            {
                if (serialPort.IsOpen)
                {
                    serialPort.Close(); // 关闭串口
                }
            }
            catch (Exception ex)
            {
                Log.Error("关闭异常: " + ex.Message + "");
            }
        }
    }
}