using AutoMapper;
using FLY.Thick.Base.Common;
using FLY.Thick.Base.Server;
using FLY.Thick.Blowing;
using FLY.Thick.Blowing.Common;
using FLY.Thick.Blowing.IService;
using FLY.Thick.Blowing.Server;
using FLY.Thick.Blowing.Server.Model;
using FLY.Thick.BlowingScan.Common;
using FLY.Thick.BlowingScan.IService;
using FlyADBase;
using FObjBase;
using FObjBase.Reflect;
using MathNet.Numerics.LinearAlgebra.Double;
using Misc;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using HistoryDb = FLY.Thick.BlowingScan.Server.Model.HistoryDb;

namespace FLY.Thick.BlowingScan.Server
{
    public class GM_BlowingScan : GM_ScanMotion, IBlowingScanService
    {
        #region 延时操作，markno
        const int MARKNO_PROFILE_ADD = 87;
        const int MARKNO_PROFILE_CHANGED = 88;
        #endregion


        /// <summary>
        /// 当前扫描号
        /// </summary>
        public int ScanNo = 0;
        class ScanPosCell
        {
            public DateTime dt = DateTime.MinValue;
            public int pos;//位于膜的位置,不是机架
            public double thk;//两层的厚度
            //由pos转换!!
            public double angle1;//上层 位于膜泡的角度
            public double angle2;//下层 位于膜泡的角度
            public Misc.DIRECTION direction;//只有一整副数据都是同一个方向，才能解方程
            public ScanPosCell Clone()
            {
                ScanPosCell scanpos = new ScanPosCell();
                scanpos.dt = dt;
                scanpos.pos = pos;
                scanpos.thk = thk;
                scanpos.angle1 = angle1;
                scanpos.angle2 = angle2;
                scanpos.direction = direction;
                return scanpos;
            }
        }
        class EquationCell
        {
            public Dictionary<int, int> boltPower = new Dictionary<int, int>();//key=boltindex, value=power
            public double thk = 0;
            public int mainBolt;//主分区号
            public void Add(int boltindex1, int boltindex2, double thk)
            {
                if (boltPower.ContainsKey(boltindex1))
                {
                    boltPower[boltindex1]++;
                }
                else
                {
                    boltPower.Add(boltindex1, 1);
                }

                if (boltPower.ContainsKey(boltindex2))
                {
                    boltPower[boltindex2]++;
                }
                else
                {
                    boltPower.Add(boltindex2, 1);
                }
                this.thk += thk;
            }
            public override string ToString()
            {
                string str = "";
                foreach (var b in boltPower)
                {
                    str += "[" + b.Key.ToString() + "," + b.Value.ToString() + "] ";
                }
                return str;
            }
            public double[] GetPower(int nbolts)
            {
                double[] power = new double[nbolts];
                for (int i = 0; i < power.Count(); i++)
                    power[i] = 0;

                foreach (var kv in boltPower)
                {
                    power[kv.Key] = kv.Value;
                }
                return power;
            }
            public double GetAvg()
            {
                int cnt = 0;
                for (int i = 0; i < boltPower.Count(); i++)
                {
                    cnt += boltPower.Values.ElementAt(i);
                }
                if (cnt > 0)
                    return thk / cnt;
                else
                    return double.NaN;
            }
        }
        class ScanInfoCell
        {
            public ScanInfoCell Clone()
            {
                ScanInfoCell scaninfo = new ScanInfoCell(ScanNo, thks.Count());
                scaninfo.Direction = Direction;
                scaninfo.ScanNo = ScanNo;
                scaninfo.IsFull = IsFull;
                scaninfo.IndexOfToGetTime = IndexOfToGetTime;
                foreach (ScanPosCell scanpos in frame)
                {
                    scaninfo.frame.Add(scanpos.Clone());
                }
                scaninfo.width = width;
                scaninfo.beginPos = beginPos;
                scaninfo.endPos = endPos;
                scaninfo.lockbm = lockbm;
                return scaninfo;
            }

            public enum GetAngleResult
            {
                /// <summary>
                /// 全部grid 数据已经获取，而且都成功转为方程
                /// </summary>
                AllGet,
                /// <summary>
                /// 部分grid 数据已经获取，这次转化了一些方程
                /// </summary>
                PartGet,
                /// <summary>
                /// 什么都没干，没有转化为任何方程
                /// </summary>
                NothingToDo

            }
            public GetAngleResult GetAngle(BlowingDetect rdetect, int orgboltno, int sensorWidth)
            {
                bool bHasNewData = false;
                for (; IndexOfToGetAngle < IndexOfToGetTime; IndexOfToGetAngle++)
                {
                    int i = IndexOfToGetAngle;
                    ScanPosCell scanpos = frame[i];

                    FilmInfo filminfo;
                    if (scanpos.dt == DateTime.MinValue)
                    {
                        //异常，跳过
                        continue;
                    }
                    int ret = rdetect.GetFilmInfo(
                        out filminfo,
                        scanpos.dt,
                        width,
                        scanpos.pos
                        );

                    if (ret == 1)
                    {
                        //发生在未来，等下一次Poll

                        if (IsFull)
                            return GetAngleResult.NothingToDo;
                        else
                        {
                            if (bHasNewData)
                                return GetAngleResult.PartGet;
                            else
                                return GetAngleResult.NothingToDo;
                        }
                    }

                    if (filminfo == null)//异常,没回复
                    {
                        continue;
                    }

                    //成功获取
                    scanpos.angle1 = filminfo.angle1;
                    scanpos.angle2 = filminfo.angle2;
                    scanpos.direction = filminfo.direction;
                    if (IndexOfToGetAngle == 0)
                    {
                        Direction = scanpos.direction;
                    }
                    else
                    {
                        if (Direction != scanpos.direction)
                        {
                            Direction = DIRECTION.FIX;
                        }
                    }
                    //探头直径转为角度范围
                    double sensor_angle = 180.0 * sensorWidth / width;

                    if (AddEquation(i, orgboltno, sensor_angle))
                        bHasNewData = true;
                }

                if (IsFull)
                    return GetAngleResult.AllGet;
                else
                {
                    if (bHasNewData)
                        return GetAngleResult.PartGet;
                    else
                        return GetAngleResult.NothingToDo;
                }
            }

            /// <summary>
            /// 角度转分区序号, 角度范围[0~360°)
            /// </summary>
            /// <param name="a">膜泡角度[0~360°)</param>
            /// <param name="orgboltno">复位区号</param>
            /// <returns></returns>
            int GetBoltIndexFromAngle(double a, int orgboltno)
            {
                int boltno1st = 1;
                int nbolts = thks.Count();
                int boltindex = (int)(a / 360 * nbolts);

                boltindex += orgboltno - boltno1st;

                //100%确保输出的序号在有效范围内
                while (boltindex < 0)
                    boltindex += nbolts;//正常情况不会调用
                while (boltindex>=nbolts)
                    boltindex -= nbolts;//极端情况，a=360.2°, 这个会调用2次

                return boltindex;
            }

            int boltindex1_last = -1;
            /// <summary>
            /// 完成了一些方程，返回true
            /// </summary>
            /// <param name="scanpos_idx"></param>
            /// <param name="orgboltno">复位区号</param>
            /// <param name="sensor_angle">探头直径对应的角度范围</param>
            /// <returns></returns>
            bool AddEquation(int scanpos_idx, int orgboltno, double sensor_angle)
            {
                ScanPosCell scanpos = frame[scanpos_idx];

                if (equationList.Count() == 0)//复位记录
                    boltindex1_last = -1;

                EquationCell equation = new EquationCell();
                equationList.Add(equation);

                int boltindex1 = GetBoltIndexFromAngle(scanpos.angle1, orgboltno);
                equation.mainBolt = boltindex1;
                equation.Add(
                    GetBoltIndexFromAngle(scanpos.angle1, orgboltno),
                    GetBoltIndexFromAngle(scanpos.angle2, orgboltno),
                    scanpos.thk);

                //添加直径范围内的方程
                for (int i = 1; i < sensor_angle / 2; i++)
                {
                    equation.Add(
                        GetBoltIndexFromAngle(scanpos.angle1 + i, orgboltno),
                        GetBoltIndexFromAngle(scanpos.angle2 + i, orgboltno),
                        scanpos.thk);

                    equation.Add(
                        GetBoltIndexFromAngle(scanpos.angle1 - i, orgboltno),
                        GetBoltIndexFromAngle(scanpos.angle2 - i, orgboltno),
                        scanpos.thk);
                }

                if (boltindex1_last != boltindex1)//记录不同，通知外部是时候解方程了
                {
                    boltindex1_last = boltindex1;
                    return true;
                }
                return false;
            }
            public double GetAvg()
            {
                if (equationList.Count() < 0)
                    return double.NaN;
                double sum = 0;
                int cnt = 0;
                for (int i = 0; i < equationList.Count(); i++)
                {
                    EquationCell equation = equationList[i];
                    double a = equation.GetAvg();
                    if (!double.IsNaN(a))
                    {
                        sum += a;
                        cnt++;
                    }
                }
                if (cnt > 0)
                    return sum / cnt;
                else
                    return double.NaN;
            }
            //public void SaveEquation(StreamWriter sw) 
            //{

