using irisHelper;
using irisRefactor.FrmService;
using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Threading;

namespace irisRefactor.IrisThread
{
    /**
     * 识别之前的线程
     * 找眼和质量评估两步操作串行进行
     * 
     */    
    class PreIdentifyTh
    {
        private PreIdentifyTh()
        {

        }

        private static readonly PreIdentifyTh _preIdentifyTh = new PreIdentifyTh();
        
        public static PreIdentifyTh GetInstance { get => _preIdentifyTh; }

        public void FindEyes()
        {
            LogHelper.WriteLog(MethodBase.GetCurrentMethod().DeclaringType, "PreIdentify -- FindEyes");

            ProMemory.Tag_SleepTimer = 0;

            // 用于计算操作耗时
            Stopwatch sw = new Stopwatch();

            try
            {
                // 条件：找眼线程在运行中；休眠线程标志为0；不在数据同步；连续未找到眼睛数小于100
                while (ProMemory.irisConfig.EyeFinderThreadRun && ProMemory.Tag_SleepTimer == 0 && !ProMemory.isSyning && ProMemory.identifyConfig.Count_NoEyeLast <= 100)
                {
                    //M++;
                    if (ProMemory.irisConfig.Q1.Count > 0)
                    {
                        lock (ProMemory.irisConfig.Q1)
                        {
                            if (ProMemory.irisConfig.Q1.Count > 0)
                            {
                                ProMemory.irisConfig.FaceBuffer = ProMemory.irisConfig.Q1.Pop();
                            }
                        }

                        if (ProMemory.irisConfig.FaceBuffer != null)
                        {
                            unsafe
                            {
                                // 申请内存，复制内存
                                IntPtr ptrFace = Marshal.AllocHGlobal(1280 * 960);
                                Marshal.Copy(ProMemory.irisConfig.FaceBuffer, 0, ptrFace, 1280 * 960);

                                // mark = 找到的眼睛数量
                                int mark;
                                // 左右眼睛的定位参数：x，y，r
                                int[] posvec = new int[] { 0, 0, 0, 0, 0, 0 };

                                fixed (int* pos = &posvec[0])
                                {
                                    int* ptrPos = pos;

                                    sw.Restart();
                                    mark = ProMemory.CaptureEye_Rec(ptrFace, ref ptrPos); // 调用找眼算法
                                    sw.Stop();
                                    LogHelper.WriteLog(MethodBase.GetCurrentMethod().DeclaringType, "执行一次找眼操作[" + mark + "]：" + sw.ElapsedMilliseconds);

                                    int[] irisPos = { ptrPos[0], ptrPos[1], ptrPos[2], ptrPos[3], ptrPos[4], ptrPos[5] };

                                    // 找到1个或者2个眼睛
                                    if (mark == 1 || mark == 2)
                                    {
                                        // 1.持续没有找到眼的计数器清零
                                        ProMemory.identifyConfig.Count_NoEyeLast = 0;

                                        // 2.黄灯闪烁
                                        //ProMemory.IoControllService.setYellowFlash(true);
                                        //Thread flashThrd = new Thread(ProMemory.IoControllService.YellowFlash);
                                        //flashThrd.Start();

                                        // 3.质量评估
                                        int score = 0;
                                        Byte[] irisBytesL = new byte[640 * 480];
                                        Byte[] irisBytesR = new byte[640 * 480];

                                        IntPtr ptrIrisFace = Marshal.AllocHGlobal(1280 * 960);
                                        Marshal.Copy(ProMemory.irisConfig.FaceBuffer, 0, ptrIrisFace, 1280 * 960);

                                        unsafe
                                        {
                                            fixed (byte* irisL = &irisBytesL[0])
                                            {
                                                fixed (byte* irisR = &irisBytesR[0])
                                                {
                                                    byte* ptrIrisL = irisL;
                                                    byte* ptrIrisR = irisR;

                                                    sw.Restart();
                                                    score = ProMemory.AssessFocus_Rec(ptrIrisFace, irisPos, ref ptrIrisL, ref ptrIrisR);  //质量评估 0均不合格 1一幅合格 2均合格
                                                    sw.Stop();
                                                    LogHelper.WriteLog(MethodBase.GetCurrentMethod().DeclaringType, "执行一次质量评估操作[" + score + "]：" + sw.ElapsedMilliseconds);
                                                }
                                            }
                                        }


                                        if (score > 0)
                                        {
                                            if (score == 1)
                                            {
                                                lock (ProMemory.irisConfig.Q4)
                                                {
                                                    ProMemory.irisConfig.Q4.Push(irisBytesL);
                                                }
                                            }
                                            else if (score == 2)
                                            {
                                                lock (ProMemory.irisConfig.Q4)
                                                {
                                                    ProMemory.irisConfig.Q4.Push(irisBytesL);
                                                    ProMemory.irisConfig.Q4.Push(irisBytesR);
                                                }
                                            }

                                            
                                            if (ProMemory.irisConfig.Key_Identify == 0)
                                            {
                                                ProMemory.irisConfig.Key_Identify = 1;

                                                ProMemory.irisConfig.IdentifyThreadRun = true;
                                                Thread m_IdentifyThread = new Thread(IdentiyfTh.GetInstance().Identify);
                                                m_IdentifyThread.Name = "Identify";
                                                m_IdentifyThread.Start();
                                            }
                                            
                                        }

                                        Marshal.FreeHGlobal(ptrIrisFace);
                                    }
                                    else
                                    {
                                        ProMemory.identifyConfig.Count_NoEyeLast++;
                                    }
                                }

                                Marshal.FreeHGlobal(ptrFace);
                            }
                        }

                        lock (ProMemory.irisConfig.Q2)
                        {
                            if (ProMemory.irisConfig.Q2.Count >= 30)
                            {
                                ProMemory.irisConfig.Q2.Clear(); //手动控制堆栈容量
                            }
                        }

                        lock (ProMemory.irisConfig.Q3)
                        {
                            if (ProMemory.irisConfig.Q3.Count >= 30)
                            {
                                ProMemory.irisConfig.Q3.Clear(); //手动控制堆栈容量                   
                            }
                        }
                    }
                }

                //if (ProMemory.Tag_SleepTimer == 1) //待机时间到,仍未找到眼睛
                if (ProMemory.identifyConfig.Count_NoEyeLast > 100)
                {
                    if (ProMemory.m_bGrabbing)
                    {
                        if (ProMemory.IoControllService.getSensorVal() == 0) //未再次触发,待机
                        {
                            if (ProMemory.formType == "1")
                                Form1.GetInstance().ReInitializeToSleep();
                            else if (ProMemory.formType == "2")
                                Form2.GetInstance().ReInitializeToSleep();
                            Thread.Sleep(200);
                            ProMemory.cameraController.ContinuousShot_TriggerOn();
                        }
                        else //已再次触发,继续下一轮识别
                        {
                            ProMemory.cameraController.ContinuousShot_TriggerOff();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLog(MethodBase.GetCurrentMethod().DeclaringType, "眼睛搜索线程CatchError:" + ex);
            }
        }
    }
}