using OTSModelSharp;
using OTSDataType;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using static OTSDataType.otsdataconst;
using static OTSModelSharp.STMSampleResultData;

namespace OTSMeasureApp
{
    class OTSMeasureDisplayResult
    {
        NLog.Logger log ;
        public enum ProgressState
        {
           
            MeasureCheckReport = 1,
            MeasureResult = 2
        }

        #region 变量生成汇总
        OTSIncAMeasureAppForm m_MeasureApp = null;
      
       
        
        //样品台窗口对象
        public OTSSamplespaceWindow m_OTSSamplespaceWindow = null;
       
        //测量进度信息窗口对象
        public MeasureCheckResultInfoWindow m_MeasureCheckReportInfoWindow = null;
        //测量结果信息窗口对象
        public OTSMeasureResultWindow m_OTSMeasureResultWindow = null;
        //在窗体TAB测量状态中显示BSE图
        public OTSMeasureStatusWindow m_OTSMeasureStatusWindow = null;
        public System.ComponentModel.BackgroundWorker m_bgWorker;
      
   
        ST_MSTMsg MeasureResultMsrData;
        //已完成帧图的绘制 根据位置-判断相差范围  四舍五入返回的数值有偏差
       
        #endregion

        #region 构造方法
        public OTSMeasureDisplayResult( OTSIncAMeasureAppForm m_MeasureApps, BackgroundWorker a_bgWorker)
        {
            log = NLog.LogManager.GetCurrentClassLogger();
          
                m_MeasureApp = m_MeasureApps;
               
                m_OTSSamplespaceWindow = m_MeasureApps.m_SamplepaceWindow;
                m_OTSMeasureResultWindow = m_MeasureApp.m_MeasureRetWindow;
                m_OTSMeasureStatusWindow = new OTSMeasureStatusWindow(m_MeasureApp);
               
                Control.CheckForIllegalCrossThreadCalls = false;

                //测量结束信息窗口对象
                m_MeasureCheckReportInfoWindow = new MeasureCheckResultInfoWindow();
                m_bgWorker = a_bgWorker;
                //设置报告更新是否可用
                m_bgWorker.WorkerReportsProgress = true;
                //设置支持取消操作是否可用
                m_bgWorker.WorkerSupportsCancellation = true;
             
                m_bgWorker.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);
                m_bgWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker_RunWorkerCompleted);
              
          
        }
        #endregion

        #region 修改窗体控件的响应事件_ProgressChanged
        //这里就是通过响应消息，来处理界面的显示工作
        private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            try
            {
              
                if (e.ProgressPercentage == (int)ProgressState.MeasureCheckReport)
                {
                    
                        MeasureResultInfo(MeasureResultMsrData);
                   
                }
                //测量结果
                if (e.ProgressPercentage == (int)ProgressState.MeasureResult)
                {
                   
                        if (m_OTSMeasureResultWindow == null)
                        {
                            //实例窗体
                            m_OTSMeasureResultWindow = m_MeasureApp.m_MeasureRetWindow;
                        }
                        //设置工作样品
                        m_MeasureApp.m_ProjParam.SetWorkSample(m_OTSSamplespaceWindow.GetWorkingVisualSample().GetSampleName());
                        //获取工作样品信息
                        COTSSample WSample = m_MeasureApp.m_ProjParam.GetWorkSample();
                        CMsrDisplayResults cMsrResultsClr = WSample.GetMsrResults();
                        //获取结果文件 颗粒列表信息
                        List<CMsrResultItem> cMsrResultItemClrList = cMsrResultsClr.GetResultItems();
                        //根据编号获取分类名称
                        List<CMsrResultItem> cMsrResultItemClrListTemp = cMsrResultItemClrList;
                        //设置测量状态数据列表
                        SetMeasureListInfo(cMsrResultItemClrList);
                   
                }

            }
            catch (Exception ex)
            {
                log.Error( ex.ToString());
            }
        }
        #endregion

        #region 处理完成的响应事件_RunWorkerCompleted
        //这里是后台工作完成后的消息处理，可以在这里进行后续的处理工作。
        private void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            //m_bgWorker.CancelAsync();

            //m_bgWorker = null;
        }
        #endregion



   

        #region 打开测量结果窗口
        /// <summary>
        /// 打开测量结果窗口
        /// </summary>
        public void MeasureResultInfo(ST_MSTMsg sMSR)
        {
            //打开测量结果窗体
            if (m_MeasureCheckReportInfoWindow.IsDisposed)
            {
                m_MeasureCheckReportInfoWindow = new MeasureCheckResultInfoWindow();
            }
            m_MeasureCheckReportInfoWindow.Activate();
            m_MeasureCheckReportInfoWindow.Show();
            SetMeasureResultInfo(sMSR);
        }
        #endregion

        #region 显示BSE图片
        public void OTSMeasureStatusWindowFun(int width, int height, byte[] ImageData, OTSIncAMeasureAppForm m_MeasureApps)
        {
            //设置图像数据与状态
            OTSMeasureStatusWindow.bfResult = true;
            m_MeasureApps.m_MessureStatuWindow.bBseData = ImageData;
            //获取灰度图数据
            double[] dGrayLevelData = new double[255];
            dGrayLevelData = GetStaticGaryData(ImageData, dGrayLevelData);
            m_MeasureApps.m_MessureStatuWindow.dGrayLevelData = dGrayLevelData;
            if (m_MeasureApps.m_MessureStatuWindow.panelXray.Visible)
            {
                m_MeasureApps.m_MessureStatuWindow.panelXray.Visible = false;
            }
            //删除点标记
            m_MeasureApps.m_MessureStatuWindow.DelElementPointGDIObjects();
            //显示BSE图
            m_MeasureApps.m_MessureStatuWindow.pbBSEImage.Show();
  
            //显示BSE图
            m_MeasureApps.m_MessureStatuWindow.ShowImage(width, height, ImageData);
        }
        public double[] GetStaticGaryData(byte[] Imagedata, double[] GrayLevelData)
        {
            try
            {
                //获得下标每一点的灰度值，并在数组里加一
                for (int i = 0; i < Imagedata.Length; i++)
                {
                    byte graylevel = Imagedata[i];
                    if (graylevel > 0 && graylevel < 255)
                    {
                        GrayLevelData[graylevel] += 1;
                    }
                }
                return GrayLevelData;
            }
            catch (Exception ex)
            {
                log.Error(ex.ToString());
                return null;
            }
        }
        #endregion

        #region 隐藏BSE图片

        #endregion

        #region 初始窗口对象

        int intFlag = 0;
        public void RunThreadLoadEvent()
        {
            if (intFlag == 0)
            {
                m_bgWorker.RunWorkerAsync();
                intFlag++;
            }
        }
        #endregion
        #region 设置测量状态列表数据
        /// <summary>
        /// 设置测量状态列表数据
        /// </summary>
        /// <param name="stratTime"></param>
        public void SetMeasureListInfo(IList list)
        {
            //设置开始时间
            if (list != null)
            {
                //获取测量状态Grid中的数据list
                m_OTSMeasureResultWindow.SetMeasureListInfo(list);
            }
        }
        #endregion
        #region 设置开始时间
        /// <summary>
        /// 设置开始时间
        /// </summary>
        /// <param name="stratTime"></param>
        public void SetStartTime(string stratTime)
        {
            //设置开始时间
            if (stratTime != null)
            {
                if (stratTime != "")
                {
                    m_OTSMeasureResultWindow.SetStartTime(stratTime);
                }
            }
        }
        #endregion


        #region 设置测量结束窗体中信息内容
        public void SetMeasureResultInfo(ST_MSTMsg SMsrData)
        {
            //设置开始时间
            string startTime = SMsrData.STMThreadStu.SMsrCompleteData.csMsrStartTime;
            //设置结束时间
            string endTime = SMsrData.STMThreadStu.SMsrCompleteData.csMsrEndTime;
            //设置测量数
            int completeSampleCount = SMsrData.STMThreadStu.SMsrCompleteData.iMsrCompleteSampleCount;
            //设置帧图数
            int completeFieldCount = SMsrData.STMThreadStu.SMsrCompleteData.iMsrCompleteFieldCount;
            //颗粒数
            int particleCount = SMsrData.STMThreadStu.SMsrCompleteData.iParticleCount;
            //用时
            TimeSpan measureTime = SMsrData.STMThreadStu.SMsrCompleteData.MsrUsedTime;
            string measureState = string.Empty;
            OTSCommon.Language lan = new OTSCommon.Language();
            Hashtable table= lan.GetNameTable("OTSMeasureResultWindow");

            //状态
        
            switch (SMsrData.STMThreadStu.iMsrStatu)
            {
                case OTS_MSR_THREAD_STATUS.COMPLETED:
                    measureState = table["state1"].ToString();
                    break;
                case OTS_MSR_THREAD_STATUS.FAILED:
                    measureState = table["state2"].ToString();
                    break;
                case OTS_MSR_THREAD_STATUS.STOPPED:
                    measureState = table["state3"].ToString();
                    break;
            }
            //设置测量结果窗体信息
            string measureTimes = string.Empty;
            m_MeasureCheckReportInfoWindow.SetMeasureStateInfo(measureState, completeSampleCount, completeFieldCount, particleCount, startTime, measureTime, endTime, ref measureTimes);
        }
        #endregion

        #region 设置测量用时
        public void SetMeasureTime(TimeSpan tSpan)
        {
            m_OTSMeasureResultWindow.SetMeasureTime(tSpan);
        }
        #endregion

        #region 设置样品名称
        /// <summary>
        /// 设置样品名称
        /// </summary>
        /// <param name="SetSampleName"></param>
        public void SetSampleName(string sampleName)
        {
            //设置开始时间
            if (sampleName != null)
            {
                if (sampleName != "")
                {
                    m_MeasureApp.m_SamplepaceWindow.SetSampleOrder(sampleName);
                    double iWDistance = 0;
                    double dMagni = 0;
                    m_MeasureApp.m_ProjParam.GetWorkingSampleSEMData(ref iWDistance, ref dMagni);
                    
                    if (m_MeasureApp.GetRunType() == MSR_RUN_TYPE.RUNMEASURE)
                    {
                        m_OTSMeasureResultWindow.SetSampleName(sampleName);
                    }
                    m_MeasureApp.m_SamplepaceWindow.Invalidate();
                }
            }
        }
        #endregion

       

        #region 测量状态进度窗口
        public void MeasureStateProgressInfo(SAMPLEFIELDDATA FieldData)
        {
            //样品测量中的总帧图数
            int MeasureFieldTotalCount = FieldData.iMeasureFieldCount;
            //样品测量中当前已测量的帧图数
            int CompleteFieldCount = FieldData.iCompleteFieldCount;
            int ParticleCount = FieldData.iSParticleCount;
            if (CompleteFieldCount >= 0 && MeasureFieldTotalCount >= 0)
            {
                m_bgWorker.ReportProgress((int)ProgressState.MeasureResult);
                //设置当前进度信息(当前Field数量与Field总数)
                m_OTSMeasureResultWindow.SetCurrentProgressInfo(CompleteFieldCount, MeasureFieldTotalCount, ParticleCount);
            }
        }
        #endregion

     

       

        #region 设置样品孔中BSE图像信息
        /// <summary>
        /// 设置样品孔中BSE图像信息
        /// </summary>
        /// <param name="ImageData">获取显示BSE的图片数据</param>
        /// <param name="width">图片宽度</param>
        /// <param name="height">图片高度</param>
        /// <param name="fieldPos">Field位置</param>
        public void SetHoleBSEImageData(byte[] ImageData, int width, int height, Point fieldPos)
        {
            m_MeasureApp.m_SamplepaceWindow.AddHoleBSEImageData(ImageData, width, height, fieldPos);
        }
        #endregion

        #region 测量方法
        //运行测量状态方法
        public void RunMeasureState(ST_MSTMsg SMsrData)
        {
            try
            {
                
                //消息枚举 测量状态、测量结果
                ENUM_MSG_TYPE dataType = SMsrData.iMsgType;
                //测量状态:开始状态、完成状态(测量停止、测量失败、测量完成)
                OTS_MSR_THREAD_STATUS msrStatus = SMsrData.STMThreadStu.iMsrStatu;
                //获取当前线程执行类型 1：测量 2：获取样品孔图片
                var runThreadType = m_MeasureApp.GetRunType();

                //获取需显示的grid信息
                OTSSamplePropertyInfo MeasureInfo = new OTSSamplePropertyInfo();
                m_MeasureApp.m_ProjParam.GetWorkSamplePerameter(m_MeasureApp.m_ProjParam.GetWorkSample(), ref MeasureInfo);

                switch (dataType)
                {
                    //测量线程状态
                    case ENUM_MSG_TYPE.MTHREADSTATUS:
                        switch (msrStatus)
                        {
                            //测量状态在进行中-测量开始
                            case OTS_MSR_THREAD_STATUS.INPROCESS:
                               
                                if (runThreadType == MSR_RUN_TYPE.RUNMEASURE)
                                {

                                    string startTime = SMsrData.STMThreadStu.csMsrStartTime;
                             
                                     
                                }
                           
                                break;
                            //测量状态已完成
                            case OTS_MSR_THREAD_STATUS.COMPLETED:
                                //当前线程执行类型 1：测量
                                if (runThreadType == MSR_RUN_TYPE.RUNMEASURE)
                                {
                                    string inprocessEndTime = SMsrData.STMThreadStu.csMsrEndTime;
                                    SetMeasureResultInfo(SMsrData);
                                    MeasureResultMsrData = SMsrData;

                                    m_bgWorker.ReportProgress((int)ProgressState.MeasureCheckReport, SMsrData);
                                    //激活跳转至报告程序按钮
                                    m_MeasureApp.rbPReport.Enabled = true;
                                    m_MeasureApp.rbReport.Enabled = true;
                                    m_MeasureApp.m_SPropertyWindows.DisplaySampleMeasureInfo(MeasureInfo);
                                }
                          

                                //测量完成，更新Grid显示的测量信息
                             
                                break;
                            //测量状态已失败
                            case OTS_MSR_THREAD_STATUS.FAILED:
                                //当前线程执行类型 1：测量
                                if (runThreadType == MSR_RUN_TYPE.RUNMEASURE)
                                {
                                    string failedEndTime = SMsrData.STMThreadStu.csMsrEndTime;
                                    SetMeasureResultInfo(SMsrData);
                                    MeasureResultMsrData = SMsrData;
                                    m_bgWorker.ReportProgress((int)ProgressState.MeasureCheckReport, SMsrData);
                                }
                          

                                //测量失败，更新Grid显示的测量信息
                                m_MeasureApp.m_SPropertyWindows.DisplaySampleMeasureInfo(MeasureInfo);
                                break;
                            //测量状态已停止
                            case OTS_MSR_THREAD_STATUS.STOPPED:
                                //当前线程执行类型 1：测量
                                if (runThreadType == MSR_RUN_TYPE.RUNMEASURE)
                                {
                                    string stopEndTime = SMsrData.STMThreadStu.csMsrEndTime;
                                    //打开测量结果窗口
                                    SetMeasureResultInfo(SMsrData);
                                    MeasureResultMsrData = SMsrData;
                                    m_bgWorker.ReportProgress((int)ProgressState.MeasureCheckReport, SMsrData);
                                    //激活跳转至报告程序按钮
                                    m_MeasureApp.rbPReport.Enabled = true;
                                    m_MeasureApp.rbReport.Enabled = true;
                                    //测量停止，更新Grid显示的测量信息
                                    m_MeasureApp.m_SPropertyWindows.DisplaySampleMeasureInfo(MeasureInfo);
                                }
                          

                             
                                break;
                        }
                        break;
                    //测量结果
                    case ENUM_MSG_TYPE.MSAMPLESTATUS:
                        //获取测量状态样品信息
                        OTS_MSR_SAMPLE_STATUS msrSampleStatu = SMsrData.STMSampleStu.iMsrSampleStatu;
                        switch (msrSampleStatu)
                        {
                            case OTS_MSR_SAMPLE_STATUS.INPROCESS:
                                //当前线程执行类型 1：测量
                                if (runThreadType == MSR_RUN_TYPE.RUNMEASURE)
                                {
                                    //获取样品名称
                                    string sampleName = SMsrData.STMSampleStu.cSampleName;
                                    //样品测量开始时间
                                    string csSampleMsrStartTime = SMsrData.STMSampleStu.csSampleMsrStartTime;
                                    //设置样品名称
                                    if (sampleName != null)
                                    {
                                        if (sampleName != "")
                                        {
                                            SetSampleName(sampleName);
                                            //设置开始时间
                                            SetStartTime(csSampleMsrStartTime);
                                          
                                        }
                                    }
                                    //切换样品
                                    m_MeasureApp.SwitchWSample(sampleName);
                                    //设置样品名称
                                    m_OTSMeasureResultWindow.SetSampleName(sampleName);

                                    
                                    
                                }
                                else if (runThreadType == MSR_RUN_TYPE.RUNSampleHoleImage)
                                {
                                    //获取样品名称
                                    string sampleName = SMsrData.STMSampleStu.cSampleName;
                                    //设置样品名称
                                    if (sampleName == null)
                                    {
                                        if (sampleName.Equals(""))
                                        {
                                            if (m_MeasureApp.m_ProjParam.GetWorkSample() != null)
                                            {
                                                sampleName = m_MeasureApp.m_ProjParam.GetWorkSample().GetName();
                                            }
                                        }
                                    }
                                    SetSampleName(sampleName);
                                }
                                break;
                        }
                        break;
                    case ENUM_MSG_TYPE.MSAMPLERESULT:
                        //获取测量状态的Field与BSE信息
                        MSAMPLE_RET retDataType = SMsrData.STMSampleRetData.iRetDataType;

                        //判断测量状态提供Field与BSE信息
                        switch (retDataType)
                        {
                            case MSAMPLE_RET.BSE_DATA:
                                //当前线程执行类型 1：测量
                                if (runThreadType == MSR_RUN_TYPE.RUNMEASURE)
                                {
                                    //获取显示BSE的图片数据
                                    byte[] ImageData = SMsrData.STMSampleRetData.BSEData.lpBSEData;
                                    //图片宽度
                                    int width = SMsrData.STMSampleRetData.BSEData.iBSEDataWidth;
                                    //图片高度
                                    int height = SMsrData.STMSampleRetData.BSEData.iBSEDataHeight;
                                    //显示状态中的BSE图像控件
                                    if (!m_MeasureApp.m_MessureStatuWindow.pbBSEImage.Visible)
                                    {
                                        m_MeasureApp.m_MessureStatuWindow.pbBSEImage.Visible = true;
                                    }
                                    //调用测量状态TAB中窗体 显示BSE图片
                                    OTSMeasureStatusWindowFun(width, height, ImageData, m_MeasureApp);
                                 
                                  

                                }
                                else if (runThreadType == MSR_RUN_TYPE.RUNSampleHoleImage)
                                {
                                    //获取显示BSE的图片数据
                                    byte[] ImageData = SMsrData.STMSampleRetData.BSEData.lpBSEData;
                                    //图片宽度
                                    int width = SMsrData.STMSampleRetData.BSEData.iBSEDataWidth;
                                    //图片高度
                                    int height = SMsrData.STMSampleRetData.BSEData.iBSEDataHeight;
                                    //Field位置
                                    Point fieldPos = SMsrData.STMSampleRetData.BSEData.pos;
                                    //设置样品孔中BSE图像信息
                                    SetHoleBSEImageData(ImageData, width, height, fieldPos);
                                }
                                break;
                            case MSAMPLE_RET.FIELD_DATA:
                                //当前线程执行类型 1：测量
                                if (runThreadType == MSR_RUN_TYPE.RUNMEASURE)
                                {
                                    //设置测量当前用时
                                    if (SMsrData.STMSampleRetData.SFieldData.TUsedTime != null)
                                    {
                                        SetMeasureTime(SMsrData.STMSampleRetData.SFieldData.TUsedTime);
                                    }

                                    MeasureStateProgressInfo(SMsrData.STMSampleRetData.SFieldData);
                                    var sam = m_MeasureApp.m_SamplepaceWindow.GetWorkingVisualSample();
                                    m_MeasureApp.m_SamplepaceWindow. ChangeDoneMeasureState(sam,SMsrData.STMSampleRetData.SFieldData.FieldPos, Color.Green);
                                    m_MeasureApp.m_SamplepaceWindow.Invalidate();

                                }
                                break;
                            case MSAMPLE_RET.START_MSR_FIELD:
                                //当前线程执行类型 1：测量
                                if (runThreadType == MSR_RUN_TYPE.RUNMEASURE)
                                {
                                    var sam = m_MeasureApp.m_SamplepaceWindow.GetWorkingVisualSample();
                                    m_MeasureApp.m_SamplepaceWindow.ChangeDoneMeasureState(sam,SMsrData.STMSampleRetData.SMsrField.FieldPos, Color.Yellow);
                                   
                                    m_MeasureApp.m_SamplepaceWindow.Invalidate();
                                }
                                break;
                        }
                        break;
                }
            }
            catch (Exception ex)
            {
               log.Error("RunMeasureState--The error message:" + ex.ToString()); 
            }
        }


        #endregion


    }
}