using Aitex.Core.RT.Log;
using Aitex.Core.RT.ParameterCenter;
using Caliburn.Micro.Core;
using MECF.Framework.Common.ParameterCenter;
using MECF.Framework.UI.Client.CenterViews.Editors.Recipe;
using RecipeEditorLib.RecipeModel.Params;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Xml;

namespace MECF.Framework.UI.Client.CenterViews.Parameter
{
    public class TempProfileParameterData : ParameterDataBase
    {
        private ParameterProvider _parameterProvider = new ParameterProvider();

        private ParameterFormatBuilder _columnBuilder = new ParameterFormatBuilder();

        private Dictionary<string, ObservableCollection<ParameterTemplateColumnBase>> ParameterTemplate;
        public TempProfileParameterData() : base()
        {
            string vars = _parameterProvider.GetParameterFormatXml($"Parameter\\TempProfile");
            _columnBuilder.Build($"Parameter\\TempProfile");
            ParameterTemplate = _parameterProvider.GetGroupParameterTemplate();
            TableNumber = _columnBuilder.TableNumber;
            Version = _columnBuilder.Version;
            for (int i = 1; i < TableNumber+1; i++)
            {
                Steps.Add(CreateStep());
            }
        }

       public override ParameterTable CreateStep(XmlNode stepNode = null)
        {
            ParameterTable table = new TempProfileTable();
            var step = table as TempProfileTable;
            if (stepNode != null)
            {
                if (stepNode.Attributes["StepNo"] != null)
                    step.StepNo = int.Parse(stepNode.Attributes["StepNo"].Value);
                if (stepNode.Attributes["Name"] != null)
                    step.Name = stepNode.Attributes["Name"].Value;
            }
            else
            {
                step.StepNo = StepNo;
                step.Name = "Name" + StepNo.ToString();
            //    step.UseTemp = "0";
                StepNo++;
                

            }
            foreach (var item in ParameterTemplate)
            {
                if (item.Key != "Parameter Information")
                {
                    var ucom = item.Value.Where(x => x.ControlName == "U").FirstOrDefault();
                    if (ucom != null)
                    {
                        DoubleParam uParam = new DoubleParam()
                        {
                            Name = ucom.ControlName,
                            Value = ucom.Value.ToString(),
                            DisplayName = ucom.DisplayName,
                            Minimun = ucom.Minimun,
                            Maximun = ucom.Maximun,
                            Resolution = 0

                        };
                        step.LimitU = uParam;
                    }
                    var cucom = item.Value.Where(x => x.ControlName == "CU").FirstOrDefault();
                    if (cucom != null)
                    {
                        DoubleParam cuParam = new DoubleParam()
                        {
                            Name = cucom.ControlName,
                            Value = cucom.Value.ToString(),
                            DisplayName = cucom.DisplayName,
                            Minimun = cucom.Minimun,
                            Maximun = cucom.Maximun,
                            Resolution = 0

                        };
                        step.LimitCU = cuParam;
                    }
                    var ccom = item.Value.Where(x => x.ControlName == "C").FirstOrDefault();
                    if (ccom != null)
                    {
                        DoubleParam cParam = new DoubleParam()
                        {
                            Name = ccom.ControlName,
                            Value = ccom.Value.ToString(),
                            DisplayName = ccom.DisplayName,
                            Minimun = ccom.Minimun,
                            Maximun = ccom.Maximun,
                            Resolution = 0

                        };
                        step.LimitC = cParam;
                    }
                    var clcom = item.Value.Where(x => x.ControlName == "CL").FirstOrDefault();
                    if (clcom != null)
                    {
                        DoubleParam clParam = new DoubleParam()
                        {
                            Name = clcom.ControlName,
                            Value = clcom.Value.ToString(),
                            DisplayName = clcom.DisplayName,
                            Minimun = clcom.Minimun,
                            Maximun = clcom.Maximun,
                            Resolution = 0

                        };
                        step.LimitCL = clParam;
                    }
                    var lcom = item.Value.Where(x => x.ControlName == "L").FirstOrDefault();
                    if (lcom != null)
                    {
                        DoubleParam lParam = new DoubleParam()
                        {
                            Name = lcom.ControlName,
                            Value = lcom.Value.ToString(),
                            DisplayName = lcom.DisplayName,
                            Minimun = lcom.Minimun,
                            Maximun = lcom.Maximun,
                            Resolution = 0

                        };
                        step.LimitL = lParam;
                    }
                    var alarmLimitcom = item.Value.Where(x => x.ControlName == "AlarmLimit").FirstOrDefault();
                    if (alarmLimitcom != null)
                    {
                        DoubleParam alarmLimitParam = new DoubleParam()
                        {
                            Name = alarmLimitcom.ControlName,
                            Value =alarmLimitcom.Value.ToString(),
                            DisplayName = alarmLimitcom.DisplayName,
                            Minimun = alarmLimitcom.Minimun,
                            Maximun = alarmLimitcom.Maximun,
                        };
                        step.AlarmLimit= alarmLimitParam;
                    }
                }
            }
            if (stepNode != null)
            {
                if (stepNode.Attributes["PreheatTime"] != null)
                    step.PreheatTime = stepNode.Attributes["PreheatTime"].Value;
                if (stepNode.Attributes["CheckTime"] != null)
                    step.CheckTime= stepNode.Attributes["CheckTime"].Value;

                if (stepNode.Attributes["U"] != null)
                    step.LimitU.Value =stepNode.Attributes["U"].Value;
                if (stepNode.Attributes["CU"] != null)
                    step.LimitCU.Value = stepNode.Attributes["CU"].Value;
                if (stepNode.Attributes["C"] != null)
                    step.LimitC.Value = stepNode.Attributes["C"].Value;
                if (stepNode.Attributes["CL"] != null)
                    step.LimitCL.Value = stepNode.Attributes["CL"].Value;
                if (stepNode.Attributes["L"] != null)
                    step.LimitL.Value = stepNode.Attributes["L"].Value;



                if (stepNode.Attributes["TotalTime"] != null)
                    step.TotalTime = stepNode.Attributes["TotalTime"].Value;
                if (stepNode.Attributes["AlarmLimit"] != null)
                    step.AlarmLimit.Value =stepNode.Attributes["AlarmLimit"].Value;
            }
            return step;
        }
        public override string GetXmlString()
        {
            XmlElement nodeData = _doc.SelectSingleNode($"Aitex/TableParameterData") as XmlElement;

            nodeData.SetAttribute("CreatedBy", Creator);
            nodeData.SetAttribute("CreationTime", CreateTime.ToString("yyyy-MM-dd HH:mm:ss"));
            nodeData.SetAttribute("LastRevisedBy", Revisor);
            nodeData.SetAttribute("LastRevisionTime", ReviseTime.ToString("yyyy-MM-dd HH:mm:ss"));
            nodeData.SetAttribute("Description", Description);
            nodeData.SetAttribute("ParameterChamberType", ChamberType);
            nodeData.SetAttribute("Version", Version);
            nodeData.SetAttribute("TableNumber", TableNumber.ToString());
            nodeData.SetAttribute("Permission", Permission);
            nodeData.SetAttribute("ParameterLevel", Level);
            XmlNode nodeModule = _doc.SelectSingleNode($"Aitex/TableParameterData/Module[@Name='{_module}']");
            if (nodeModule == null)
            {
                nodeModule = _doc.CreateElement("Module");
                nodeData.AppendChild(nodeModule);
            }
            nodeModule.RemoveAll();
            (nodeModule as XmlElement).SetAttribute("Name", _module);
            int i = 0;
            foreach (TempProfileTable parameter in Steps)
            {
                XmlElement nodeStep = _doc.CreateElement("Step");
                nodeStep.SetAttribute("StepNo", parameter.StepNo.ToString());
                nodeStep.SetAttribute("Name", parameter.Name);
             //   nodeStep.SetAttribute("UseTemp", parameter.UseTemp);
                nodeStep.SetAttribute("PreheatTime", parameter.PreheatTime);
                nodeStep.SetAttribute("CheckTime", parameter.CheckTime);
                nodeStep.SetAttribute("U", parameter.LimitU.Value.ToString());
                nodeStep.SetAttribute("CU", parameter.LimitCU.Value.ToString());
                nodeStep.SetAttribute("C", parameter.LimitC.Value.ToString());
                nodeStep.SetAttribute("CL", parameter.LimitCL.Value.ToString());
                nodeStep.SetAttribute("L", parameter.LimitL.Value.ToString());
                nodeStep.SetAttribute("TotalTime", parameter.TotalTime);
                nodeStep.SetAttribute("AlarmLimit", parameter.AlarmLimit.Value.ToString());
                nodeModule.AppendChild(nodeStep);
                i++;
            }
          
            return _doc.OuterXml;
        }