            //    for (int i = 0; i < equationList.Count(); i++) 
            //    {
            //        EquationCell equation = equationList[i];
            //        string s = ScanNo.ToString();
            //        s +=","+ Direction.ToString();
            //        s += "," + StartTime.ToString();
            //        s+=","+equation.thick.ToString();
            //        for (int j = 0; j <  equation.boltPower.Count(); j++) 
            //        {
            //            int boltindex = equation.boltPower.Keys.ElementAt(j);
            //            s += "," + boltindex.ToString();
            //            s += "," + equation.boltPower[boltindex].ToString();
            //        }
            //        sw.WriteLine(s);
            //    }    
            //}
            //public static void SaveEquation_Header(StreamWriter sw)
            //{
            //    string s = "序号,方向,时间,总厚度,序号1,数量1,序号2,数量2";
            //    sw.WriteLine(s);
            //}
            public ScanInfoCell(int scanNo, int nbolts)
            {
                Reset(scanNo);
                thks = new double[nbolts];
                for (int i = 0; i < nbolts; i++)
                {
                    thks[i] = double.NaN;
                }
            }
            /// <summary>
            /// 开始测量时间
            /// </summary>
            public DateTime StartTime;
            /// <summary>
            /// 结束测量时间
            /// </summary>
            public DateTime EndTime;
            /// <summary>
            /// 旋转架旋转的方向，当同一次扫描中，有两个方向，Direction= Fix；
            /// </summary>
            public Misc.DIRECTION Direction;
            /// <summary>
            /// 扫描号，必须唯一！！！！！
            /// </summary>
            public int ScanNo;
            /// <summary>
            /// grid数据，已经全部放入！！！！！
            /// </summary>
            public bool IsFull;
            /// <summary>
            /// 准备要去获取时间的ScanPosCell序号, -1, 整个scaninfo 都发生在过去，作废
            /// </summary>
            public int IndexOfToGetTime;
            /// <summary>
            /// 准备要去转角度的ScanPosCell序号
            /// </summary>
            public int IndexOfToGetAngle;
            /// <summary>
            /// 快速解方法，equationList序号
            /// </summary>
            public int IndexOfToSolveEquationQuick;
            public void Reset(int scanNo)
            {
                ScanNo = scanNo;
                frame.Clear();
                equationList.Clear();
                IsFull = false;
                IndexOfToGetTime = 0;
                IndexOfToGetAngle = 0;
                Direction = DIRECTION.FORWARD;
            }
            /// <summary>
            /// 复位数据；一幅grid成功生成,重新获取pos,thick,time,angle,equation
            /// </summary>
            /// <param name="beginPos"></param>
            /// <param name="endPos"></param>
            public void Reset_IsFull(int beginPos, int endPos)
            {
                this.beginPos = beginPos;
                this.endPos = endPos;
                this.width = endPos - beginPos + 1;//膜宽
                this.IsFull = true;

                equationList.Clear();
                frame.Clear();
                IndexOfToGetTime = 0;
                IndexOfToGetAngle = 0;
            }



            void ClearFrame()
            {
                equationList.Clear();
                frame.Clear();
                IndexOfToGetTime = 0;
                IndexOfToGetAngle = 0;
            }
            public void Reset2GetAngle()
            {
                IndexOfToGetAngle = 0;
                equationList.Clear();
                for (int i = 0; i < thks.Count(); i++)
                    thks[i] = double.NaN;
            }
            /// <summary>
            /// 原始数据(时间，位置，总厚度
            /// </summary>
            public List<ScanPosCell> frame = new List<ScanPosCell>();
            /// <summary>
            /// 膜的宽度
            /// </summary>
            public int width = -1;
            /// <summary>
            /// 膜边界左
            /// </summary>
            public int beginPos;
            /// <summary>
            /// 膜边界右
            /// </summary>
            public int endPos;

            /// <summary>
            /// 方程列表
            /// </summary>
            public List<EquationCell> equationList = new List<EquationCell>();
            /// <summary>
            /// 下面解方程得到的一幅数据对应的数据，与 StartTime 不一样
            /// </summary>
            public DateTime thicks_dt;
            /// <summary>
            /// 一幅数据
            /// </summary>
            public double[] thks;
            /// <summary>
            /// 经过分区表后的结果
            /// </summary>
            public double[] thks_map;

            /// <summary>
            /// 锁定 bookmark，只要解过一次方程，bookmark 就会被锁定，不能再修改
            /// </summary>
            public bool lockbm = false;
            public class SolveQuickResult
            {
                /// <summary>
                /// 新得到数据开始序号
                /// </summary>
                public int start_index;
                /// <summary>
                /// 新得到数据长度,这是一个环形队列
                /// </summary>
                public int len = 0;
            }
            /// <summary>
            /// 快速解方程
            /// </summary>
            /// <param name="org_thks">上一幅完成的数据</param>
            /// <param name="power">上一幅图所占的权重,当前只占1</param>
            /// <returns></returns>
            public SolveQuickResult SolveQuick(double[] org_thks, int power)
            {
                List<int> updateboltindex = new List<int>();
                for (int i = IndexOfToSolveEquationQuick; i < equationList.Count; i++, IndexOfToSolveEquationQuick++)
                {
                    EquationCell equation = equationList[i];


                    int mainpower = equation.boltPower[equation.mainBolt];
                    double sum = 0;
                    for (int j = 0; j < equation.boltPower.Count; j++)
                    {
                        int boltindex = equation.boltPower.Keys.ElementAt(j);

                        if (boltindex != equation.mainBolt)
                        {
                            if (org_thks == null)
                            {
                                mainpower += equation.boltPower[boltindex];
                            }
                            else if (double.IsNaN(org_thks[boltindex]))
                            {
                                mainpower += equation.boltPower[boltindex];
                            }
                            else
                            {
                                sum += equation.boltPower[boltindex] * org_thks[boltindex];
                            }
                        }
                    }
                    double mainBolt_value = (org_thks != null) ? org_thks[equation.mainBolt] : double.NaN;

                    if (!double.IsNaN(mainBolt_value))
                    {
                        //这个位置有效时，获取这个位置从现在到以前的均值
                        thks[equation.mainBolt] = (mainBolt_value * power + ((equation.thk - sum) / mainpower)) / (power + 1);
                    }
                    else
                    {
                        //这个位置无效时，获取这个位置以前的均值
                        thks[equation.mainBolt] = (equation.thk - sum) / mainpower;
                    }

                    updateboltindex.Add(equation.mainBolt);
                }
                SolveQuickResult result = new SolveQuickResult();
                if (updateboltindex.Count > 0)
                {
                    result.start_index = updateboltindex.Min();
                    result.len = updateboltindex.Max() - updateboltindex.Min() + 1;
                }
                return result;



            }
        }
        /// <summary>
        /// 每次扫描的数据, 
        /// 不是每一幅数据都能解出方程，
        /// 因为要连续3幅才能解出方程
        /// </summary>
        private RList<ScanInfoCell> mScanInfoList;
        /// <summary>
        /// 与 mScanInfoList 基本一样
        /// </summary>
        public RList<FlyData_BlowingScan> mBufList;

        #region IRenZiJiaService




        #region 分区设置


        /// <summary>
        /// 加热通道数
        /// </summary>
        public int ChannelCnt { get; set; } = 88;


        /// <summary>
        /// 分区数/加热通道数
        /// </summary>
        public int BPC { get; set; } = 1;

        /// <summary>
        /// 风环螺丝数
        /// </summary>
        public int NBolts => ChannelCnt * BPC;

        /// <summary>
        /// 人字架复位时,对应的螺丝号，0° 对应的 螺丝号
        /// </summary>
        public int OrgBoltNo { get; set; } = 1;

        private int smooth = 1;
        /// <summary>
        /// 平滑
        /// </summary>
        public int Smooth
        {
            get { return smooth; }
            set
            {
                if (value < 0)
                    value = 0;

                if (smooth != value)
                {
                    smooth = value;
                }
            }
        }


        /// <summary>
        /// 使用分区表
        /// </summary>
        public bool IsUsedMap { get; set; }
        bool IsNeedMap()
        {
            if (IsUsedMap && Map != null && Map.Count() > 0)
                return true;
            else
                return false;
        }

