using CodeLibrary;
using DeviceLibrary;
using HalconDotNet;
using Newtonsoft.Json;
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Xml;
using System.Xml.Linq;
using System.Xml.Serialization;

public class RemoteDecodeHelper_mod
{
    static bool IsIDCamera = ConfigHelper.Config.Get<bool>("isStartscanningcode");
    static int webclienttimeout = 30 * 1000;
    static Process p = new Process();
    const string serverhost = "http://127.0.0.1:58137/";
    public static WebResultCode DecodeRequest(Bitmap bitmap, RemoteDecodeParam remoteDecodeParam)
    {
        CheckAndRunServer();
        if (bitmap == null)
            return null;
        byte[] requestdata;
        lock (bitmap)
        {
            using (MemoryStream mStream = new MemoryStream())
            {
                BinaryFormatter bf = new BinaryFormatter();
                bf.Serialize(mStream, bitmap);
                requestdata = mStream.ToArray();
                mStream.Close();
            }
        }
        return DecodeRequest(requestdata, remoteDecodeParam);
    }
    static WebResultCode DecodeRequest(byte[] requestdata, RemoteDecodeParam remoteDecodeParam,bool isHObject=false)
    {
        //CheckAndRunServer();
        string param;
        using (MemoryStream mStreamparam = new MemoryStream())
        {
            XmlSerializer xf = new XmlSerializer(typeof(RemoteDecodeParam));
            xf.Serialize(mStreamparam, remoteDecodeParam);
            param = base64UrlEncode(mStreamparam.ToArray());
            mStreamparam.Close();
        }
        string url = serverhost+ "NeoScan/ProcessBitmap?param=";
        if (isHObject)
            url = serverhost+ "NeoScan/Process?param=";
        byte[] resp;
        try
        {
            MyWebClient webClient = new MyWebClient(webclienttimeout);
            resp = webClient.UploadData(url + param, requestdata);
            requestdata = null;
            webClient.Dispose();
        }
        catch(WebException we)
        {
            return null;
        }
        catch
        {
            return null;
        }

        WebResultCode codeInfos = null;
        var ss = Encoding.UTF8.GetString(resp);
        try
        {

            codeInfos = JsonConvert.DeserializeObject<WebResultCode>(ss);
        
        }
        catch (Exception ex)
        {
            throw new Exception("数据解析出错:" + ex + "\r\n" + ss);
        }
        return codeInfos;
    }

    #region 扫码相机请求ns100方法
    public static WebResultCode NeoSacnRequest(Bitmap bitmap, List<CodeInfo> codeInfos,int PlateW)
    {
        WebResultCode resultCode = null;
        try
        {
            CheckAndRunServer();
            BitmapData bitmapData = new BitmapData();
            string iamgestr = BitmapToBase64(bitmap);
            List<BarcodeInfos> barcodeInfos = new List<BarcodeInfos>();
            codeInfos.ForEach(c =>
            {
                barcodeInfos.Add(new BarcodeInfos
                {
                    Text = c.CodeStr,
                    CodeType = c.CodeType,
                    Angle = (float)c.Orientation,
                    Distance = c.LabelDistance,
                    X=c.X, Y=c.Y
                });
            });
            bitmapData.ImageData = iamgestr;
            bitmapData.BarCodeList = barcodeInfos;
            bitmapData.X = RobotManage.Config.Right_Batch_X;
            bitmapData.Y = RobotManage.Config.Right_Batch_Y;
            bitmapData.IsIDCamera = IsIDCamera;
            bitmapData.PlateW = PlateW;
            string methodname = "NeoScan/ProcessBitmaps";
            string repststr=NeoSacnPost(bitmapData, methodname);

            resultCode = JsonConvert.DeserializeObject<WebResultCode>(repststr);
            //因为传值时未传入条码中心点，所以在这里，还是用
            resultCode.workCodeInfo = new List<BarcodeInfo>();
            codeInfos.ForEach((c) => {
                resultCode.workCodeInfo.Add(new BarcodeInfo
                {
                    Text = c.CodeStr,
                    CodeType = c.CodeType,
                    Angle = (float)c.Orientation,
                    Center = new PointF(c.X,c.Y),
                    Distance = c.LabelDistance,
                }); ;
            });
        }
        catch (Exception ex)
        {
            LogUtil.error($"请求错误：{ex.Message}");
        }
        return resultCode;
    }

