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

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

        /// <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>>();
        PlcCls plc = new PlcCls();

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

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

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

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


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

        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)
        {
            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);
            }

            rfid.Start();

            /*
            TaskMain();
            TaskPing();
            TaskDbUpload();
            imgControl.Start();
            plc.Start();
            carCls.Login()
            //*/
        }

        CancellationTokenSource _cts,_cts2,_dbCts;
        bool getPreInfo = false, getFirst = false;
        string strOldCarNo = "";

        /// <summary>
        /// 主定时任务
        /// </summary>
        private void TaskMain() 
        {
            _cts = new CancellationTokenSource();
            Task.Run(() => {
                while (!_cts.IsCancellationRequested)
                {
                    if (CacleCls.weight > 500)
                    {
                        CacleCls.isClear = false;
                        
                        //是否能连上远程服务器，这里只是服务器，不是服务器上的服务端
                        pbLineOn.Load(CacleCls.serverFlag ? (AppConfigCache.path + "\\image\\icon\\green.gif") : (AppConfigCache.path + "\\image\\icon\\red.gif"));

                        if (!CacleCls.isLock)
                        {
                            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("_"))
                                            {
                                                this.panel3.Invoke(new Action(() => {
                                                    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];

                                                this.panel3.Invoke(new Action(() => {
                                                    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;
                                }
                            }
                        }
                    }
                    else
                    {
                        getFirst = false;
                        getPreInfo = false;
                    }

                    this.panel3.Invoke(new Action(() => {

                        if (CacleCls.weight < 500) 
                        {
                            if (!CacleCls.isClear)
                            {
                                CacleCls.Clear(); //清理一次数据
                                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;
                            }
                        }

                        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;
                            }

                            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;
                            }
                        }
                    }));
                    Thread.Sleep(500);
                }
            }, _cts.Token);
        }

        /// <summary>
        /// ping服务器
        /// </summary>
        private void TaskPing() 
        {
            _cts2 = new CancellationTokenSource();
            Task.Run(() => {
                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;
                }
                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(() => {
                try
                {
                    if (CacleCls.weight < 500 && CacleCls.serverFlag) 
                    {
                        //检索本地实时库中结净数据。（若本地数据结净后，一次数据得删除，而结净数据中会保留一次数据的编号、重量、计量时间、计量点信息）
                        //若本地存在结净数据未进行上传的，则进行数据上传并得到返回的结果：老一次计量编号|一次计量编号,老二次计量编号|新二次计量编号
                        //得到结果后构造成Dictionary然后进行图片操作，修改图片名称及位置






                        string str = "老一次计量编号|一次计量编号,老二次计量编号|新二次计量编号";

                        dic.Clear();
                        string[] strs = str.Split(',');
                        dic.Add(strs[0].Split('|')[0], strs[0].Split('|')[1]);
                        dic.Add(strs[1].Split('|')[0], strs[1].Split('|')[1]);
                        imgControl.ZipFiles(dic);
                    }
                }
                catch (Exception)
                {
                    CacleCls.serverFlag = false;
                }
                Thread.Sleep(1000);
            }, _dbCts.Token);
        }

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


            if (CacleCls.serverFlag) //网络正常
            {
                if (CacleCls.firstDb != null)
                {
                    //进行结净
                    
                }
                else
                {
                    //进行一次计量
                    
                }
            }
            else 
            {
                //写本地文件
                bool flag = FileOption.WriterDb(new ActualFirstModel { actualFirstNo = "", baseSpotNo = "", baseSpotName = "", carNo = "", createTime = DateTime.Now, meterWeight = 999 },out msgInfo);
                if (flag)
                {
                    //计量完成
                }
                else 
                {
                    txtMsgInfo.Text = msgInfo;
                }
            }

            

            cbCarNo.Enabled = false;
            txtCarNo.Enabled = false;
            #endregion


            /*
            List<MeterWorkMonitor> lt = RedisCls.getValue<List<MeterWorkMonitor>>("MeterWorkMonitor");

            RedisCls.remoeItemValue("test001", JsonConvert.SerializeObject(new MeterWorkMonitor { pointNo = "00002", pointName = "计量点2" },
                new JsonSerializerSettings
                {
                    NullValueHandling = NullValueHandling.Ignore
                }));
            //*/

            /*
            List<MeterWorkMonitor> lt = new List<MeterWorkMonitor>()
            {
                new MeterWorkMonitor{ pointNo="00001",pointName="计量点1",updateTime=DateTime.Now },
                new MeterWorkMonitor{ pointNo="00002",pointName="计量点2" }
            };
            try
            {
                RedisCls.setVaule<List<MeterWorkMonitor>>("MeterWorkMonitor", lt, DateTime.Now.AddMinutes(2));
            }
            catch { }

            RedisCls.setItemVaule("test001", JsonConvert.SerializeObject(lt[0], 
                new JsonSerializerSettings
                {
                    NullValueHandling = NullValueHandling.Ignore
                }),
                DateTime.Now.AddSeconds(120));
            RedisCls.setItemVaule("test001", JsonConvert.SerializeObject(lt[1],
                new JsonSerializerSettings
                {
                    NullValueHandling = NullValueHandling.Ignore
                }), DateTime.Now.AddSeconds(60));
            //*/
        }

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

        private void frmMain_FormClosing(object sender, FormClosingEventArgs e)
        {
            rfid.ClosingCollect();

            if (bVoice) ce.StopTalk();

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

            plc.Stop();
            _cts?.Cancel();
            _cts2?.Cancel();
            _dbCts?.Cancel();
            carCls?.LoginOut();
            imgControl.Stop();
        }

        /// <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 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";

            //*/
        }
    }
}