using com.hnshituo.core.webapp.vo;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.IO;
using System.Linq;
using System.Net.NetworkInformation;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace CarLocalMeter
{
    public partial class frmMain : Form
    {
        public frmMain()
        {
            InitializeComponent();
        }

        Log lg = Log.GetInstance();

        private LED_Control led_controler;

        //List<CamerEs> lc = new List<CamerEs>();
        /// <summary>
        /// 硬盘录像机图片抓拍通道
        /// </summary>
        List<int> lc = new List<int>();

        /// <summary>
        /// 服务端委托获取
        /// </summary>
        private PreTrackScaleService PreTrackScaleService = new PreTrackScaleService();
        RESTfulResult<List<PreTrackScale>> rmScaleListCarTimer = new RESTfulResult<List<PreTrackScale>>();
        private MeterWorkCarActualFirstService workCarActualFirstService = new MeterWorkCarActualFirstService(); //一次计量数据
        RESTfulResult<List<MeterWorkCarActualFirst>> RESTfulResultOutTimer = new RESTfulResult<List<MeterWorkCarActualFirst>>();
        MeterBaseRfidInfoService rfidServer = new MeterBaseRfidInfoService();

        PlcCls plc = new PlcCls();

        /// <summary>
        /// redis操作类
        /// </summary>
        RedisOption redis = new RedisOption();

        /// <summary>
        /// 图片操作类
        /// </summary>
        ImageOption imgControl = new ImageOption();

        /// <summary>
        /// 重量采集类
        /// </summary>
        MoxaCls mx = new MoxaCls();

        /// <summary>
        /// 语音播放
        /// </summary>
        VoicePlay vicPlayClass = new VoicePlay();

        /// <summary>
        /// 摄像头车号识别枪机
        /// </summary>
        CarNoCls carCls = new CarNoCls();

        /// <summary>
        /// 摄像头识别球机
        /// </summary>
        CarNoCls carCls2 = new CarNoCls();

        /// <summary>
        /// rfid车号识别
        /// </summary>
        RfIdCarNo rfid = new RfIdCarNo();

        /// <summary>
        /// 以下是硬盘录像机的控制
        /// </summary>
        bool bVoice = false;
        CamerEs ce = new CamerEs(AppConfigCache.voicePlayIp, $"{AppConfigCache.voicePlayPort}", AppConfigCache.voicePlayUid, AppConfigCache.voicePlayPwd);
        List<int> voPlay = new List<int>();
        int iPic = 0;



        private void frmMain_Load(object sender, EventArgs e)
        {
            CacleCls.updateRfidInfoTime = DateTime.Now;

            btnSave.Enabled = false;
            if (!string.IsNullOrEmpty(AppConfigCache.ledIp))
            {
                led_controler = new LED_Control(AppConfigCache.ledIp);
            }

            #region 读取音频文件名称
            List<string> ls = new List<string>();
            DirectoryInfo folder = new DirectoryInfo(AppConfigCache.path + "\\Sound");

            foreach (FileInfo file in folder.GetFiles("*.wav"))
            {
                ls.Add(file.Name.Replace(".wav", ""));
            }
            CacleCls.voiceInfo = ls;
            #endregion


            string[] strTd1 = AppConfigCache.channelOther.Split(',');
            string[] strTd2 = AppConfigCache.channelVis.Split(',');
            string[] strAll = new string[strTd1.Length + strTd2.Length];
            strTd1.CopyTo(strAll, 0);
            strTd2.CopyTo(strAll, strTd1.Length);
            List<string> lcs = strAll.Distinct().OrderBy(s => s).ToList(); //

            lc.Add(AppConfigCache.channelCarNo);
            foreach (string str in lcs)
            {
                if ($"{AppConfigCache.channel}" != str && $"{AppConfigCache.channelCarNo}" != str)
                {
                    lc.Add(Convert.ToInt32(str)); //抓拍通道与数组中不相同的时候写入，因为我们仪表抓拍的通道需单独进行处理
                }
            }


            plImgShow.Visible = false;
            lbPointName.Text = AppConfigCache.pointName;

            foreach (string str in AppConfigCache.channelVis.Split(',')) 
            {
                voPlay.Add(Convert.ToInt32(str));
            }

            ce.Connection();
            foreach(int i in voPlay) 
            {
                PictureBox pb = new PictureBox();
                pb.Dock = DockStyle.Top;
                pb.DoubleClick += new EventHandler(PictureBoxDoubleClick);
                pb.Height = AppConfigCache.channelVisHeight;
                pb.Name = $"pb{i}";
                panel1.Controls.Add(pb);
                ce.RealPlay(pb, i);
            }

            mx.start();

            TaskPing();
            /*
            rfid.Start();
            TaskMain();
            
            TaskDbUpload();
            imgControl.Start();
            plc.Start();
            carCls.Login(AppConfigCache.voiceCarNoIp, AppConfigCache.voiceCarNoPort, AppConfigCache.voiceCarNoUid, AppConfigCache.voiceCarNoPwd);
            //*/
            //carCls2.Login(AppConfigCache.voiceCarNoIp2, AppConfigCache.voiceCarNoPort2, AppConfigCache.voiceCarNoUid2, AppConfigCache.voiceCarNoPwd2, false);
        }

        CancellationTokenSource _cts,_cts2,_dbCts;
        bool getPreInfo = false, getFirst = false, flagCaption = false, isVoiceDownCar = false;
        string strOldCarNo = "";
        bool isMeasureSuccess = false;
        int voiceNum = 0;

        int iImgCnt = 0;
        /// <summary>
        /// 主定时任务
        /// </summary>
        private void TaskMain() 
        {
            _cts = new CancellationTokenSource();
            Task.Run(() => {
                while (!_cts.IsCancellationRequested)
                {
                    this.panel3.Invoke(new Action(() => {
                        if (!CacleCls.isLock) 
                        {
                            ucWeightT1.setWgt(Math.Round((double)CacleCls.weight / 1000, 2)); //2021年5月10日界面显示单位，调整为T
                            ucWeightT1.setStable(CacleCls.isWd != 1 ? true : false);
                            ucWeightT1.setExceed(CacleCls.weight > AppConfigCache.maxRange * 1000 ? false : true);

                            if (cbCarNo.Text.Trim() != "" && txtCarNo.Text.Trim() != "")
                            {
                                CacleCls.lockCarNo = cbCarNo.Text.Trim() + txtCarNo.Text.Trim();
                            }
                            else if (CacleCls.rfidCarNo != "")
                            {
                                CacleCls.lockCarNo = CacleCls.rfidCarNo;
                            }
                            else if (CacleCls.voicCarNo != "")
                            {
                                CacleCls.lockCarNo = CacleCls.voicCarNo;
                            }
                            else if (!string.IsNullOrEmpty(CacleCls.voicCarNo2)) 
                            {
                                CacleCls.lockCarNo = CacleCls.voicCarNo2;
                            }

                            if (CacleCls.lockCarNo != "" && cbCarNo.Text.Trim() == "" && txtCarNo.Text.Trim() == "")
                            {
                                cbCarNo.Text = CacleCls.lockCarNo.Substring(0, 1);
                                if (CacleCls.lockCarNo.Length > 1)
                                {
                                    txtCarNo.Text = CacleCls.lockCarNo.Substring(1);
                                }
                            }
                            if (strOldCarNo != CacleCls.lockCarNo)
                            {
                                strOldCarNo = CacleCls.lockCarNo;
                                getPreInfo = false;
                                getFirst = false;
                            }
                        }

                        if (CacleCls.weight > 500)
                        {
                            iImgCnt = 0;
                            CacleCls.isClear = false;

                            //是否能连上远程服务器，这里只是服务器，不是服务器上的服务端
                            pbLineOn.Load(CacleCls.serverFlag ? (AppConfigCache.path + "\\image\\icon\\green.gif") : (AppConfigCache.path + "\\image\\icon\\red.gif"));

                            #region 一些必要验证及提醒
                            if (!CacleCls.isLock) 
                            {
                                //重量最后一位不为0也是超量程
                                if ((AppConfigCache.maxRange * 1000 < CacleCls.weight) || CacleCls.weight.ToString().Substring(CacleCls.weight.ToString().Length - 1, 1) != "0")
                                {
                                    //超量程
                                    vicPlayClass.GetVoicePlay("已超量程", CacleCls.lockCarNo);
                                    txtMsgInfo.Text = "当前重量已超量程，秤体量程为【" + AppConfigCache.maxRange + "】T，不允许进行自助计量操作！";
                                    led_controler.setStaticLineMsg(AppConfigCache.ledIp, "当前重量已超量程，秤体量程为【" + AppConfigCache.maxRange + "】T，不允许进行自助计量操作！");
                                    CacleCls.isLock = false;
                                    return;
                                }

                                if (CacleCls.isWd == 0 && !string.IsNullOrEmpty(CacleCls.lockCarNo))
                                {
                                    if ((CacleCls.topJg == "1" || CacleCls.bottomJg == "1"))
                                    {
                                        //重量稳定，且对射验证不合格
                                        vicPlayClass.GetVoicePlay("车辆超出秤台，请调整车位2", CacleCls.lockCarNo);
                                        txtMsgInfo.Text = "车辆超出秤台，请调整车位2";
                                        led_controler.setStaticLineMsg(AppConfigCache.ledIp, "车辆超出秤台，请调整车位2");
                                        CacleCls.isLock = false;
                                        return;
                                    }
                                    else if (CacleCls.rightGs == "1")
                                    {
                                        //重量稳定，且右光栅不合格
                                        vicPlayClass.GetVoicePlay("车辆超出秤台，请调整车位3", CacleCls.lockCarNo);
                                        txtMsgInfo.Text = "车辆超出秤台，请调整车位3";
                                        led_controler.setStaticLineMsg(AppConfigCache.ledIp, "车辆超出秤台，请调整车位3");
                                        CacleCls.isLock = false;
                                        return;
                                    }
                                    else if (CacleCls.leftGs == "1")
                                    {
                                        //重量稳定，且左光栅不合格
                                        vicPlayClass.GetVoicePlay("车辆超出秤台，请调整车位4", CacleCls.lockCarNo);
                                        txtMsgInfo.Text = "车辆超出秤台，请调整车位4";
                                        led_controler.setStaticLineMsg(AppConfigCache.ledIp, "车辆超出秤台，请调整车位4");
                                        CacleCls.isLock = false;
                                        return;
                                    }
                                }

                                /*
                                if (PbCache.isOvertimeAlarm)
                                {
                                    //停留超时提醒，不作为计量卡控的条件
                                    if (!isPlayOvertimeVoice && !PbCache.isLockFrm)
                                    {
                                        vicPlayClass.GetVoicePlay("停留超时", PbCache.collect.carno);
                                        led_controler.setStaticLineMsg(PbCache.sportInfo.ledIp, "停留超时");
                                        txtMsgInfo.Text = "停留超时";
                                        PbCache.ResultMessage = "停留超时";
                                        isPlayOvertimeVoice = true;
                                        return;
                                    }
                                }
                                //*/

                                #region 一次计量数据跟预报获取一次
                                if (!string.IsNullOrEmpty(CacleCls.lockCarNo))
                                {
                                    //查询一次计量数据
                                    if (!getFirst)
                                    {
                                        RESTfulResultOutTimer = workCarActualFirstService.doQueryWf(new MeterWorkCarActualFirst { valueFlag = "1", carNo = CacleCls.lockCarNo });

                                        if (RESTfulResultOutTimer.Succeed)
                                        {
                                            if (RESTfulResultOutTimer.Data != null && RESTfulResultOutTimer.Data.Count > 0)
                                            {
                                                CacleCls.firstDb = RESTfulResultOutTimer.Data[0];
                                                if (CacleCls.firstDb.predictionNo != null && !CacleCls.firstDb.predictionNo.Contains("_"))
                                                {
                                                    txtMATTER_NAME.Text = CacleCls.firstDb.matterName;
                                                    txtFORWARDING_UNIT_NAME.Text = CacleCls.firstDb.forwardingUnitName;
                                                    txtRECEIVING_UINT_NAME.Text = CacleCls.firstDb.receivingUintName;
                                                    txtMETER_TYPE.Text = CacleCls.firstDb.meterTypeName;
                                                }
                                            }
                                        }
                                        getFirst = true;
                                    }

                                    //根据网络状态及车号以及是否存在一次计量数据，查询一次预报信息，然后将getPreInfo改为true
                                    if (!getPreInfo && CacleCls.serverFlag)
                                    {
                                        if (CacleCls.firstDb == null || string.IsNullOrEmpty(CacleCls.firstDb?.predictionNo))
                                        {
                                            //如果没有一次信息或者一次信息里面没带预报信息，则查询一次预报信息
                                            rmScaleListCarTimer = PreTrackScaleService.doQueryByFlag(new PreTrackScale { lineDesc = "1", carNo = CacleCls.lockCarNo });
                                            if (rmScaleListCarTimer.Succeed)
                                            {
                                                if (rmScaleListCarTimer.Data != null && rmScaleListCarTimer.Data.Count == 1)
                                                {
                                                    CacleCls.preTrackScale = rmScaleListCarTimer.Data[0];

                                                    txtMATTER_NAME.Text = CacleCls.preTrackScale.matterName;
                                                    txtFORWARDING_UNIT_NAME.Text = CacleCls.preTrackScale.forwardingUnitName;
                                                    txtRECEIVING_UINT_NAME.Text = CacleCls.preTrackScale.receivingUintName;
                                                    txtMETER_TYPE.Text = CacleCls.preTrackScale.meterTypeName;
                                                }
                                            }
                                        }
                                        getPreInfo = true;
                                    }
                                }
                                #endregion


                                //进行计量称重条件的判断  车号不为空、重量稳定、车辆已停到位
                                if (!string.IsNullOrEmpty(CacleCls.lockCarNo) && CacleCls.isWd == 0 && CacleCls.leftGs != "1" && CacleCls.rightGs != "1" && CacleCls.topJg != "1" && CacleCls.bottomJg != "1")
                                {
                                    if (!isVoiceDownCar)
                                    {
                                        isVoiceDownCar = true;
                                        vicPlayClass.GetVoicePlay("车上人员请下车", CacleCls.lockCarNo);//只播放一次
                                    }

                                    //if(!btnSave.Enabled) btnSave.Enabled = true;

                                    if (!CacleCls.isJg) 
                                    {
                                        lg.WriteLog(LogType.SystemLog, CacleCls.lockCarNo + "开始保存：" + DateTime.Now.ToLongTimeString());
                                        btnSave.PerformClick();
                                    }
                                }
                            }
                            #endregion

                            //计量完成后进行语音播报，提示离开秤台，播报5次
                            if (isMeasureSuccess)
                            {
                                if (voiceNum < AppConfigCache.voiceNum)
                                {
                                    if (CacleCls.voiceOver)
                                    {
                                        vicPlayClass.GetVoicePlay("计量完成，请离开秤台", CacleCls.lockCarNo);
                                        voiceNum++;
                                    }
                                }
                                return;
                            }
                        }
                        else
                        {
                            voiceNum = 0;
                            isMeasureSuccess = false;
                            lockWgtImg = CacleCls.weight;
                            getFirst = false;
                            getPreInfo = false;
                            flagCaption = false;
                            isVoiceDownCar = false;
                            strGuid = "";

                            if (!CacleCls.isClear)
                            {
                                CacleCls.Clear(); //清理一次数据
                                btnSave.Enabled = false;
                                cbCarNo.Text = "";
                                cbCarNo.SelectedIndex = -1;
                                txtCarNo.Text = "";
                                txtMATTER_NAME.Text = "";
                                txtFORWARDING_UNIT_NAME.Text = "";
                                txtRECEIVING_UINT_NAME.Text = "";
                                txtMETER_TYPE.Text = "";
                                cbCarNo.Enabled = true;
                                txtCarNo.Enabled = true;

                                txtGroess.Text = "";
                                txtTare.Text = "";
                                txtNet.Text = "";

                                //释放一次内存
                                FlushMemory();
                            }

                            //避免海康截图完成时间在下磅后，所以压缩图片在下磅后5秒继续执行，超过这个时间则认为没有图片需压缩了
                            if (iImgCnt < 10)
                            {
                                iImgCnt++;//最多在车辆下磅后，5秒内继续压缩下图片，如果都下磅5秒了还没图片说明没有图片需压缩了
                                imgControl.ZipFiles();
                            }
                        }
                    }));
                    Thread.Sleep(500);
                }
            }, _cts.Token);
        }

        string dbFile = Path.Combine(AppConfigCache.path, "data/rfidDb.data");

        /// <summary>
        /// ping服务器
        /// </summary>
        private void TaskPing() 
        {
            _cts2 = new CancellationTokenSource();
            Task.Run(() => {
                while (!_cts2.IsCancellationRequested) 
                {
                    try
                    {
                        Ping pingSend = new Ping();
                        PingReply reply = pingSend.Send(AppConfigCache.ServiceIp, 1000);
                        if (reply.Status == IPStatus.Success)
                            CacleCls.serverFlag = true;
                        else
                            CacleCls.serverFlag = false;
                    }
                    catch (Exception)
                    {
                        CacleCls.serverFlag = false;
                    }
                    finally 
                    {
                        if (CacleCls.serverFlag)
                        {
                            if (CacleCls.weight < 500 && DateTime.Now > CacleCls.updateRfidInfoTime)
                            {
                                CacleCls.updateRfidInfoTime.Value.AddHours(1); //每隔一小时更新一次rfid数据

                                Dictionary<string, string> rfidInfo = new Dictionary<string, string>();
                                RESTfulResult<List<MeterBaseRfidInfo>> rfids = rfidServer.doQueryRfid(new MeterBaseRfidInfo { valueFlag = "0" });
                                if (rfids.Succeed)
                                {
                                    if (rfids.Data != null && rfids.Data.Count > 0) 
                                    {
                                        StringBuilder sb = new StringBuilder();
                                        foreach (MeterBaseRfidInfo rfid in rfids.Data)
                                        {
                                            try
                                            {
                                                sb.AppendLine($"{rfid.rfidCode},{rfid.carNo}");
                                                rfidInfo.Add(rfid.rfidCode, rfid.carNo);
                                            }
                                            catch { }
                                        }
                                        try
                                        {
                                            //如果目标文件存在则覆盖，不存在则创建
                                            File.WriteAllText(dbFile, sb.ToString());
                                        }
                                        catch(Exception ex) 
                                        {
                                            lg.WriteLog(LogType.SystemLog, "写入rfid数据到本地失败：" + ex.Message);
                                        }
                                        CacleCls.rifdInfo = rfidInfo;
                                    }
                                }
                                else 
                                {
                                    lg.WriteLog(LogType.serverLog, $"获取RFID信息失败：{rfids.Message}");
                                }
                            }
                        }
                        else 
                        {
                            if (CacleCls.rifdInfo == null || CacleCls.rifdInfo.Count == 0) 
                            {
                                //读取本地rfid数据文件
                                try
                                {
                                    if (File.Exists(dbFile))
                                    {
                                        Dictionary<string, string> rfidInfo = new Dictionary<string, string>();
                                        string[] strs = File.ReadAllLines(dbFile);
                                        foreach (string str in strs)
                                        {
                                            try 
                                            {
                                                string[] strInfo = str.Split(',');
                                                if (strInfo.Length == 2)
                                                {
                                                    rfidInfo.Add(strInfo[0], strInfo[1]);
                                                }
                                            } catch { }
                                        }
                                        CacleCls.rifdInfo = rfidInfo;
                                    }
                                }
                                catch (Exception ex)
                                {
                                    lg.WriteLog(LogType.WriteDbLog, "写入信息失败：" + ex.Message);
                                }
                            }
                        }
                    }
                    Thread.Sleep(500);
                }
            }, _cts2.Token);
        }

        /// <summary>
        /// 结净数据上传服务
        /// 这里需等重量小于500且网络正常时触发
        /// 因为假如网络正常且重量大于500的时候，会优先将当前计量的数据存储到服务器上，然后返回结果进行打印操作
        /// 所以这里为了避免重复数据插入，所以需重量小于500且网络正常
        /// </summary>
        private void TaskDbUpload() 
        {
            Dictionary<string, string> dic = new Dictionary<string, string>();
            _dbCts = new CancellationTokenSource();
            Task.Run(() =>
            {
                while (!_cts2.IsCancellationRequested)
                {
                    try
                    {
                        if (CacleCls.weight < 500 && CacleCls.serverFlag)
                        {
                            dic.Clear();
                            //检索本地实时库中结净数据。（若本地数据结净后，一次数据得删除，而结净数据中会保留一次数据的编号、重量、计量时间、计量点信息）
                            //若本地存在结净数据未进行上传的，则进行数据上传并得到返回的结果：老一次计量编号|一次计量编号,老二次计量编号|新二次计量编号
                            //得到结果后构造成Dictionary然后进行图片操作，修改图片名称及位置
                            bool bReadFlag = false;
                            string strRtMsgInfo = "";
                            List<MeterWorkCarActualFirst> lm = FileOption.ReadDb(ref bReadFlag, ref strRtMsgInfo);
                            if (bReadFlag)
                            {
                                //进行结净
                                RESTfulResult<List<DjPbModel>> rmRst = workCarActualFirstService.doDbUpload(lm);
                                if (rmRst.Succeed)
                                {
                                    if (rmRst.Data.Count == lm.Count)
                                    {
                                        //直接重写文件
                                        FileOption.clearFile();
                                        //然后对图片进行压缩及修改名称处理
                                        foreach (DjPbModel dm in rmRst.Data)
                                        {
                                            dic.Add(dm.key, dm.value);
                                        }
                                    }
                                    else
                                    {
                                        //清理下文件
                                        FileOption.clearFile();
                                        //重写下未成功的数据
                                        foreach (MeterWorkCarActualFirst first in lm)
                                        {
                                            DjPbModel pm = rmRst.Data.Where(s => s.key == first.actualFirstNo).FirstOrDefault();
                                            if (pm == null || string.IsNullOrEmpty(pm.key) || string.IsNullOrEmpty(pm.value))
                                            {
                                                //Thread.Sleep(100);
                                                bool flag = FileOption.WriterDb(new ActualFirstModel { actualFirstNo = first.actualFirstNo, baseSpotNo = first.baseSpotNo, baseSpotName = first.baseSpotName, carNo = first.carNo, createTime = first.createTime, meterWeight = first.meterWeight }, out string msgInfo);
                                                if (!flag)
                                                {
                                                    lg.WriteLog(LogType.serverLog, $"重写失败：{msgInfo}，数据：actualFirstNo{first.actualFirstNo},baseSpotNo:{first.baseSpotNo},baseSpotName:{first.baseSpotName},carNo:{first.carNo},createTime:{first.createTime},meterWeight:{first.meterWeight}");
                                                }
                                            }
                                            else
                                            {
                                                dic.Add(pm.key, pm.value);
                                            }
                                        }
                                    }

                                    if (dic.Count > 0) imgControl.ZipFiles(dic);
                                }
                                else
                                {
                                    //计量失败，播报失败，然后写led屏幕及日志
                                    led_controler.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，请联系管理员");
                                    txtMsgInfo.Text = "计量失败：" + rmRst.ResultMessage;
                                    lg.WriteLog(LogType.serverLog, rmRst.ResultMessage);
                                    CacleCls.isLock = false;
                                    return;
                                }
                            }
                        }
                    }
                    catch (Exception)
                    {
                        CacleCls.serverFlag = false;
                    }
                    Thread.Sleep(1000);
                }
            }, _dbCts.Token);
        }

        int lockWgtImg = 0;
        string strGuid = "";
        private void btnSave_Click(object sender, EventArgs e)
        {
            #region 下面是业务逻辑代码
            string msgInfo = "";
            if (txtCarNo.Focused) return; //如果正在修改车号，就必须等光标离开后再保存，否则容易导致车号输入了一半保存了

            if (CacleCls.isWd != 0) return;

            ucWeightT1.setStable(true);    // 重量稳定
            ucWeightT1.setWgt(Math.Round((double)CacleCls.weight / 1000, 2));    // 最新重量
            CacleCls.lockWgt = CacleCls.weight;

            if (!CacleCls.lockWgt.ToString().EndsWith("0")) //个位不是0则说明超量程了
            {
                //txtMsgInfo.Text = "仪表重量[" + CacleCls.lockWgt + "]不是以0结尾，禁止计量操作！";
                vicPlayClass.GetVoicePlay("已超量程", CacleCls.lockCarNo);
                txtMsgInfo.Text = "当前重量已超量程，秤体量程为【" + AppConfigCache.maxRange + "】T，不允许进行自助计量操作！";
                return;
            }

            //接管状态点的保存
            if (CacleCls.isJg) 
            {
                if (string.IsNullOrEmpty(CacleCls.lockCarNo))
                {
                    txtMsgInfo.Text = "没有车号，无法保存";
                    return;
                }
                else if (CacleCls.lockWgt < 500)
                {
                    txtMsgInfo.Text = "重量过小，无法保存";
                    return;
                }
                else if (CacleCls.isWd != 0)
                {
                    txtMsgInfo.Text = "重量不稳定，无法保存";
                    return;
                }
                else if (CacleCls.leftGs == "1" || CacleCls.rightGs == "1" || CacleCls.topJg == "1" || CacleCls.bottomJg == "1")
                {
                    txtMsgInfo.Text = "激光被遮挡，车辆未停到位，无法保存";
                    return;
                }
                else 
                {
                    lg.WriteLog(LogType.SystemLog, CacleCls.lockCarNo + "接管状态下进行的保存：" + DateTime.Now.ToLongTimeString());
                }
            }


            //存在零点，且不为接管状态则禁止计量
            if (CacleCls.isZeroState && !CacleCls.isJg)
            {
                vicPlayClass.GetVoicePlay("仪表未归零，无法计量，请联系大厅", CacleCls.lockCarNo);
                txtMsgInfo.Text = "仪表未归零，无法计量，请联系大厅"; //btnSave_Click
                led_controler.setStaticLineMsg(AppConfigCache.ledIp, "仪表未归零，无法计量");
                return;
            }

            if (!CacleCls.isJg && CacleCls.firstDb != null)
            {
                if (Math.Abs(CacleCls.firstDb.meterWeight.Value - CacleCls.lockWgt) < AppConfigCache.differenceWgt) 
                {
                    vicPlayClass.GetVoicePlay("计量失败，洁净重量过小，请联系计量大厅", CacleCls.lockCarNo);
                    txtMsgInfo.Text = "计量失败，洁净重量过小";
                    led_controler.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，洁净重量过小");
                    return;
                }
            }


            txtMsgInfo.Text =  "称重保存中......";

            CacleCls.isLock = true;
            cbCarNo.Enabled = false;
            txtCarNo.Enabled = false;

            strGuid = strGuid == "" ? Guid.NewGuid().ToString() : strGuid;
            #region 截图
            if (!flagCaption)
            {
                for (int i = 0; i < lc.Count(); i++)
                {
                    if (i == 0) 
                    {
                        carCls.CapturePictrue2($"{AppConfigCache.path}/imgShort/formalImg/{AppConfigCache.pointNo}_C{strGuid}_tempImg_{i + 2}.jpg");
                        continue;
                    }

                    //从_2开始，因为_1是仪表图片  2是车号快照抓拍
                    ce.CapPic((uint)lc[i], $"{AppConfigCache.path}/imgShort/formalImg/{AppConfigCache.pointNo}_C{strGuid}_tempImg_{i + 2}.jpg");
                }
                flagCaption = true;
            }

            if (lockWgtImg != CacleCls.lockWgt)
            {
                lockWgtImg = CacleCls.lockWgt;
                
                foreach (Control cn in panel1.Controls) 
                {
                    if (cn.Name.Substring(cn.Name.Length - 1) == $"{AppConfigCache.channel}")
                    {
                        if (cn is PictureBox)
                        {
                            Bitmap bit = new Bitmap(cn.Width, cn.Height);//实例化一个和窗体一样大的bitmap
                            Graphics g = Graphics.FromImage(bit);
                            g.CompositingQuality = CompositingQuality.HighQuality;//质量设为最高 HighQuality
                            g.CopyFromScreen(panel1.Left, panel1.Top + 25, 0, 0, new Size(cn.Width, cn.Height));//保存整个窗体为图片       
                            bit.Save($"{AppConfigCache.path}/imgShort/formalImg/{AppConfigCache.pointNo}_C{strGuid}_tempImg_1.jpg");//默认保存格式为PNG，保存成jpg格式质量不是很好
                            bit.Dispose();
                            break;
                        }
                    }
                }

                #region
                /* //下面的代码可实现抓放大的图，不过我这为了时间更准，抓的左侧显示的图
                if (iPic != 0)
                {
                    ce.StopRealPlay(iPic);
                }
                ce.RealPlay(pictureShow, AppConfigCache.channel);
                plImgShow.Visible = true;
                Thread.Sleep(200);
                Bitmap bit = new Bitmap(plImgShow.Width, plImgShow.Height);//实例化一个和窗体一样大的bitmap
                Graphics g = Graphics.FromImage(bit);
                g.CompositingQuality = CompositingQuality.HighQuality;//质量设为最高 HighQuality
                g.CopyFromScreen(plImgShow.Left, plImgShow.Top + 25, 0, 0, new Size(plImgShow.Width, plImgShow.Height));//保存整个窗体为图片       
                bit.Save($"{AppConfigCache.path}/imgShort/formalImg/{AppConfigCache.pointNo}_C{strGuid}_tempImg_1.jpg");//默认保存格式为PNG，保存成jpg格式质量不是很好
                bit.Dispose();
                plImgShow.Visible = false;
                ce.StopRealPlay(AppConfigCache.channel);
                //*/
                #endregion
            }
            #endregion

            if (CacleCls.serverFlag) //网络正常
            {
                //没有接管的情况下
                if (!CacleCls.isJg && CacleCls.firstDb != null && Math.Abs(CacleCls.firstDb.meterWeight.Value - AppConfigCache.differenceWgt) < AppConfigCache.differenceWgt)
                {
                    string str = "第一次计量重量【" + CacleCls.firstDb.meterWeight.Value / 1000 + "T】和第二次计量重量【" + CacleCls.lockWgt / 1000 + "T】接近，小于结净最小值【" + AppConfigCache.differenceWgt / 1000 + " T】";
                    led_controler.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，请联系管理员");
                    txtMsgInfo.Text = str;
                    lg.WriteLog(LogType.serverLog, str);
                    CacleCls.isLock = false;
                    return;
                }

                
                //一次计量
                if (CacleCls.firstDb == null)
                {
                    //进行计量，不管有没有一次计量数据，都调用这个，如果服务端判断有一次计量数据则进行结净，没有则做一次计量操作
                    RESTfulResult<MeterWorkCarActualFirst> rmRst = workCarActualFirstService.doAddFirstDjDb(CacleCls.preTrackScale, new MeterWorkCarActualFirst
                    {
                        baseSpotNo = AppConfigCache.pointNo,
                        baseSpotName = AppConfigCache.pointName,
                        carNo = CacleCls.lockCarNo,
                        createTime = DateTime.Now,
                        meterWeight = CacleCls.lockWgt,
                        createManNo = "system",
                        createManName = "system",
                        valueFlag = "1",
                        meterMode = "2",
                        isPreScale = "0",
                        dataSource = "1",
                        checkFlag = "1"
                    });

                    if (rmRst.Succeed)
                    {
                        isMeasureSuccess = true;
                        CacleCls.actualNo = rmRst.Data?.actualFirstNo;
                        CacleCls.tempNo = strGuid;
                    }
                    else
                    {
                        //计量失败，播报失败，然后写led屏幕及日志
                        led_controler.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，请联系管理员");
                        txtMsgInfo.Text = "计量失败：" + rmRst.ResultMessage;
                        lg.WriteLog(LogType.serverLog, rmRst.ResultMessage);
                        CacleCls.isLock = false;
                        return;
                    }
                }
                else //结净操作
                {
                    RESTfulResult<string> rmRst = workCarActualFirstService.doAddNet(CacleCls.preTrackScale, CacleCls.firstDb, new MeterWorkCarActualFirst
                    {
                        baseSpotNo = AppConfigCache.pointNo,
                        baseSpotName = AppConfigCache.pointName,
                        carNo = CacleCls.lockCarNo,
                        createTime = DateTime.Now,
                        meterWeight = CacleCls.lockWgt,
                        createManNo = "system",
                        createManName = "system",
                        valueFlag = "1",
                        meterMode = "2",
                        isPreScale = "0",
                        dataSource = "1",
                        checkFlag = "1"
                    });

                    if (rmRst.Succeed)
                    {
                        isMeasureSuccess = true;
                        CacleCls.actualNo = rmRst.Data;
                        CacleCls.tempNo = strGuid;
                    }
                    else
                    {
                        //计量失败，播报失败，然后写led屏幕及日志
                        led_controler.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，请联系管理员");
                        txtMsgInfo.Text = "计量失败：" + rmRst.ResultMessage;
                        lg.WriteLog(LogType.serverLog, rmRst.ResultMessage);
                        CacleCls.isLock = false;
                        return;
                    }
                }
            }
            else 
            {
                //写本地文件
                bool flag = FileOption.WriterDb(new ActualFirstModel { actualFirstNo = strGuid, baseSpotNo = AppConfigCache.pointNo, baseSpotName = AppConfigCache.pointName, carNo = CacleCls.lockCarNo, createTime = DateTime.Now, meterWeight = CacleCls.lockWgt },out msgInfo);
                if (flag)
                {
                    isMeasureSuccess = true;
                }
                else 
                {
                    led_controler.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，请联系管理员");
                    txtMsgInfo.Text = "计量失败：" + msgInfo;
                    lg.WriteLog(LogType.serverLog, msgInfo);
                    CacleCls.isLock = false;
                    return;
                }
            }

            //计量成功
            if (isMeasureSuccess) 
            {
                #region 毛皮净赋值
                if (CacleCls.firstDb != null && CacleCls.firstDb.meterWeight > 0 && CacleCls.lockWgt > 0)
                {
                    if (CacleCls.firstDb.meterWeight > CacleCls.lockWgt)
                    {
                        txtGroess.Text = $"{CacleCls.firstDb.meterWeight / 1000}";
                        txtTare.Text = $"{CacleCls.lockWgt / 1000}";
                        txtNet.Text = $"{(CacleCls.firstDb.meterWeight - CacleCls.lockWgt) / 1000}";
                    }
                    else
                    {
                        txtGroess.Text = $"{CacleCls.lockWgt / 1000}";
                        txtTare.Text = $"{CacleCls.firstDb.meterWeight / 1000}";
                        txtNet.Text = $"{(CacleCls.lockWgt - CacleCls.firstDb.meterWeight) / 1000}";
                    }
                }

                if (!string.IsNullOrEmpty(CacleCls.LEDResultMessage))
                {
                    led_controler.setStaticLineMsg(AppConfigCache.ledIp, CacleCls.LEDResultMessage);
                }
                #endregion

                //屏幕截图操作
                _ = BeginInvoke(new Action(() => { shotImageScreen(strGuid); }));
            }
            #endregion

        }

        private void btnOpenVoice_Click(object sender, EventArgs e)
        {
            //*
            if (btnOpenVoice.Text == "打开对讲")
            {
                VoiceOpen();
            }
            else
            {
                VoiceClose();
            }
            //*/
        }

        private void frmMain_FormClosing(object sender, FormClosingEventArgs e)
        {
            
            try { mx.ClosingCollect(); } catch { }
            try { rfid.ClosingCollect(); } catch { }
            try { if (bVoice) ce.StopTalk(); } catch { }
            

            foreach (int i in voPlay)
            {
                try { ce.StopRealPlay(i); } catch { }
            }

            try { plc.Stop(); } catch { }
            try { _cts?.Cancel(); } catch { }
            try { _cts2?.Cancel(); } catch { }
            try { _dbCts?.Cancel(); } catch { }
            try { carCls?.LoginOut(); } catch { }
            //try { carCls2?.LoginOut(); } catch { }
            try { imgControl.Stop(); } catch { }
        }

        /// <summary>
        ///  必须先打开视频，然后再打开语音
        /// </summary>
        private void VoiceOpen()
        {
            try
            {
                if (ce.StartTalk())
                {
                    btnOpenVoice.Text = "关闭对讲";
                    bVoice = true;
                }
            }
            catch (Exception ex)
            {
                txtMsgInfo.Text = "打开对讲失败：" + ex.Message;
            }
        }

        /// <summary>
        /// 关闭语音对讲
        /// </summary>
        private void VoiceClose()
        {
            try
            {
                if (ce.StopTalk())
                {
                    btnOpenVoice.Text = "打开对讲";
                    bVoice = false;
                }
            }
            catch (Exception ex)
            {
                txtMsgInfo.Text = "关闭对讲失败：" + ex.Message;
            }
        }

        private void btnExport_Click(object sender, EventArgs e)
        {
            ClsControlPack.ExportDataWithSaveDialog2(ref ultraGridFirst, DateTime.Now.ToString("yyyyMMddHHmmss"));
        }

        private void cbCarNo_SelectedIndexChanged(object sender, EventArgs e)
        {
            CacleCls.isLock = false;
        }

        private void cbJg_CheckedChanged(object sender, EventArgs e)
        {
            CacleCls.isJg = cbJg.Checked;
            btnSave.Enabled = cbJg.Checked;
        }

        private void txtCarNo_TextChanged(object sender, EventArgs e)
        {
            CacleCls.isLock = false;
        }

        private void PictureBoxDoubleClick(object sender, EventArgs e)
        {
            if (iPic != 0)
            {
                ce.StopRealPlay(iPic);
            }
            PictureBox picture = (PictureBox)sender;
            iPic = Convert.ToInt32(picture.Name.Substring(picture.Name.Length - 1, 1));
            plImgShow.Visible = true;
            ce.RealPlay(pictureShow, iPic);
        }

        private void pictureShow_DoubleClick(object sender, EventArgs e)
        {
            plImgShow.Visible = false;
            ce.StopRealPlay(iPic);
            iPic = 0;
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            if (!string.IsNullOrEmpty(CacleCls.voicCarNo)) 
            {
                txtMsgInfo.Text += CacleCls.voicCarNo + "\n\r";
            }
            CacleCls.voicCarNo = "";

            if(!string.IsNullOrEmpty(CacleCls.rfidCarNo))
                txtMsgInfo.Text += CacleCls.rfidCarNo + "\n\r";

            //*/
        }


        /// <summary>
        /// 终端截图(临时截图，使用临时ID存储)
        /// </summary>
        public void shotImageScreen(string strActualFirstNo)
        {
            try
            {
                #region 截取图片信息
                //截取屏幕信息
                Point screenPoint = plCaptionMain.PointToScreen(new Point());
                Rectangle rect = new Rectangle(screenPoint, plCaptionMain.Size);
                Image img = new Bitmap(plCaptionMain.Width, plCaptionMain.Height);
                Graphics g = Graphics.FromImage(img);
                g.CopyFromScreen(rect.X - 1, rect.Y - 1, 0, 0, rect.Size);//"D://file/1.jpg"
                img.Save(string.Format("{0}imgShort\\formalImg\\{1}_{2}_{3}.jpg",
                    AppDomain.CurrentDomain.SetupInformation.ApplicationBase,
                    AppConfigCache.pointNo, "C" + strActualFirstNo, 7), System.Drawing.Imaging.ImageFormat.Jpeg);

                //lg.WriteLog(35, "完成截图    成功标识：" + PbCache.shotSuccess.ToString() + "车号：" + PbCache.lockCarNo + "；重量：" + PbCache.lockWgt + "；时间：" + DateTime.Now.ToLongTimeString());
                #endregion 截取图片信息
            }
            catch (Exception ex)
            {
                lg.WriteLog(LogType.SystemLog, "计量完成，但图片截取失败，编号：" + strActualFirstNo);
            }
        }


        #region 释放内存
        [DllImport("kernel32.dll")]
        private static extern bool SetProcessWorkingSetSize(IntPtr process, int minSize, int maxSize);
        //刷新存储器
        private static void FlushMemory()
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
            {
                SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle, -1, -1);
            }
        }
        #endregion
    }
}