    public static WebResultCode NeoSacnRequest_ordinary(Bitmap bitmap,int PlateW)
    {
        WebResultCode resultCode = null;
        try
        {
            CheckAndRunServer();
            BitmapData bitmapData = new BitmapData();
            string iamgestr = BitmapToBase64(bitmap);
            List<BarcodeInfos> barcodeInfos = new List<BarcodeInfos>();
            bitmapData.ImageData = iamgestr;
            bitmapData.BarCodeList = barcodeInfos;
            bitmapData.X = RobotManage.Config.Right_Batch_X;
            bitmapData.Y = RobotManage.Config.Right_Batch_Y;
            bitmapData.IsIDCamera = IsIDCamera;
            bitmapData.PlateW = PlateW;
            string methodname = "NeoScan/ProcessBitmaps";
            string repststr = NeoSacnPost(bitmapData, methodname);
            resultCode = JsonConvert.DeserializeObject<WebResultCode>(repststr);
        }
        catch (Exception ex)
        {
            LogUtil.error($"请求错误：{ex.Message}");
        }
        return resultCode;
    }
    public class BitmapData
    {
        public string ImageData { get; set; }
        public List<BarcodeInfos> BarCodeList { get; set; }
       /// <summary>
       /// xy轴中心线
       /// </summary>
        public int X { get; set; }
        public int Y { get; set; }
        /// <summary>
        /// 是否扫码相机
        /// </summary>
        public bool IsIDCamera { get; set; }
        /// <summary>
        /// 料盘宽度
        /// </summary>
        public int PlateW { get; set; }
    }
    public class BarcodeInfos
    {
        //
        // 摘要:
        //     文本
        public string Text { get; set; }
        //
        // 摘要:
        //     条码类型
        public string CodeType { get; set; }
        ////
        //// 摘要:
        ////     中心点

        //public PointF Center { get; set; }
        /// <summary>
        /// 条码xy轴
        /// </summary>
        public int X { get; set; }

        public int Y { get; set; }
        ////
        //// 摘要:
        ////     条码尺寸大小

        //public SizeF Size { get; set; }


        //
        // 摘要:
        //     角度，3点钟方向0°，逆时针为正，顺时针为负。
        public float Angle { get; set; }
        //
        // 摘要:
        //     原点垂直于经过中心点的直线的距离
        public float Distance { get; set; }
    }

    static byte[] BitmapToByteArray(Bitmap bitmap)
    {
        using (MemoryStream stream = new MemoryStream())
        {
            // 将 Bitmap 保存到 MemoryStream
            bitmap.Save(stream, bitmap.RawFormat);
            // 返回 MemoryStream 中的字节数组
            return stream.ToArray();
        }
    }

    static string BitmapToBase64(Bitmap bitmap)
    {
        using (MemoryStream memoryStream = new MemoryStream())
        {
            // 将Bitmap保存到MemoryStream中
            bitmap.Save(memoryStream, System.Drawing.Imaging.ImageFormat.Jpeg);

            // 获取字节数组
            byte[] byteArray = memoryStream.ToArray();

            // 将字节数组转换为Base64编码的字符串
            return Convert.ToBase64String(byteArray);
        }
    }
    public static string NeoSacnPost(BitmapData bitmapData,string methodname)
    {
        string url = serverhost + methodname;
        string jsonData = Newtonsoft.Json.JsonConvert.SerializeObject(bitmapData);
        using (HttpClient httpClient = new HttpClient())
        {
            StringContent content = new StringContent(jsonData, Encoding.UTF8, "application/json");
            HttpResponseMessage response = httpClient.PostAsync(url, content).Result;
            if (response.IsSuccessStatusCode)
            {
                string res= response.Content.ReadAsStringAsync().Result;
                return res;
            }
            else
            {
                LogUtil.error($"请求失败返回状态码：{response.StatusCode}；");
                return null;
            }
        }
    }
    #endregion