        public override void InitData(string prefixPath, string recipeName, string recipeContent, string module)
        {
            IsCompatibleWithCurrentFormat = false;
            _module = module;
            Name = recipeName;
            PrefixPath = prefixPath;
            try
            {
                _doc = new XmlDocument();
                _doc.LoadXml(recipeContent);

                if (!LoadHeader(_doc.SelectSingleNode("Aitex/TableParameterData")))
                    return;

                XmlNodeList nodeSteps = _doc.SelectNodes($"Aitex/TableParameterData/Module[@Name='{module}']/Step");
                if (nodeSteps == null)
                    nodeSteps = _doc.SelectNodes($"Aitex/TableParameterData/Step");

                LoadSteps(nodeSteps);

                var index = 1;
                foreach (ParameterTable parameters in Steps)
                {
                    parameters.Value = index.ToString();
                    index++;
                }

                //   ValidLoopData();

                XmlNode nodeConfig =
                    _doc.SelectSingleNode($"Aitex/TableParameterData/Module[@Name='{module}']/Config");
                if (nodeSteps == null)
                    nodeConfig = _doc.SelectSingleNode($"Aitex/TableParameterData/Config");
                IsCompatibleWithCurrentFormat = true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }
        }
        public override void LoadSteps(XmlNodeList steps)
        {
            Steps.Clear();
            PopSettingSteps.Clear();
            StepTolerances.Clear();
            StepNos.Clear();
            int index = 1;
           
            foreach (XmlNode nodeStep in steps)
            {
                ParameterTable stepTable = this.CreateStep(nodeStep);
                StepNos.Add(stepTable.StepNo);
                Steps.Add(stepTable);
                index++;
            }
        }
       
    }
}