using Cowain.Bake.BLL;
using Cowain.Bake.Common;
using Cowain.Bake.Common.Core;
using Cowain.Bake.Common.Enums;
using Cowain.Bake.Common.Models;
using Cowain.Bake.Communication.Interface;
using Cowain.Bake.Model;
using Cowain.Bake.Model.Models;
using HslCommunication;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Unity;
using JSON = System.Text.Json.JsonSerializer;

namespace Cowain.Bake.Main.Station
{
    public class StoveProcessParam
    {
        const int PROCESS_PARAM_NUM = 21;
        //ProcessParamService procParamService;
        public IUnityContainer _unityContainer { get; set; }
        public StoveProcessParam(IUnityContainer unityContainer)
        {
            _unityContainer = unityContainer;
            //procParamService = _unityContainer.Resolve<ProcessParamService>();
        }

        public bool SendStoveProcessParam(IPLCDevice plc, ExCavityInfoModel palletProceParam)
        {
            ProceParamList proceParam = null;
            TProcessParameter proceParamModel = null;
            //_unityContainer.Resolve<LogService>().AddLog("StoveProcessParam:SendStoveProcessParam:下发工艺参数开始"
            //    , E_LogType.Info.ToString());
            OperateResult<AddrValue> operateResult = null;
            Model.Models.Variable node = null;
            List<AddrValue> makeAddrValues = new List<AddrValue>();
            List<ProceParamList> listParams = null;
            if (null == palletProceParam)
            {
                LogHelper.Instance.GetCurrentClassWarn("发送工艺参数时，没有获取到托盘信息！");
                return false;
            }

            //判断是否是复烘
            if (palletProceParam.PalletStatus == (int)EPalletStatus.TestNG)
            {
                //使用复烘工艺
                proceParamModel = _unityContainer.Resolve<ProcessParamService>().GetReProcessParam(palletProceParam.JobNum); 
            }
            else
            {
                proceParamModel = _unityContainer.Resolve<ProcessParamService>().GetProcessParam(palletProceParam.JobNum);
            }

            if (null == proceParamModel)
            {
                LogHelper.Instance.GetCurrentClassWarn("没有找到工艺参数列表!");
                return false;
            }

            try
            {
                listParams = JSON.Deserialize<List<ProceParamList>>(proceParamModel.Parameters);
            }
            catch(Exception ex)
            {
                LogHelper.Instance.GetCurrentClassFatal(ex.Message);
                return false;
            }

            //温度上限预警值
            node = plc.GetVariable(EStoveSignal.TemperatureUpperWarnValue.ToString(), palletProceParam.StationId);
            proceParam = listParams.Where(x => x.ParameterCode.ToLower() == EStoveSignal.TemperatureUpperWarnValue.ToString().ToLower()).FirstOrDefault();
            operateResult = SetNodeValue(node, proceParam);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //真空上限预警值
            node = plc.GetVariable(EStoveSignal.VacuumUpperWarnValue.ToString(), palletProceParam.StationId);
            proceParam = listParams.Where(x => x.ParameterCode.ToLower() == EStoveSignal.VacuumUpperWarnValue.ToString().ToLower()).FirstOrDefault();
            operateResult = SetNodeValue(node, proceParam);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            ////参数_设定温度
            node = plc.GetVariable(EStoveSignal.SetTemp.ToString(), palletProceParam.StationId);
            proceParam = listParams.Where(x => x.ParameterCode.ToLower() == EStoveSignal.SetTemp.ToString().ToLower()).FirstOrDefault();
            operateResult = SetNodeValue(node, proceParam, 100); //乘以100，设定10000，表示100度
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_温度公差
            node = plc.GetVariable(EStoveSignal.TemperatureTolerance.ToString(), palletProceParam.StationId);
            proceParam = listParams.Where(x => x.ParameterCode.ToLower() == EStoveSignal.TemperatureTolerance.ToString().ToLower()).FirstOrDefault();
            operateResult = SetNodeValue(node, proceParam, 100); //乘以100，设定10000
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_温度上限
            node = plc.GetVariable(EStoveSignal.TemperatureLimit.ToString(), palletProceParam.StationId);
            proceParam = listParams.Where(x => x.ParameterCode.ToLower() == EStoveSignal.TemperatureLimit.ToString().ToLower()).FirstOrDefault();
            operateResult = SetNodeValue(node, proceParam, 100); //乘以100，设定10000
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_真空到达值
            node = plc.GetVariable(EStoveSignal.VacuumArriveValue.ToString(), palletProceParam.StationId);
            proceParam = listParams.Where(x => x.ParameterCode.ToLower() == EStoveSignal.VacuumArriveValue.ToString().ToLower()).FirstOrDefault();
            operateResult = SetNodeValue(node, proceParam);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_真空上限
            node = plc.GetVariable(EStoveSignal.VacuumUpValue.ToString(), palletProceParam.StationId);
            proceParam = listParams.Where(x => x.ParameterCode.ToLower() == EStoveSignal.VacuumUpValue.ToString().ToLower()).FirstOrDefault();
            operateResult = SetNodeValue(node, proceParam);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_真空下限
            node = plc.GetVariable(EStoveSignal.VacuumDownValue.ToString(), palletProceParam.StationId);
            proceParam = listParams.Where(x => x.ParameterCode.ToLower() == EStoveSignal.VacuumDownValue.ToString().ToLower()).FirstOrDefault();
            operateResult = SetNodeValue(node, proceParam);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_氮气到达值
            node = plc.GetVariable(EStoveSignal.NitrogenArriveValue.ToString(), palletProceParam.StationId);
            proceParam = listParams.Where(x => x.ParameterCode.ToLower() == EStoveSignal.NitrogenArriveValue.ToString().ToLower()).FirstOrDefault();
            operateResult = SetNodeValue(node, proceParam);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_氮气上限
            node = plc.GetVariable(EStoveSignal.NitrogenUpValue.ToString(), palletProceParam.StationId);
            proceParam = listParams.Where(x => x.ParameterCode.ToLower() == EStoveSignal.NitrogenUpValue.ToString().ToLower()).FirstOrDefault();
            operateResult = SetNodeValue(node, proceParam);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_氮气下限
            node = plc.GetVariable(EStoveSignal.NitrogenDownValue.ToString(), palletProceParam.StationId);
            proceParam = listParams.Where(x => x.ParameterCode.ToLower() == EStoveSignal.NitrogenDownValue.ToString().ToLower()).FirstOrDefault();
            operateResult = SetNodeValue(node, proceParam);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_常压到达值
            node = plc.GetVariable(EStoveSignal.AtmosphericArriveValue.ToString(), palletProceParam.StationId);
            proceParam = listParams.Where(x => x.ParameterCode.ToLower() == EStoveSignal.AtmosphericArriveValue.ToString().ToLower()).FirstOrDefault();
            operateResult = SetNodeValue(node, proceParam);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_常压上限
            node = plc.GetVariable(EStoveSignal.AtmosphericUpValue.ToString(), palletProceParam.StationId);
            proceParam = listParams.Where(x => x.ParameterCode.ToLower() == EStoveSignal.AtmosphericUpValue.ToString().ToLower()).FirstOrDefault();
            operateResult = SetNodeValue(node, proceParam);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_常压下限
            node = plc.GetVariable(EStoveSignal.AtmosphericDownValue.ToString(), palletProceParam.StationId);
            proceParam = listParams.Where(x => x.ParameterCode.ToLower() == EStoveSignal.AtmosphericDownValue.ToString().ToLower()).FirstOrDefault();
            operateResult = SetNodeValue(node, proceParam);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_循环启动工步
            node = plc.GetVariable(EStoveSignal.CycleStartStep.ToString(), palletProceParam.StationId);
            operateResult = SetNodeValues(node, listParams, EStoveSignal.CycleStartStep.ToString(), false);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_循环结束工步
            node = plc.GetVariable(EStoveSignal.CycleEndStep.ToString(), palletProceParam.StationId);
            operateResult = SetNodeValues(node, listParams, EStoveSignal.CycleEndStep.ToString(), false);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_循环次数
            node = plc.GetVariable(EStoveSignal.CycleNumber.ToString(), palletProceParam.StationId);
            operateResult = SetNodeValues(node, listParams, EStoveSignal.CycleNumber.ToString(), false);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_加热启用
            node = plc.GetVariable(EStoveSignal.HeatingEnabled.ToString(), palletProceParam.StationId);
            operateResult = SetNodeValues(node, listParams, EStoveSignal.HeatingEnabled.ToString(), true);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_真空启用
            node = plc.GetVariable(EStoveSignal.VacuumEnabled.ToString(), palletProceParam.StationId);
            operateResult = SetNodeValues(node, listParams, EStoveSignal.VacuumEnabled.ToString(), true);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_氮气启用
            node = plc.GetVariable(EStoveSignal.NitrogenEnabled.ToString(), palletProceParam.StationId);
            operateResult = SetNodeValues(node, listParams, EStoveSignal.NitrogenEnabled.ToString(), true);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            //参数_工步时间
            node = plc.GetVariable(EStoveSignal.StepWorkTime.ToString(), palletProceParam.StationId);
            operateResult = SetNodeValues(node, listParams, EStoveSignal.StepWorkTime.ToString(), true);
            if (operateResult.IsSuccess)
            {
                makeAddrValues.Add(operateResult.Content);
            }

            if (PROCESS_PARAM_NUM != makeAddrValues.Count)
            {
                LogHelper.Instance.GetCurrentClassError("发送工艺数据项不够！", true);
                return false;
            }

            OperateResult result = plc.Writes(makeAddrValues.Select(x => x.Addr).ToArray(), makeAddrValues.Select(x => x.Value).ToArray());

            if (!result.IsSuccess)
            {
                LogHelper.Instance.GetCurrentClassError($"发送工艺数据失败,{result.Message}！");
                return false;
            }
            _unityContainer.Resolve<LogService>().AddLog("StoveProcessParam:SendStoveProcessParam:下发工艺参数结束", E_LogType.Info.ToString());
            return true;
        }