    /// <summary>
    /// 在url中传递base64字符串需要替换加号等符号
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    static string base64UrlEncode(byte[] input)
    {
        return Convert.ToBase64String(input).Replace('+', '-').Replace('/', '_');
    }
    /// <summary>
    /// 检查并自动启动服务器
    /// </summary>
    static void CheckAndRunServer()
    {
        lock (p)
        {
            Process proes = new Process();
            var pss = Process.GetProcessesByName("Neo Scan");
            if (pss.Length > 0)
            {
                LogUtil.info("ns100服务已启动；");
                return;
            }             
            var f = ConfigHelper.Config.Get("Display_GetDataAppPath");
            string path = Path.Combine(Application.StartupPath, f);
            LogUtil.info("启动ns100服务:"+path);
            if (!File.Exists(path))
            {
                LogUtil.error("找不到扫码服务器文件");
                return;
            };               
            p.StartInfo = new ProcessStartInfo(path);
            p.StartInfo.Arguments = "hide";
            p.Start();
            int checkcount = 5;
            while (checkcount > 0)
            {
                try
                {
                    checkcount--;
                    Thread.Sleep(1000);
                    MyWebClient webClient = new MyWebClient(webclienttimeout);
                    var s = webClient.DownloadString(serverhost + "alive");
                    if (s.Trim() == "\"1\"")
                    {
                        LogUtil.info("ns100服务启动成功；");
                        return;
                    }
                }
                catch (Exception)
                {
                }                    
            }
            LogUtil.error("扫码服务器打开失败");
        }
    }

    [Serializable]
    public struct RemoteDecodeParam
    {
        public string[] codeTypeList;
        public int codeCount;
        public int timeout;
    }
    
    [Serializable]
    public class WebResultCode
    {
        public int ErrorCode { get; set; }
        public string Msg { get; set; }
        //public WebCodeText[] Data { get; set; }
        public List<KeyValuePair<string,string>> workCodeKeyword { get; set; }
        public List<BarcodeInfo> workCodeInfo;
        public WebResultCode()
        {
            ErrorCode = 0;
            Msg = "OK";
        }

        /// <summary>
        ///计算好的角度
        /// </summary>
        public NewPositionAngle  positionAngle { get; set; }  
    }
    //
    // 摘要:
    //     条码信息，1DBarcode、2DBarcode
    [Serializable]
    public class BarcodeInfo
    {
        //
        // 摘要:
        //     文本
        public string Text { get; set; }
        //
        // 摘要:
        //     条码类型
        public string CodeType { get; set; }
        //
        // 摘要:
        //     中心点
        public PointF Center { get; set; }
        //
        // 摘要:
        //     角度，3点钟方向0°，逆时针为正，顺时针为负。
        public float Angle { get; set; }
        //
        // 摘要:
        //     条码尺寸大小
        //public SizeF Size { get; set; }
        //
        // 摘要:
        //     原点垂直于经过中心点的直线的距离
        public float Distance { get; set; }
    }

    public class MyWebClient : WebClient
    {
        private int _timeout;
        public MyWebClient(int timeout)
        {
            this._timeout = timeout;
        }
        protected override WebRequest GetWebRequest(Uri address)
        {
            var result = base.GetWebRequest(address);
            result.Timeout = this._timeout;
            return result;
        }
    }

    public class NewPositionAngle
    {
        public int X { get; set; }
        public int Y { get; set; }
        public int Angle { get; set; }

        public bool[] IsCodeUsed { get; set; }
    }

}