        private BoltMapCell[] map;
        /// <summary>
        /// 分区表,必须保证不能为null
        /// </summary>
        public BoltMapCell[] Map
        {
            get { return map; }
            set
            {
                //检测是否不一样
                if (!IsEquals(map, value))
                {
                    if (!IsValid(value))
                    {
                        IsUsedMap = false;
                        map = null;
                    }
                    else
                    {
                        map = value;
                    }
                }
            }
        }

        /// <summary>
        /// 检测通过，返回true
        /// </summary>
        /// <returns></returns>
        bool IsValid(BoltMapCell[] mapCells)
        {
            bool map_err = false;
            bool g_o = false;
            bool g_n = false;
            if (mapCells == null)
                return true;

            //Map 检测
            //OldNo,NewNo不能 <1 >NBolts
            //Map OldNo 必须从小到大环形排列
            //Map NewNo 必须从小到大环形排列
            for (int i = 0; i < mapCells.Count(); i++)
            {
                var mapCell = mapCells[i];
                if (mapCell.NewNo < 1 || mapCell.NewNo > NBolts)
                {
                    map_err = true;
                    break;
                }
                if (mapCell.OldNo < 1 || mapCell.OldNo > NBolts)
                {
                    map_err = true;
                    break;
                }

                int i_next = i + 1;
                if (i_next >= mapCells.Count())
                    i_next = 0;

                var mapCell_next = mapCells[i_next];
                if (mapCell.OldNo >= mapCell_next.OldNo)
                {
                    if (!g_o)
                        g_o = true;
                    else
                    {
                        map_err = true;
                        break;
                    }

                }

                if (mapCell.NewNo >= mapCell_next.NewNo)
                {
                    if (!g_n)
                        g_n = true;
                    else
                    {
                        map_err = true;
                        break;
                    }

                }
            }

            if (map_err)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        bool IsEquals(BoltMapCell c1, BoltMapCell c2)
        {
            if (c1 == c2)
            {
                return true;
            }
            if (c1 == null && c2 != null)
                return false;
            if (c1 != null && c2 == null)
                return false;
            if (c1.NewNo != c2.NewNo)
                return false;
            if (c1.OldNo != c2.OldNo)
                return false;
            return true;
        }
        bool IsEquals(BoltMapCell[] mapCells1, BoltMapCell[] mapCells2)
        {
            if (mapCells1 == mapCells2)
                return true;
            if (mapCells1 == null && mapCells2 != null)
                return false;
            if (mapCells1 != null && mapCells2 == null)
                return false;
            if (mapCells1.Count() != mapCells2.Count())
                return false;

            //mapCells1 与 mapCells2 肯定都不是 null 且数量一样
            for (int i = 0; i < mapCells1.Count(); i++)
            {
                var c1 = mapCells1[i];
                var c2 = mapCells2[i];
                if (!IsEquals(c1, c2))
                    return false;
            }
            return true;
        }
        #endregion

        /// <summary>
        /// 测厚仪类型， 追边 or 扫描
        /// </summary>
        public BlowingType BType { get; } = BlowingType.Scan;
        /// <summary>
        /// 测厚仪测量点位置方向：Left， Right （也就是三角形在左还是右）
        /// </summary>
        public bool IsProbeRight { get; set; } = true;

        /// <summary>
        /// 正方向是顺时钟;
        /// 信号0->信号1 为正方向;
        /// 风环加热棒排列方向为 正方向;
        /// 默认情况 风环加热棒排列是逆时钟
        /// </summary>
        public bool IsForwCW { get; set; }

        /// <summary>
        /// 应用
        /// </summary>
        public void Apply()
        {
            Save();
        }

        [Push(typeof(RenZiJiaDataEventArgs))]
        public event EventHandler DataEvent;
        #endregion

        /// <summary>
        /// 缓冲区数据量
        /// </summary>
        public int BufListCount { get; private set; } = 0;
        /// <summary>
        /// 缓冲区最后一个记录序号
        /// </summary>
        public int BufListLastNo { get; private set; } = -1;

        private int sensorwidth = 250;
        /// <summary>
        /// 探头宽度，用于解方程，可以与实际不符合 单位脉冲
        /// </summary>
        public int SensorWidth
        {
            get { return sensorwidth; }
            set
            {
                if (value < 1)
                    value = 1;

                if (sensorwidth != value)
                {
                    sensorwidth = value;
                }
            }
        }

        private int solvecnt = 4;
        /// <summary>
        /// 多少次扫描解一次方程
        /// </summary>
        public int SolveCnt
        {
            get { return solvecnt; }
            set
            {
                if (value < 3)
                    value = 3;

                if (solvecnt != value)
                {
                    solvecnt = value;
                }
            }
        }
        void checkParamErr()
        {


            if (ChannelCnt < 20 || ChannelCnt > 160)
            {
                ChannelCnt = 44;
            }

            if (BPC < 1 || BPC > 4)
            {
                BPC = 2;
            }

            if (OrgBoltNo < 1 || OrgBoltNo > NBolts)
            {
                OrgBoltNo = 1;
            }

            if (SolveCnt > 20)
            {
                SolveCnt = 5;
            }

            if (!IsValid(Map))
            {
                IsUsedMap = false;
                Map = null;
            }
        }



        /// <summary>
        ///边界查找模块 
        /// </summary>
        private BorderSearch mBorderSearch;


        /// <summary>
        ///人字架位置检测器 
        /// </summary>
        public BlowingDetect mPDetect;

        /// <summary>
        /// AD值转厚度值 
        /// </summary>
        private AD2ThkHandler Ad2Thk;


        BlowingFixProfileParam mProfileParam;

        HistoryDb mHistoryDb;

        BulkDb bulkDb;

        /// <summary>
        /// 动态数据组合
        /// </summary>
        private DynArea mDynArea;
        /// <summary>
        /// 扫描脉冲检测 
        /// </summary>
        private ScanPosDetect mScanPosDetect;
        InitParam initParam;
        OBJComponents.Server.WarningSystem2 warningSystem;

        public GM_BlowingScan()
        {

            mPDetect = new BlowingDetect();
            mScanInfoList = new RList<ScanInfoCell>(30);
            mBufList = new RList<FlyData_BlowingScan>(100);
            mScanPosDetect = new ScanPosDetect();

            ChannelCnt = 44;//加热棒数量
            BPC = 2;//分区数量/加热棒数量

            OrgBoltNo = 10;//复位时，测厚仪对应的螺丝号

            SolveCnt = 5;
            mPDetect.Load();
            Load();

            //检测参数
            mPDetect.CheckParamErr();
            checkParamErr();

            if (SolveCnt < 3)
                SolveCnt = 3;

            PropertyChanged += new PropertyChangedEventHandler(RenZiJiaScan_PropertyChanged);

            mPDetect.PropertyChanged += (s, e) =>
            {
                NotifyPropertyChanged(e.PropertyName);
            };

            mPDetect.FilmInfoChangedEvent += new FilmInfoChangedEventHandler(mPDetect_FilmInfoChangedEvent);
            mPDetect.ClearEvent += new ClearEventHandler(mPDetect_ClearEvent);



        }

        public void Init(
            FlyAD7 flyAd,
            GSample gsample, InitParam initParam, OBJComponents.Server.WarningSystem2 warningSystem,
            BorderSearch borderSearch,
            DynArea dynArea, AD2ThkHandler ad2thk,
            BlowingFixProfileParam profileParam,
            HistoryDb historyDb, BulkDb bulkDb
            )
        {
            base.Init(flyAd, gsample);
            this.initParam = initParam;
            this.warningSystem = warningSystem;

            Ad2Thk = ad2thk;
            mBorderSearch = borderSearch;
            mDynArea = dynArea;
            mProfileParam = profileParam;
            mHistoryDb = historyDb;
            this.bulkDb = bulkDb;

            mPDetect.Init(mFlyAD);

            mScanPosDetect.Init(mFlyAD);


            //接收PollScan的推送
            DataPosEvent += new EndEventHandler(pollScan_DataPosEvent);
            EndEvent += new EndEventHandler(pollScan_EndEvent);

            //记录调试数据
            //MarkDebugInit();
        }
        #region 记录原始数据
        //DateTime markdebug_dt = DateTime.MinValue;
        //int markdebug_lastBm = -1;
        //void MarkDebugInit()
        //{
        //    if (markdebug_dt == DateTime.MinValue)
        //        markdebug_dt = DateTime.Now;

        //    //启动1分钟定时器
        //    FObjBase.PollModule.Current.Poll_Config(
        //        FObjBase.PollModule.POLL_CONFIG.ADD,
        //        () =>
        //        {
        //            mPDetect.GetSignList(markdebug_dt, (asyncState, retData) =>
        //            {
        //                var reponse = retData as GetSignListReponse;
        //                var cells = reponse.datas;
        //                if (cells.Count > 0)
        //                {
        //                    mHistoryDb.AddSignData(
        //                        new Lc_Sign()
        //                        {
        //                            Time = cells.First().Time,
        //                            Signs = cells.ToArray()
        //                        });
        //                }
        //            }, null);
        //            mPDetect.GetRollList(markdebug_dt, (asyncState, retData) =>
        //            {
        //                var reponse = retData as GetRollListReponse;
        //                var cells = reponse.datas;
        //                if (cells.Count > 0)
        //                {
        //                    mHistoryDb.AddRollData(
        //                        new Lc_Roll()
        //                        {
        //                            Time = cells.First().dt,
        //                            Signs = cells.ToArray()
        //                        });
        //                }
        //            }, null);

        //            int index = mBufList.No2Index(markdebug_lastBm);
        //            index++;
        //            if (index < 0)
        //                index = 0;

        //            if (index < mBufList.Count())
        //            { 
        //                //有新的数据
        //                List<Model.Lc_OrgScanData> lc_OrgScanDatas = new List<Model.Lc_OrgScanData>();
        //                for (int i = index; i < mBufList.Count(); i++)
        //                {
        //                    var data = mBufList[i];

        //                    var times = data.ThicksDt.Where(dt => dt != DateTime.MinValue);
        //                    if (times.Count() == 0)
        //                        continue;
        //                    Model.Lc_OrgScanData lcOrgScanData = new Model.Lc_OrgScanData();
        //                    lcOrgScanData.Time = times.Min();
        //                    lcOrgScanData.FilmBegin = data.FilmRange.Begin;
        //                    lcOrgScanData.FilmEnd = data.FilmRange.End;
        //                    lcOrgScanData.PosOfGrid = data.PosOfGrid;
        //                    lcOrgScanData.K = mProfileParam.K;
        //                    lcOrgScanData.Thicks = ToRealThicks(data.Thicks);
        //                    lcOrgScanData.ThicksDt = data.ThicksDt;
        //                    lc_OrgScanDatas.Add(lcOrgScanData);
        //                }
        //                mHistoryDb.AddOrgScanDatas(lc_OrgScanDatas);

        //            };
        //            markdebug_dt = DateTime.Now;
        //        },
        //        TimeSpan.FromMinutes(1));
        //}

        #endregion

        double[] Round(IEnumerable<double> frame, int digits)
        {
            return frame.Select(t =>
            {
                if (!double.IsNaN(t))
                    return Math.Round(t, digits);
                else
                    return double.NaN;
            }).ToArray();
        }
        void RenZiJiaScan_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == nameof(NBolts))
            {
                //所有数据删除
                mScanInfoList.Clear();
                //TODO!!!!!
                //停下来
            }
            else if (e.PropertyName == nameof(OrgBoltNo))
            {
                for (int i = 0; i < mScanInfoList.Count(); i++)
                {
                    mScanInfoList[i].Reset2GetAngle();
                }
            }
        }
        void mPDetect_FilmInfoChangedEvent(object sender, FilmInfoChangedEventArgs e)
        {
            // 找到 e.Time 对应的 scaninfo

            for (int i = 0; i < mScanInfoList.Count; i++)
            {
                ScanInfoCell scaninfo = mScanInfoList[i];
                if (scaninfo.IndexOfToGetTime > 0)
                {
                    DateTime dt_start = scaninfo.frame[0].dt;
                    DateTime dt_end = scaninfo.frame[scaninfo.IndexOfToGetTime - 1].dt;
                    if (e.Time < dt_end)//找到了 
                    {
                        for (int j = i; j < mScanInfoList.Count; j++)
                        {
                            scaninfo = mScanInfoList[j];
                            scaninfo.IndexOfToGetAngle = 0;
                        }
                        return;
                    }
                }
            }
        }
        void mPDetect_ClearEvent(object sender)
        {
            //已经很久没数据，清空全部！！！！！！！

            //scanposdetect
            mScanPosDetect.ScanNo = ScanNo;

            if (mScanInfoList.Count > 0)
            {
                mScanInfoList.Clear();

                //scaninfo
                ScanInfoCell scaninfo = new ScanInfoCell(ScanNo, NBolts);
                //scaninfo.bookmark = bookmark;
                mScanInfoList.Add(scaninfo);
            }
        }


