using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Tps_LQ_Transmitter.com;

namespace Tps_LQ_Transmitter.models
{
    class PowerTest_PowerMeter : BaseModel
    {
        double[,] WTempPowerVal;
        double[,] dBTempPowerVal;
        string serial = "****";
        public PowerTest_PowerMeter()
        {
            TemplateName = "功率(功率计)测试";
        }
        /// <summary>
        /// 使用功率计（E4418A）进行功率测试
        /// </summary>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public override bool Run(TestNode parameters)
        {
            //获取仪器
            DataType PowerPrint = new DataType();//功率(w)
            ShowMessage(MsgType.Info, string.Format("第{0}个频点功率(功率计)测试开始", parameters.PointIndex));

            var PowerMeter = this.tps.GetDeviceModel("GPIB0::13::INSTR");
            if (PowerMeter == null)
            {
                ShowMessage(MsgType.Error, string.Format("仪器不齐全，{0}/{1}无法运行", parameters.Channel, parameters.Name));
                return false;
            }
            OpenExcel("功率(功率计)", out Spire.Xls.Workbook workbook, out Spire.Xls.Worksheet sheet);
            if (sheet == null)
            {
                ShowMessage(MsgType.Error, "找不到" + tps.TestProject + "模板.xlsx");
                return false;
            }
            
         //   TransmitterSerialPort SerialClient = new TransmitterSerialPort();
            ConfigParameter PowerPara = new ConfigParameter();
            DataType PowerSumPrint = new DataType();//两路功率总和(w)
            DataType PowerFlatnessPrint = new DataType();//两路功率不平度（dB）

            //   MatchComPara CfigComParas = new MatchComPara();
            //CfigComParas = LoadComWorkBook();

            //if (CfigComParas == null)
            //{
            //    return false;
            //}

            //   byte FourthByte=0x00;
            //   string ComPort = CfigComParas.GetComPort("1");
            //   byte ThridByte = Convert.ToByte(CfigComParas.GetThirdByte("1"),16);
            //   PowerPara.StepFrequency = 0;
            //   PowerPara.StartFrequency = parameters.Parameters.GetParameter<double>("起始频率");
            //   PowerPara.StepFrequency = parameters.Parameters.GetParameter<double>("频率步进");
            ////   PowerPara.FrequencyNumber = parameters.Parameters.GetParameter<int>("频点数量");
            //   PowerPara.StopFrequency = parameters.Parameters.GetParameter<double>("终止频率");

            //   PowerPara.ControlDelay = parameters.Parameters.GetParameter<int>("控制延时");
            PowerPara.PowerLower = parameters.Parameters.GetParameter<double>("功率下限");
            PowerPara.PowerUpper = parameters.Parameters.GetParameter<double>("功率上限");
            PowerPara.PowerSumLower = parameters.Parameters.GetParameter<double>("两路功率总和下限");
            PowerPara.PowerSumUpper = parameters.Parameters.GetParameter<double>("两路功率总和上限");
            PowerPara.PowerFlatnessUpper = parameters.Parameters.GetParameter<double>("功率不平度上限");
            if ( (PowerPara.PowerLower == 0) || (PowerPara.PowerUpper == 0) ||  (PowerPara.PowerSumLower == 0) || (PowerPara.PowerSumUpper == 0) || (PowerPara.PowerFlatnessUpper == 0))
            {
                ShowMessage(MsgType.Error, string.Format("配置文件中频率参数为空，{0}/{1}无法运行", parameters.Channel, parameters.Name));
                return false;
            }

            if (tps.Serial != serial)
            {
                WTempPowerVal = new double[2, parameters.PointTotal];
                dBTempPowerVal = new double[2, parameters.PointTotal];
                serial = tps.Serial;
                for (int initVal1 = 0; initVal1 < 2; initVal1++)
                {
                    for (int initVal2 = 0; initVal2 < parameters.PointTotal; initVal2++)
                    {
                        WTempPowerVal[initVal1, initVal2] = -100;
                        dBTempPowerVal[initVal1, initVal2] = -100;
                    }
                }
            }
            //if (PowerPara.ControlDelay == 0)
            //{
            //    PowerPara.ControlDelay = 10;
            //}
            PowerMeter.Write("设置显示单位W", "1");
            //if ((PowerPara.FrequencyNumber != 0) && (PowerPara.FrequencyNumber != 1) && (PowerPara.StepFrequency == 0))
            //{
            //    PowerPara.StepFrequency = ((int)(((PowerPara.StopFrequency - PowerPara.StartFrequency) / (PowerPara.FrequencyNumber - 1)) * 100)) / 100;
            //}
            //if (PowerPara.StepFrequency != 0)
            //{
            //    PowerPara.FrequencyNumber = ((int)((PowerPara.StopFrequency - PowerPara.StartFrequency) / PowerPara.StepFrequency)) + 1;
            //}
            //double CenterFreq;
           // PowerPara.FrequencyNumber = CfigComParas.ComParameters.Count;

            //for ( int point = 0;  point< PowerPara.FrequencyNumber; point++)
            {
                //FourthByte = Convert.ToByte(CfigComParas.GetFourthByte((point+1).ToString()), 16);
                //CenterFreq = PowerPara.StartFrequency + PowerPara.StepFrequency * FourthByte;
                //if (CenterFreq > PowerPara.StopFrequency)
                //{
                //    break;
                //}
                
                //SerialClient.DUT_Transmitter_Ctrol(ThridByte, FourthByte);
                //Thread.Sleep(PowerPara.ControlDelay);//单位ms
                string aa = PowerMeter.Query("Fetch测量功率", "1");
                PowerPrint.Test_name = parameters.Channel + "-功率测试(功率计)(W)-" + parameters.CenterFreq.ToString() + "MHz";
                PowerPrint.Lower = PowerPara.PowerLower;
                PowerPrint.Upper = PowerPara.PowerUpper;
                PowerPrint.TestVal = Math.Round(double.Parse(aa), 2);//功率W
                if ((PowerPrint.TestVal >= PowerPrint.Lower ) && (PowerPrint.TestVal <= PowerPrint.Upper))
                {
                    PowerPrint.Result = "是";
                }
                else
                {
                    PowerPrint.Result = "否";
                }
                tps.TestTableAddCell(PowerPrint.Test_name, PowerPrint.Lower.ToString(), PowerPrint.Upper.ToString(), PowerPrint.TestVal.ToString(), PowerPrint.Result);
                if (parameters.Channel == "通道1")
                {

                    WriteExcelData(sheet, parameters.PointIndex, 1, PowerPrint.Test_name, PowerPrint.Lower.ToString(), PowerPrint.Upper.ToString(), PowerPrint.TestVal.ToString(), PowerPrint.Result);            
                }
                else if (parameters.Channel == "通道2")
                {

                    WriteExcelData(sheet, parameters.PointIndex, 2, PowerPrint.Test_name, PowerPrint.Lower.ToString(), PowerPrint.Upper.ToString(), PowerPrint.TestVal.ToString(), PowerPrint.Result);                 
                }
                #region 功率不平度及两路功率总和计算
                if (parameters.Channel == "通道1")
                {
                    WTempPowerVal[0, parameters.PointIndex] = PowerPrint.TestVal;//W
                    dBTempPowerVal[0, parameters.PointIndex] = 10* Math.Log10(PowerPrint.TestVal*1000);//dB
                }
                else
                {
                    WTempPowerVal[1, parameters.PointIndex] = PowerPrint.TestVal;//W
                    dBTempPowerVal[1, parameters.PointIndex] = 10 * Math.Log10(PowerPrint.TestVal * 1000);//dB
                }

                if (WTempPowerVal[0, parameters.PointIndex] > -100 && WTempPowerVal[1, parameters.PointIndex] > -100)
                {
                    PowerSumPrint.Test_name = "两路功率总和(功率计)(W)-" + parameters.CenterFreq.ToString() + "MHz";
                    PowerSumPrint.Lower = PowerPara.PowerSumLower;
                    PowerSumPrint.Upper = PowerPara.PowerSumUpper;
                    PowerSumPrint.TestVal = Math.Round(WTempPowerVal[0, parameters.PointIndex] + WTempPowerVal[1, parameters.PointIndex], 2);//W
                    if ((PowerSumPrint.TestVal >= PowerSumPrint.Lower) && (PowerSumPrint.TestVal <= PowerSumPrint.Upper))
                    {
                        PowerSumPrint.Result = "是";
                    }
                    else
                    {
                        PowerSumPrint.Result = "否";
                    }
                    PowerFlatnessPrint.Test_name = "功率不平度(功率计)(dB)-" + parameters.CenterFreq.ToString() + "MHz";
                    PowerFlatnessPrint.Upper = PowerPara.PowerFlatnessUpper;
                    PowerFlatnessPrint.TestVal = Math.Round(Math.Abs(dBTempPowerVal[0, parameters.PointIndex] - dBTempPowerVal[1, parameters.PointIndex]), 2);//dB
                    if ((PowerFlatnessPrint.TestVal >= 0) && (PowerFlatnessPrint.TestVal <= PowerFlatnessPrint.Upper))
                    {
                        PowerFlatnessPrint.Result = "是";
                    }
                    else
                    {
                        PowerFlatnessPrint.Result = "否";
                    }

                    tps.TestTableAddCell(PowerSumPrint.Test_name, PowerSumPrint.Lower.ToString(), PowerSumPrint.Upper.ToString(), PowerSumPrint.TestVal.ToString(), PowerSumPrint.Result);
                    tps.TestTableAddCell(PowerFlatnessPrint.Test_name, "0", PowerFlatnessPrint.Upper.ToString(),  PowerFlatnessPrint.TestVal.ToString(), PowerFlatnessPrint.Result);
                    // WriteExcelData(sheet, parameters.PointIndex, 3, PowerSumPrint.Test_name, PowerSumPrint.Lower.ToString(), "/", PowerSumPrint.TestVal.ToString(), PowerSumPrint.Result);
                    // WriteExcelData(sheet, parameters.PointIndex, 4, PowerFlatnessPrint.Test_name, PowerFlatnessPrint.Lower.ToString(), "/", PowerFlatnessPrint.TestVal.ToString(), PowerFlatnessPrint.Result);
                    //tps.SetTestTableCellValue(parameters.PointIndex, 12, PowerSumPrint.Result, PowerSumPrint.TestVal);
                    //tps.SetTestTableCellValue(parameters.PointIndex, 13, PowerFlatnessPrint.Result,PowerFlatnessPrint.TestVal);

                }
                #endregion
            }
            SaveExcel(workbook);
            ShowMessage(MsgType.Info, string.Format("第{0}个频点功率(功率计)测试结束", parameters.PointIndex));
            return true;
        }

        
        public class ConfigParameter
        {
            /// <summary>
            /// 输出损耗
            /// </summary>
            public double OutLoss { set; get; }
            /// <summary>
            /// 产品测试的起始频率
            /// </summary>
            public double StartFrequency { set; get; }
            /// <summary>
            /// 产品测试的频率步进
            /// </summary>
            public double StepFrequency { set; get; }
            /// <summary>
            /// 产品测试的频点数量
            /// </summary>
            public int FrequencyNumber { set; get; }
            /// <summary>
            /// 产品的工作频带上限(终止频率)
            /// 功能：用于判断从起始频率按一定的步进测试是否超出产品工作频段上限
            /// </summary>
            public double StopFrequency { set; get; }
            /// <summary>
            ///设置频谱仪的SPAN
            /// </summary>
            public string SPAN { set; get; }
            /// <summary>
            /// 设置参考电平
            /// </summary>
            public string REF { set; get; }
            /// <summary>
            /// 设置RBW
            /// </summary>
            public string RBW { set; get; }
            /// <summary>
            /// 设置VBW
            /// </summary>
            public string VBW { set; get; }
            /// <summary>
            /// 控制延时
            /// </summary>
            public int ControlDelay { set; get; }
            /// <summary>
            /// 功率下限
            /// </summary>
            public double PowerLower { set; get; }
            /// <summary>
            /// 功率上限
            /// </summary>
            public double PowerUpper { set; get; }
            /// <summary>
            /// 频率稳定度上限
            /// </summary>
            public double FreqAccuracyUpper { set; get; }
            /// <summary>
            /// 两路功率总和下限
            /// </summary>
            public double PowerSumLower { set; get; }
            /// <summary>
            /// 两路功率总和上限
            /// </summary>
            public double PowerSumUpper { set; get; }
            /// <summary>
            /// 功率不平度上限
            /// </summary>
            public double PowerFlatnessUpper { set; get; }

        }
    }
}