        OperateResult<AddrValue> SetNodeValues(Model.Models.Variable node, List<ProceParamList> proceParams, string key, bool fristNull)
        {
            object obj;
            EDataType dt = EDataType.UINT32;
            OperateResult<AddrValue> result = new OperateResult<AddrValue>() { IsSuccess = false };
            AddrValue nodeValue = new AddrValue();
            List<object> vaules = new List<object>();

            if (fristNull)
            {
                vaules.Add(StringToObject("0", node.VarType));
            }

            foreach (var item in proceParams)
            {
                if (item.ParameterCode.ToLower().StartsWith(key.ToLower())) //在JOSN里面，数组一定要按顺序排，或者顺序乱了
                {
                    dt = (EDataType)System.Enum.Parse(typeof(EDataType), node.VarType);            
                    obj = StringToObject(item.TargetValue, node.VarType);

                   if (null == obj)
                   {
                        continue;
                   }

                   vaules.Add(obj);
                }
            }

            if (vaules.Count == 0)
            {
                return result;
            }

            nodeValue.Addr = node.Address + node.VarName;
            System.Type type = System.Type.GetType(dt.GetDescription());
            MethodInfo mi = this.GetType().GetMethod(ReflexFun.OBJECT_TO_T).MakeGenericMethod(new System.Type[] { type }); //如果不转T，直接object会写不进去
            nodeValue.Value =  mi.Invoke(this, new object[]
            {
                vaules
            });
            result.Content = nodeValue;
            result.IsSuccess = true;
            return result;
        }