        #region 1.grid 数据 转 ScanPosCell.(pos,thick)  放入 mScanInfoList.Last()
        /// <summary>
        /// 动态获取！！！！ 
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="e"></param>
        void pollScan_DataPosEvent(object obj, FlyADBase.MiniGridEventArgs e)
        {
            DIRECTION direction = e.direction;
            int posOfGrid = e.posOfGrid;
            int start_idx = e.grid_start;
            int start_pos = e.grid_start * e.posOfGrid;
            int[] dat = e.buf;
            //-------------------------------------
            //DIR

            mDynArea.AD = dat[0];
            mDynArea.Thk = Ad2Thk(dat[0]);


            if (mScanInfoList.Count == 0)
                return;

            ScanInfoCell scaninfocell = mScanInfoList.Last();
            if (scaninfocell.width <= 0)
            {
                //刚开始，连膜边都还没找到
                return;
            }

            //找边界前，要对数据进行校正

            //尽可能不要两个边的数据，N2是边界向内减, 只是不要更多的数据而已
            int bp = scaninfocell.beginPos + mBorderSearch.N2;
            int ep = scaninfocell.endPos - mBorderSearch.N2;
            //对应的grid号
            int bp_idx = bp / posOfGrid;
            int ep_idx = ep / posOfGrid;

            if (bp_idx < start_idx)
                bp_idx = start_idx;

            if (ep_idx > (start_idx + dat.Length - 1))
                ep_idx = start_idx + dat.Length - 1;

            for (int i = bp_idx; i <= ep_idx; i++)
            {
                int idx = i - start_idx;

                int pos = i * posOfGrid + posOfGrid / 2;//一个grid的中间脉冲，也就是大概而已
                double thk = double.NaN;
                if (!double.IsNaN(dat[idx]))
                    thk = Ad2Thk(dat[idx]) * 2;

                pos -= scaninfocell.beginPos;//膜上面的位置
                scaninfocell.frame.Add(new ScanPosCell() { pos = pos, thk = thk });
            }
            OnPoll_GetTime2();
        }
        void pollScan_EndEvent(object obj, FlyADBase.MiniGridEventArgs e)
        {
            DIRECTION direction = e.direction;
            int posOfGrid = e.posOfGrid;
            int start_idx = e.grid_start;
            int start_pos = e.grid_start * e.posOfGrid;
            int[] dat = e.buf;

            //int scaninfo_idx = mScanInfoList.FindIndex(sil => sil.IndexOfToGetTime < sil.frame.Count);
            //if ((scaninfo_idx>0) && (mScanInfoList.Count - scaninfo_idx > 1) )
            //{
            //    //有问题
            //}


            ScanNo++;
            mScanPosDetect.ScanNo = ScanNo;

            if (gsample.Samples[0].AD <= 0)
            {
                //无温修AD
                if (mScanInfoList.Count == 0)
                    return;

                ScanInfoCell scaninfo = mScanInfoList.Last();
                //清空动态数据
                bulkDb.SetTempFrame(scaninfo.StartTime, scaninfo.EndTime, 0, null);
                scaninfo.Reset(ScanNo);
                return;
            }

            //找边界
            bool ret = mBorderSearch.FindFilm(direction, posOfGrid, start_idx, dat);
            if (!ret)//不能找到边界！！！没膜！！！！
            {
                mBorderSearch.Reset();

            }
            //设置扫描范围
            //POLLSCAN----------------------------------------	
            Range scanrange = mBorderSearch.GetScanRange();

            ScanStart = scanrange.Begin;// beginPos;
            ScanEnd = scanrange.End;// endPos;

            if (!ret)
            {
                if (mScanInfoList.Count == 0)
                    return;

                ScanInfoCell scaninfo = mScanInfoList.Last();
                //清空动态数据
                bulkDb.SetTempFrame(scaninfo.StartTime, scaninfo.EndTime, 0, null);
                scaninfo.Reset(ScanNo);
                return;
            }

            //必须设置好 mBorderSearch.SensorWidth，它就是探头直径
            Range border = mBorderSearch.GetBorder(direction);

            if (mScanInfoList.Count == 0)//安全检查，不可能发生的！！！！！
                return;

            ScanInfoCell scaninfocell = mScanInfoList.Last();
            //膜宽，和位置一起计算旋转架上的角度
            scaninfocell.Reset_IsFull(border.Begin, border.End);

            //尽可能不要两个边的数据，N2是边界向内减, 只是不要更多的数据而已
            Range boltrange = mBorderSearch.GetBoltRange(direction);

            //对应的grid号
            int bp_idx = boltrange.Begin / posOfGrid;
            int ep_idx = boltrange.End / posOfGrid;

            if (bp_idx < start_idx)
                bp_idx = start_idx;

            if (ep_idx > (start_idx + dat.Length - 1))
                ep_idx = start_idx + dat.Length - 1;

            for (int i = bp_idx; i <= ep_idx; i++)
            {
                int idx = i - start_idx;
                int pos = i * posOfGrid + posOfGrid / 2;//一个grid的中间脉冲，也就是大概而已
                double thk = double.NaN;
                if (Misc.MyBase.ISVALIDATA(dat[idx]))
                    thk = Ad2Thk(dat[idx]) * 2;

                pos -= border.Begin;//膜上面的位置
                scaninfocell.frame.Add(new ScanPosCell() { pos = pos, thk = thk });
            }



            //或取每个数据对应的时间点
            OnPoll_GetTime2();

            //把扫描数据放多一份到 mBufList
            PushToBufList(e, border, scaninfocell.ScanNo);

            //插入纵向数据
            #region sqlite3 历史数据保存
            {
                List<double> boltValues = new List<double>();
                double boltwidth = scaninfocell.width * 1.0 / (NBolts / 2);
                int boltIdx = 0;
                double boltSum = 0;
                int boltCnt = 0;

                for (int i = 0; i < scaninfocell.frame.Count(); i++)
                {
                    int idx = (int)(scaninfocell.frame[i].pos / boltwidth);
                    if (boltIdx != idx)
                    {
                        if (boltCnt > 0)
                        {
                            boltValues.Add(boltSum / boltCnt);
                            boltSum = 0;
                            boltCnt = 0;
                        }
                    }
                    boltIdx = idx;
                    if (!double.IsNaN(scaninfocell.frame[i].thk))
                    {
                        boltSum += scaninfocell.frame[i].thk / 2;
                        boltCnt++;
                    }

                }
                if (boltCnt > 0)
                {
                    double v = boltSum / boltCnt;
                    v = Math.Round(v, 2);//限制小数点

                    boltValues.Add(v);
                }

                mHistoryDb.AddTrendData(new Lc_TrendData()
                {
                    Time = DateTime.Now,
                    K = mProfileParam.K,
                    Thicks = boltValues.ToArray()
                });
            }

            #endregion


            //创建一个新的 scaninfocell 
            //为下一趟即时扫描作准备
            scaninfocell = new ScanInfoCell(ScanNo, NBolts);

            direction = (direction == DIRECTION.FORWARD) ? DIRECTION.BACKWARD : DIRECTION.FORWARD;
            border = mBorderSearch.GetBorder(direction);
            scaninfocell.beginPos = border.Begin;
            scaninfocell.endPos = border.End;
            scaninfocell.width = border.Width;//膜宽
            scaninfocell.IsFull = false;
            mScanInfoList.RAdd(scaninfocell);
        }
        void PushToBufList(MiniGridEventArgs e, Range border, int scanNo)
        {
            DIRECTION direction = e.direction;
            int posOfGrid = e.posOfGrid;
            int start_idx = e.grid_start;
            int start_pos = e.grid_start * e.posOfGrid;
            int[] dat = e.buf;


            FlyData_BlowingScan f = new FlyData_BlowingScan();
            f.FilmRange = border;
            f.PosOfGrid = posOfGrid;
            f.Thks = new double[mFlyAD.PosLen / posOfGrid];
            f.ThicksDt = new DateTime[f.Thks.Count()];
            //对应的grid号
            for (int i = 0; i < f.Thks.Count(); i++)
            {
                int idx = i - start_idx;
                int pos = i * posOfGrid + posOfGrid / 2;//一个grid的中间脉冲，也就是大概而已

                double thk = double.NaN;
                if (idx >= 0 && idx < dat.Count())
                {
                    if (!double.IsNaN(dat[idx]))
                    {
                        thk = Ad2Thk(dat[idx]) * 2;
                        thk = Math.Round(thk, 2);//保存到 FlyData_BlowingScan 的, 需要通讯， 限制小数点
                    }
                }
                f.Thks[i] = thk;

                DateTime dt = DateTime.MinValue;
                if (!double.IsNaN(thk))
                {
                    int ret = mScanPosDetect.GetTime(pos, scanNo, out dt);
                }
                f.ThicksDt[i] = dt;
            }

            f.RotateCnt = mPDetect.RotationCnt;
            if (mPDetect.mLimitList.Count() > 0)
            {
                LimitCell lc = mPDetect.mLimitList.Last();
                f.SignNo = lc.no;
                f.Time = lc.dt_begin;
                f.LeaveTime = lc.dt_end;
            }
            else
            {
                f.SignNo = -1;
                f.Time = DateTime.MinValue;
                f.LeaveTime = DateTime.MinValue;
            }

            f.LimitSignTime = mPDetect.LimitSignTime;
            f.RotatePeriod = mPDetect.RenZiJiaPeriod;

            f.Velocity = mPDetect.FilmVelocity;

            mBufList.RAdd(f);
            BufListLastNo = mBufList.GetLastNo();
            BufListCount = mBufList.Count();
        }
        #endregion
        #region 2.填入 ScanPosCell.(dt)  
        /// <summary>
        /// 找到一幅数据，每个grid 对应的时间点
        /// </summary>
        void OnPoll_GetTime2()
        {
            ScanInfoCell scaninfo = mScanInfoList.Last();

            for (; scaninfo.IndexOfToGetTime < scaninfo.frame.Count; scaninfo.IndexOfToGetTime++)
            {
                int i = scaninfo.IndexOfToGetTime;
                ScanPosCell scanpos = scaninfo.frame[i];
                //还原为机架位置
                int pos = scaninfo.beginPos + scanpos.pos;

                DateTime dt;
                int ret = mScanPosDetect.GetTime(pos, scaninfo.ScanNo, out dt);
                if (ret == -2)
                {
                    //发生在过去，不正常

                }
                else if (ret == 1)//这个是未来的，等下一次Poll
                {
                    return;
                }
                else if (dt == DateTime.MinValue)
                {
                    //出错， 把scaninfo 删除掉
                    //mScanInfoList.RemoveAt(scaninfo_idx);
                    //scaninfo_idx--;
                    break;
                }
                //成功获取

                scanpos.dt = dt;
                if (i == 0)
                {
                    scaninfo.StartTime = dt;
                    scaninfo.thicks_dt = dt;
                }
                scaninfo.EndTime = dt;
            }
        }
        #endregion
        #region 3.填入 ScanPosCell.(angle1,angle2), 且转为 Equation 
        void OnPoll_GetAngle()
        {
            int scaninfo_idx = mScanInfoList.FindIndex(
                sil =>
                    (sil.IndexOfToGetAngle < sil.IndexOfToGetTime));

            if (scaninfo_idx == -1)
            {
                return;//全部都转换完成！！
            }

            while (true)
            {
                ScanInfoCell scaninfo = mScanInfoList[scaninfo_idx];

                ScanInfoCell.GetAngleResult result = scaninfo.GetAngle(mPDetect, OrgBoltNo, SensorWidth);
                if (result == ScanInfoCell.GetAngleResult.NothingToDo)
                {
                    //getangle 失败，发生在未来，等下一次Poll
                    break;
                }

                //解方程，画数据！！
                ToThicks(scaninfo_idx);


                //全部GetAngle 成功，下一个scaninfo
                scaninfo_idx++;
                if (scaninfo_idx >= mScanInfoList.Count)
                    break;//已经没有了
            }
        }


        class CalSolveCnt
        {
            List<int> list = new List<int>();
            const int listcap = 5;
            void Add(int cnt)
            {
                list.Add(cnt);
                if (list.Count > listcap)
                    list.RemoveAt(0);
            }
            public int Max()
            {
                if (list.Count > 0)
                    return list.Max();
                else
                    return 4;
            }
            Misc.DIRECTION direction = DIRECTION.FIX;
            int cnt = 0;
            public bool Check(Misc.DIRECTION direction)
            {
                if (this.direction != direction)
                {
                    if ((this.direction != Misc.DIRECTION.FIX) && (cnt > 3))
                        Add(cnt);
                    cnt = 0;
                }
                cnt++;
                this.direction = direction;
                return OK();
            }
            public bool OK()
            {
                if (list.Count >= listcap)
                {
                    return true;
                }
                return false;
            }
        }
        CalSolveCnt mCalSolveCnt = new CalSolveCnt();

        /// <summary>
        /// 解方程
        /// </summary>
        /// <param name="scaninfo_idx"></param>
        /// <returns></returns>
        bool ToThicks_SolveEquation(int scaninfo_idx)
        {
            ScanInfoCell scaninfo = mScanInfoList[scaninfo_idx];
            if (scaninfo.Direction == DIRECTION.FIX)//当前是Fix 不解方程
                return false;

            //解方程数量检测，免得一直数量不足，解不了方程
            //if (mCalSolveCnt.Check(scaninfo.Direction)) 
            //{
            //    if (SolveCnt > (mCalSolveCnt.Max()-1)) 
            //    {
            //        SolveCnt = (mCalSolveCnt.Max() - 1);
            //    }
            //}

            if (scaninfo_idx < (SolveCnt - 1))
                return false;

            //全部方向都必须一致，当然也不能是Fix
            //for (int i = 0; i < (SolveCnt - 1); i++)
            //{
            //    if (scaninfo.Direction != mScanInfoList[scaninfo_idx - 1 - i].Direction)
            //        return false;
            //}

            double avg = scaninfo.GetAvg();
            if (double.IsNaN(avg))//平均值不合法！！！！
                return false;

            if (avg < 5)//小于5um ，太小！！！
                return false;

            List<EquationCell> equationlist = new List<EquationCell>();
            ////全部平均值相差不能超过 5%
            //for (int i = 0; i < SolveCnt; i++)
            //{
            //    int a = mScanInfoList[scaninfo_idx - 1 - i].GetAvg();
            //    if (Math.Abs((a - avg) / avg) > 0.05)
            //        return false;
            //    equationlist.AddRange(mScanInfoList[scaninfo_idx - i].equationList);
            //}


            int cnt = 0;
            for (int i = scaninfo_idx; i >= 0; i--)
            {
                if (mScanInfoList[i].Direction == DIRECTION.FIX)
                    continue;
                cnt++;
                double a = mScanInfoList[i].GetAvg();
                double p = (a - avg) / avg;
                if (Math.Abs(p) > 0.05)
                    return false;
                equationlist.AddRange(mScanInfoList[i].equationList);

                if (cnt >= SolveCnt)
                    break;
            }
            if (cnt < SolveCnt)//方程不够！！！！
                return false;

            if (equationlist.Count < 100)//方程数太少
                return false;

            //2105 条方程，耗时 0.3s
            SolveEquation(mScanInfoList[scaninfo_idx].thks, equationlist);

            //不能有任何一个NULL_VALUE
            for (int i = 0; i < scaninfo.thks.Count(); i++)
            {
                if (double.IsNaN(scaninfo.thks[i]))
                    return false;
                if (scaninfo.thks[i] > 10000)
                    return false;
                if (scaninfo.thks[i] < -100)
                    return false;
            }

            //检测
            {
                double sigma = scaninfo.thks.Sigma();
                double avg2 = scaninfo.thks.Average();


                double p = 1.0 * (avg2 - avg) / avg;
                if (Math.Abs(p) > 0.05)//变化太大，不可能！！！
                    return false;
                p = 1.0 * sigma / avg2;
                if (Math.Abs(p) > 0.5) //波动太大,异常
                    return false;
            }
            //最后处理，滤波，平滑
            if (Smooth > 0)
            {
                double[] data = new double[scaninfo.thks.Count()];
                for (int i = 0; i < scaninfo.thks.Count(); i++)
                {
                    double sum = 0;

                    for (int j = 0; j < (Smooth * 2 + 1); j++)
                    {
                        int index = i + j - Smooth;
                        if (index < 0)
                            index += scaninfo.thks.Count();
                        else if (index >= scaninfo.thks.Count())
                            index -= scaninfo.thks.Count();
                        sum += scaninfo.thks[index];
                    }
                    data[i] = (sum / (Smooth * 2 + 1));
                }
                Array.Copy(data, scaninfo.thks, data.Count());
            }
            scaninfo.thicks_dt = mScanInfoList[scaninfo_idx - (SolveCnt - 1)].StartTime;

            return true;
        }