        public T[] ObjectToT<T>(List<object> vaules) //where T : class
        {
            return vaules.OfType<T>().ToArray(); //object[]转T[]       
        }

        object StringToObject(string value, string varType, float multiples = 1)
        {
            object obj = null;
            EDataType dt = (EDataType)Enum.Parse(typeof(EDataType), varType);
            try
            {
                switch (dt)
                {
                    case EDataType.BOOL:
                        obj = (value == "1");
                        break;
                    case EDataType.UINT16:
                        obj = (UInt16)(System.Convert.ToSingle(value) * multiples);
                        break;
                    case EDataType.INT16:
                        obj = (Int16)(System.Convert.ToSingle(value) * multiples);
                        break;
                    case EDataType.INT32:
                        obj = (Int32)(System.Convert.ToSingle(value) * multiples);
                        break;
                    case EDataType.UINT32:
                        obj = (UInt32)(System.Convert.ToSingle(value) * multiples);
                        break;
                    case EDataType.FLOAT:
                    case EDataType.REAL:
                        obj = (float)(System.Convert.ToSingle(value) * multiples);
                        break;
                    default:
                        LogHelper.Instance.Fatal($"没有这种数据类型:{varType}");
                        break;
                }
                if (null == obj)
                {
                    LogHelper.Instance.GetCurrentClassError("获取工艺数据的值为空");
                }
            }
            catch(Exception ex)
            {
                LogHelper.Instance.GetCurrentClassDebug(ex.Message);
            }
           

            return obj;
        }

        OperateResult<AddrValue> SetNodeValue(Model.Models.Variable node, ProceParamList proceParam, float multiples = 1)
        {
            OperateResult<AddrValue> result = new OperateResult<AddrValue>() { IsSuccess = false};
            AddrValue nodeValue = new AddrValue();
            if (null == node)
            {
                LogHelper.Instance.GetCurrentClassError("获取节点数据失败");
                return result;
            }

            if (null == proceParam)
            {
                LogHelper.Instance.GetCurrentClassError("获取工艺数据失败");
                return result;
            }

            nodeValue.Addr = node.Address + node.VarName;          
            nodeValue.Value = StringToObject(proceParam.TargetValue, node.VarType, multiples);
            
            if (null == nodeValue.Value)
            {
                return result;
            }

            result.IsSuccess = true;
            result.Content = nodeValue;
            return result;
        }
    }
}