        enum BindingMotion
        {
            Add,
            Remove
        }

        DateTime lastTempBeginTime;
        bool ToThicks(int scaninfo_idx)
        {
            ScanInfoCell scaninfo = mScanInfoList[scaninfo_idx];

            if (scaninfo.IsFull)//所有grid数据都获取完，解方程
            {
                if (scaninfo.lockbm)
                {
                    //不需要再解方程，算thicks 的值！！！
                    return false;
                }

                if (ToThicks_SolveEquation(scaninfo_idx))
                {
                    //解方程成功

                    //重新分区
                    if (IsNeedMap())
                    {
                        //上面已经检查了 Map == null 的情况
                        Dictionary<int, int> map = new Dictionary<int, int>();
                        for (int i = 0; i < Map.Count(); i++)
                            map.Add(Map[i].OldNo - 1, Map[i].NewNo - 1);
                        scaninfo.thks_map = Misc.MyMath.Map(scaninfo.thks, map);
                    }

                    //更新数据库内容
                    {
                        double[] frame;
                        List<BoltMapCell> map;
                        if (IsNeedMap())
                        {
                            //上面已经检查了 Map == null 的情况
                            frame = scaninfo.thks_map;
                            map = new List<BoltMapCell>();
                            foreach (var m in Map)
                                map.Add(m.Clone());
                        }
                        else
                        {
                            frame = scaninfo.thks;
                            map = null;
                        }
                        var realthicks = Round(frame, 2);
                        var renZiJiaDataEventArgs = new RenZiJiaDataEventArgs()
                        {
                            Time = scaninfo.thicks_dt,
                            EndTime = scaninfo.EndTime,
                            IsBackw = scaninfo.Direction == DIRECTION.BACKWARD,
                            RPeriod = mPDetect.RenZiJiaPeriod,
                            RCnt = mPDetect.RotationCnt,
                            OrgBoltNo = OrgBoltNo,
                            RAngle = mPDetect.RAngle,
                            FilmLength = mPDetect.FilmLength,
                            FilmVelocity = mPDetect.FilmVelocity,
                            K = mProfileParam.K,
                            Thicks = realthicks,
                            Boltmap = map
                        };

                        //TODO 只有最后一幅图推送
                        //if(scaninfo_idx == mScanInfoList.Count() - 1) //居然还有一幅更新的，但里面数据是空
                        {
                            bulkDb.SetTempFrame(scaninfo.StartTime, scaninfo.EndTime, 0, Round(scaninfo.thks, 2));

                            if (!mDynArea.SecuteLock) //授权过期, 没有数据
                            {
                                DataEvent?.Invoke(this, renZiJiaDataEventArgs);
                            
                                //TODO 需要检查是否重复写入了！！！！！
                                #region sqlite3 历史数据保存
                                var lc_scandata = Lc_AutoMapperProfile.Mapper.Map<Lc_ScanData>(renZiJiaDataEventArgs);
                            
                                mHistoryDb.AddScanData(lc_scandata);
                            }
                            
                            #endregion
                        }
                    }
                }
                else
                {
                    //失败，删除！！！
                    for (int i = 0; i < scaninfo.thks.Count(); i++)
                        scaninfo.thks[i] = double.NaN;
                }
                scaninfo.lockbm = true;
                return true;
            }
            else
            {
                //还没获取完所有grid, 简易解方程，只认为 mainBolt 是未知的，其它都是已知的,用上一幅数据的值
                //这样的数据不需要放在数据库中！！！！！！

                double[] org_thks = null;
                if (scaninfo_idx != 0)
                    org_thks = mScanInfoList[scaninfo_idx - 1].thks;

                ScanInfoCell.SolveQuickResult result = scaninfo.SolveQuick(org_thks, SolveCnt - 1);

                if (mScanInfoList.Count() - 1 == scaninfo_idx)
                {
                    //最后一幅图，需要画出来
                    if (result.len > 0)
                    {
                        if (scaninfo.StartTime != lastTempBeginTime)
                        {
                            //新的，全部发送
                            bulkDb.SetTempFrame(scaninfo.StartTime, scaninfo.EndTime, 0, Round(scaninfo.thks, 2));
                        }
                        else
                        {
                            int cnt = scaninfo.thks.Count() - result.start_index;
                            if (result.len < cnt)
                            {
                                //没有环路
                                var thks = scaninfo.thks.Skip(result.start_index).Take(result.len);
                                bulkDb.SetTempFrame(scaninfo.StartTime, scaninfo.EndTime, result.start_index, Round(thks, 2));
                            }
                            else
                            {
                                //转了个圈，只能全部发送
                                bulkDb.SetTempFrame(scaninfo.StartTime, scaninfo.EndTime, 0, Round(scaninfo.thks, 2));
                            }
                        }
                        lastTempBeginTime = scaninfo.StartTime;
                    }
                }
            }
            return false;
        }
        /// <summary>
        /// 解方程
        /// </summary>
        /// <param name="equationList">N条方程</param>
        /// <param name="frame_out">输出的结果</param>
        void SolveEquation(double[] frame_out, List<EquationCell> equationList)
        {

            int nrow = equationList.Count();
            //A~AX = A~B
            //转换为 DenseMatrix 与 DenseVector
            DenseMatrix matrixA = new DenseMatrix(nrow, NBolts);
            DenseMatrix matrixAT = new DenseMatrix(NBolts, nrow);
            DenseVector vectorB = new DenseVector(nrow);
            DenseVector vectorATB = new DenseVector(NBolts);

            int rowindex = 0;

            foreach (EquationCell ec in equationList)
            {

                double[] datas = ec.GetPower(NBolts);

                matrixA.SetRow(rowindex, datas);

                matrixAT.SetColumn(rowindex, datas);
                vectorB[rowindex] = ec.thk;
                rowindex++;
            }

            DenseMatrix ATA = (DenseMatrix)matrixA.TransposeThisAndMultiply(matrixA);
            DenseVector ATB = (DenseVector)matrixA.TransposeThisAndMultiply(vectorB);

            DenseVector X = (DenseVector)ATA.Solve(ATB);


            for (int i = 0; i < NBolts; i++)
            {
                frame_out[i] = X[i];
            }
        }
        #endregion

        /// <summary>
        /// 开始扫描
        /// </summary>
        /// <returns></returns>
        public override void Start()
        {
            base.Start();

            if (IsRunning == false)
            {
                warningSystem.Add(
                    ERRNOs.Instance.SCAN_ERRNO_FATAL.Code,
                    ERRNOs.Instance.SCAN_ERRNO_FATAL.Descrption + " :AD卡连接断开");
                return;
            }

            //设置扫描范围
            int beginPos, endPos;

            mBorderSearch.Reset();
            mBorderSearch.GetScanRange(out beginPos, out endPos);



            ScanNo++;
            //scanposdetect
            mScanPosDetect.ScanNo = ScanNo;

            //scaninfo
            ScanInfoCell scaninfo = new ScanInfoCell(ScanNo, NBolts);
            mScanInfoList.Add(scaninfo);



            //清空临时数据
            bulkDb.SetTempFrame(DateTime.MinValue, DateTime.MinValue, 0, null);

            #region sqlite3 历史数据保存
            CheckProfile();
            mProfileParam.PropertyChanged += MProfileParam_PropertyChanged;
            #endregion


            base.Start2(beginPos, endPos);
        }
        #region sqlite3 历史数据保存
        string[] profile_propertynames_add = new string[]{
                "PName",
                "OrderNo",
                "Number"
            };
        string[] profile_propertynames_update = new string[]{
                "Target",
                "TolerancePercent"
            };
        /// <summary>
        /// 检查产品信息更新情况，是否需要新加单，或者更新单信息
        /// </summary>
        void CheckProfile()
        {
            if (mHistoryDb.localDb.IsProfileFinished)
            {
                //上一单结束了，添加新单
                AddProfile();
            }
            else
            {
                if (mHistoryDb.localDb.CurrProfile != null)
                {
                    Db_Profile db_Profile = mHistoryDb.localDb.CurrProfile;

                    if ((db_Profile.PName != mProfileParam.PName) ||
                    (db_Profile.OrderNo != mProfileParam.OrderNo) ||
                    (db_Profile.Number != mProfileParam.Number))
                    {
                        //产品名称/订单号/卷号改变了，需要新加单
                        AddProfile();
                    }
                    else
                    {
                        //继续上一次生产！！！！更新订单信息
                        UpdateProfile();
                    }
                }
                else
                {
                    //异常，居然没有订单信息
                    AddProfile();
                }

            }
        }
        void AddProfile()
        {
            mHistoryDb.AddProfile(new Db_Profile()
            {
                PName = mProfileParam.PName,
                OrderNo = mProfileParam.OrderNo,
                Number = mProfileParam.Number,
                Target = mProfileParam.Target,
                TolerancePercent = mProfileParam.TolerancePercent,
                StartTime = DateTime.Now,
                EndTime = DateTime.Now
            });
        }
        void UpdateProfile()
        {
            mHistoryDb.UpdateProfile(new Db_Profile()
            {
                PName = mProfileParam.PName,
                OrderNo = mProfileParam.OrderNo,
                Number = mProfileParam.Number,
                Target = mProfileParam.Target,
                TolerancePercent = mProfileParam.TolerancePercent,
            });
        }
        private void MProfileParam_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            if (profile_propertynames_add.Contains(e.PropertyName))
            {
                FObjBase.PollModule.Current.Poll_JustOnce(
                    () =>
                    {
                        if (!mHistoryDb.localDb.IsProfileFinished)
                        {
                            mHistoryDb.FinishProfile();
                        }
                        AddProfile();//新
                    }, this, MARKNO_PROFILE_ADD);
            }
            else if (profile_propertynames_update.Contains(e.PropertyName))
            {
                FObjBase.PollModule.Current.Poll_JustOnce(
                    () =>
                    {
                        UpdateProfile();//修改
                    }, this, MARKNO_PROFILE_CHANGED);
            }
        }
        #endregion

        /// <summary>
        /// 停止扫描
        /// </summary>
        public override void Stop()
        {
            #region sqlite3 历史数据保存
            mProfileParam.PropertyChanged -= MProfileParam_PropertyChanged;
            #endregion

            base.Stop();
            //已经停止
            //删除全部
            mScanInfoList.Clear();
        }

        /// <summary>
        /// 周期动作处理
        /// </summary>
        protected override void OnPoll()
        {
            base.OnPoll();
            OnPoll_GetAngle();
        }

        /// <summary>
        /// 获取 缓冲区列表
        /// </summary>
        /// <param name="asyncDelegate"></param>
        /// <param name="asyncContext"></param>
        public void GetBufList(int no, AsyncCBHandler asyncDelegate, object asyncContext)
        {
            GetBufListReponse p = new GetBufListReponse();
            p.no = no;
            int index = mBufList.No2Index(no);
            if (index >= 0 && index < mBufList.Count())
            {
                p.data = mBufList[index];
            }
            else
            {
                //已经被删除，不存在了
            }
            asyncDelegate(asyncContext, p);
        }

        string file_path = "renzijiascan.json";

        bool Load()
        {
            if (BlowingScanJsonDb.Load(this, file_path))
            {
                return true;
            }
            else//只是为了版本兼容，以后就会删除
            {
                var jsonDb = FLY.Thick.BlowingScan.Server.Update.GM_BlowingScan.ToJsonDb();
                if (jsonDb == null)
                    return false;
                string json = Newtonsoft.Json.JsonConvert.SerializeObject(jsonDb);
                File.WriteAllText(file_path, json);

                return BlowingScanJsonDb.Load(this, file_path);
            }

        }
        bool Save()
        {
            return BlowingScanJsonDb.Save(this, file_path);
        }



    }
    /// <summary>
    /// 扫描位置检测
    /// 里面的列表会缓存一些旧数据，如1次扫描前的位置信息。
    /// 什么时候删除，由ScanPosDetect 自行决定，使用者不用关心
    /// </summary>
    public class ScanPosDetect
    {
        /// <summary>
        /// IOStatus 推送出来扫描位置与时间
        /// </summary>
        class PosCell
        {
            public DateTime sysTime;
            public int position;
            public override string ToString()
            {
                return $"{sysTime} pos={position}";
            }
        }
        class PosCellList
        {
            /// <summary>
            /// 这次扫描 的开始电脑时间
            /// </summary>
            public DateTime beginTime;
            /// <summary>
            /// 这次扫描 的开始AD盒时间
            /// </summary>
            public DateTime beginSysTime;
            /// <summary>
            /// 扫描号
            /// </summary>
            public int ScanNo { get; private set; }
            public PosCellList(int scanNo, DateTime beginTime, DateTime beginSysTime)
            {
                this.ScanNo = scanNo;
                this.beginSysTime = beginSysTime;
                this.beginTime = beginTime;
            }
            private List<PosCell> mPosList = new List<PosCell>();

            /// <summary>
            /// 
            /// </summary>
            /// <param name="position">脉冲</param>
            /// <param name="systime">AD盒的时间，用于时间偏移量</param>
            /// <param name="dt">电脑的时间</param>
            public void Add(int position, DateTime systime)
            {
                if (mPosList.Count() == 0)
                {
                    mPosList.Add(new PosCell() { position = position, sysTime = systime });
                    return;
                }

                if (mPosList.Count() > 0)
                {
                    if (mPosList.Last().position == position)
                    {
                        mPosList.Last().sysTime = systime;
                        return;
                    }
                    else
                    {
                        mPosList.Add(new PosCell() { position = position, sysTime = systime });
                    }
                }

            }
            private DateTime GetTime(int position, int idx)
            {
                var timeOffset = beginTime - beginSysTime;


                double d_pos = mPosList[idx].position - mPosList[idx + 1].position;

                TimeSpan ts = mPosList[idx].sysTime - mPosList[idx + 1].sysTime;
                long ticks = (long)((position - mPosList[idx + 1].position) / d_pos * ts.Ticks);
                return mPosList[idx + 1].sysTime + new TimeSpan(ticks) + timeOffset;
            }
            /// <summary>
            /// 获取位置对应的数据点.
            /// 返回
            /// -1:position在列表的前面;
            /// 0:position在列表的里面
            /// 1:position在列表的后面
            /// </summary>
            /// <param name="position"></param>
            /// <param name="dt"></param>
            /// <returns></returns>
            public int GetTime(int position, out DateTime dt)
            {
                dt = DateTime.MinValue;
                //TODO
                if (mPosList.Count < 2)
                    return -1;
                //通过列表最前面的数据，与最后面的数据，确认方向
                DIRECTION direction;
                if (mPosList.First().position < mPosList.Last().position)
                    direction = DIRECTION.FORWARD;
                else
                    direction = DIRECTION.BACKWARD;
                int idx;
                if (direction == DIRECTION.FORWARD)
                {
                    idx = mPosList.FindIndex(p => position <= p.position);
                }
                else
                {
                    idx = mPosList.FindIndex(p => position >= p.position);
                }

                if (idx == -1)
                {
                    //在列表后面
                    dt = GetTime(position, mPosList.Count - 2);
                    return 1;
                }
                else if (idx == 0)
                {
                    //在列表前面
                    dt = GetTime(position, 0);
                    return -1;
                }
                else
                {
                    //在列表里面
                    dt = GetTime(position, idx - 1);
                    return 0;
                }
            }
        }
        //TODO
        private List<PosCellList> mPosLists = new List<PosCellList>();
        private int lastGetTimeScanNo = -1;
        private int scanNo;//当前扫描号。每扫描一次，scanNo++
        public int ScanNo
        {
            get
            {
                return scanNo;
            }
            set
            {
                if (scanNo != value)
                {

                    //Clear(ScanNo, -2);

                    scanNo = value;
                }
            }
        }

        /// <summary>
        /// 删除scanNo 偏移 offset 之前的数据
        /// </summary>
        /// <param name="scanNo"></param>
        /// <param name="offset"></param>
        public void Clear(int scanNo, int offset)
        {
            if (mPosLists.Count == 0)//没数据
                return;

            int index = mPosLists.FindIndex(pl => pl.ScanNo == scanNo);
            if (index == -1)
                return;//可能还没出现
            index += offset;
            if (index < 0)
                return;//没有之前的数据
            mPosLists.RemoveRange(0, index + 1);
        }
        public void Clear()
        {
            mPosLists.Clear();
        }
        public ScanPosDetect()
        {
        }

        public void Init(IFlyAD flyad)
        {
            flyad.IStatusChangedEvent += new IStatusChangedEventHandler(flyad_IStatusChangedEvent);
        }

        void flyad_IStatusChangedEvent(object sender, IStatusChangedEventArgs e)
        {
            PosCellList poslist;
            if (mPosLists.Count == 0)
                mPosLists.Add(new PosCellList(ScanNo, DateTime.Now, e.Time));
            else
            {
                poslist = mPosLists.Last();
                if (poslist.ScanNo != ScanNo)
                {
                    mPosLists.Add(new PosCellList(ScanNo, DateTime.Now, e.Time));
                }
            }
            poslist = mPosLists.Last();

            poslist.Add(e.Position, e.Time);
        }


        /// <summary>
        /// 获取pos 对应的时间;
        /// 返回 -1 数据在 列表前;
        /// 返回 0 数据在列表内;
        /// 返回 1 数据在列表外;
        /// </summary>
        /// <param name="position">位置</param>
        /// <param name="scanNo">扫描号</param>
        /// <returns></returns>
        public int GetTime(int position, int scanNo, out DateTime dt)
        {
            if (lastGetTimeScanNo != scanNo)
            {
                //TODO
                Clear(lastGetTimeScanNo, -8);
                lastGetTimeScanNo = scanNo;
            }
            dt = DateTime.MinValue;
            if (mPosLists.Count == 0)//没数据
                return 1;

            int d = scanNo - mPosLists[0].ScanNo;
            if (d < 0)
            {
                //发生在过去
                //不正常
                return -2;
            }

            int index = mPosLists.FindIndex(pl => pl.ScanNo == scanNo);
            if (index == -1)
                return 1;//可能还没出现


            PosCellList poslist = mPosLists[index];

            int ret = poslist.GetTime(position, out dt);
            if ((ret == 1) && (index != (mPosLists.Count - 1)))
                return 0;
            else if ((ret == -1) && (index != 0))
                return 0;
            else
                return ret;
        }
    }

    public class BlowingScanJsonDb
    {
        static Mapper Mapper { get; } = new AutoMapper.Mapper(new MapperConfiguration(c => {
            c.CreateMap<GM_BlowingScan, BlowingScanJsonDb>().ReverseMap();
        }));
        public static bool Load(GM_BlowingScan src, string file_path)
        {
            if (File.Exists(file_path))
            {
                try
                {
                    string json = File.ReadAllText(file_path);
                    var jsonDb = JsonConvert.DeserializeObject<BlowingScanJsonDb>(json);
                    Mapper.Map(jsonDb, src);
                    return true;
                }
                catch
                {
                    //异常，没有json 解码失败

                }
            }

            return false;
        }
        public static bool Save(GM_BlowingScan src, string file_path)
        {
            try
            {
                var jsonDb = Mapper.Map<BlowingScanJsonDb>(src);
                string json = JsonConvert.SerializeObject(jsonDb, Formatting.Indented);
                File.WriteAllText(file_path, json);
                return true;
            }
            catch
            {
                //异常，没有json 编码失败

            }
            return false;
        }

        /// <summary>
        /// 加热通道数
        /// </summary>
        public int ChannelCnt { get; set; } = 88;

        /// <summary>
        /// 分区数/加热通道数
        /// </summary>
        public int BPC { get; set; } = 1;

        /// <summary>
        /// 复位时，探头测量的位置对应分区号
        /// </summary>
        public int OrgBoltNo { get; set; } = 1;

        /// <summary>
        /// 使用分区表
        /// </summary>
        public bool IsUsedMap { get; set; } = false;


        /// <summary>
        /// 探头宽度，用于解方程，可以与实际不符合 单位脉冲
        /// </summary>
        public int SensorWidth { get; set; } = 300;


        /// <summary>
        /// 多少次扫描解一次方程
        /// </summary>
        public int SolveCnt { get; set; } = 4;

        /// <summary>
        /// 平滑
        /// </summary>
        public int Smooth { get; set; } = 1;

        /// <summary>
        /// 分区表,必须保证不能为null
        /// </summary>
        public BoltMapCell[] Map { get; set; }


        /// <summary>
        /// 测厚仪测量点位置方向：Left， Right （也就是三角形在左还是右）
        /// </summary>
        public bool IsProbeRight { get; set; } = true;

        public bool IsForwCW { get; set; }
    }
}

namespace FLY.Thick.BlowingScan.Server.Update
{
    public class GM_BlowingScan : ISaveToXml
    {
        public static Mapper Mapper { get; } = new AutoMapper.Mapper(new MapperConfiguration(c => {
            c.CreateMap<GM_BlowingScan, BlowingScanJsonDb>()
            .ForMember(bs => bs.Map, opt =>
            {
                opt.MapFrom(s => s.Map.ToArray());
            });
        }));

        /// <summary>
        /// 加热通道数
        /// </summary>
        public int ChannelCnt { get; set; } = 88;

        /// <summary>
        /// 分区数/加热通道数
        /// </summary>
        public int BPC { get; set; } = 1;

        /// <summary>
        /// 复位时，探头测量的位置对应分区号
        /// </summary>
        public int OrgBoltNo { get; set; } = 1;

        /// <summary>
        /// 使用分区表
        /// </summary>
        public bool IsUsedMap { get; set; } = false;


        /// <summary>
        /// 探头宽度，用于解方程，可以与实际不符合 单位脉冲
        /// </summary>
        public int SensorWidth { get; set; } = 300;


        /// <summary>
        /// 多少次扫描解一次方程
        /// </summary>
        public int SolveCnt { get; set; } = 4;
        /// <summary>
        /// 分区表,必须保证不能为null
        /// </summary>
        public List<BoltMapCell> Map { get; } = new List<BoltMapCell>();

        static GM_BlowingScan()
        {
            Misc.SaveToXmlHepler.Regist(typeof(BoltMapCell));
        }

        #region ISaveToXml
        public string[] GetSavePropertyNames()
        {
            return new string[]{
                nameof(ChannelCnt),
                nameof(BPC),
                nameof(OrgBoltNo),
                nameof(SolveCnt),
                nameof(SensorWidth),
                nameof(IsUsedMap),
                nameof(Map)
            };
        }

        #endregion

        public static BlowingScanJsonDb ToJsonDb()
        {
            if (File.Exists("renzijiascan.xml"))
            {//只是为了版本兼容，以后就会删除

                var blowingScan = new GM_BlowingScan();

                Misc.SaveToXmlHepler.Load("renzijiascan.xml", blowingScan);

                return Mapper.Map<BlowingScanJsonDb>(blowingScan);
            }
            else
                return null;
        }
    }
}