using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using Aitex.Core.Util;
using Caliburn.Micro;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.RecipeCenter;
using OpenSEMI.ClientBase;
using RecipeEditorLib.RecipeModel.Params;
using VirgoUI.Client.Models.Sys;

namespace VirgoUI.Client.Models.Recipe.Clean
{
    public class CleanItem : NotifiableItem
    {
        public string ChamberModule { get; set; }
        public string ModuleName { get; set; }

        public bool IdlePurgeIsEnable { get; set; }
        public string IdlePurgeRecipe { get; set; }
        public int IdlePurgeIdleTimeSetPoint { get; set; }
        public int IdlePurgeNextRunTime { get; set; }
        public bool IdlePurgeIsSaved { get; set; }

        public bool IdleCleanIsEnable { get; set; }
        public string IdleCleanRecipe { get; set; }
        public int IdleCleanIdleTimeSetPoint { get; set; }
        public int IdleCleanNextRunTime { get; set; }
        public bool IdleCleanIsSaved { get; set; }

        public bool JobCleanIsEnable { get; set; }
        public string PreJobRecipe { get; set; }
        public string CompleteJobRecipe { get; set; }
        public bool PreJobIsEnable { get; set; }
        public bool CompleteJobIsEnable { get; set; }

        public bool PreJobIdleTimeIsSaved { get; set; }

        public int PreJobIdleTimeSetPoint { get; set; }
    }

    public class PMCleanViewModel : ModuleUiViewModelBase, ISupportMultipleSystem
    {
        private int MenuPermission;

        public bool IsReadOnly
        {
            get => this.Permission == 2 ? true : false;
        }

        public bool IsEnableEdit
        {
            get => !IsReadOnly;
        }

        [Subscription("IdlePurgeNextRunTime")]
        public int IdlePurgeNextRunTimePM { get; set; }

        [Subscription("IdleCleanNextRunTime")]
        public int IdleCleanNextRunTimePM { get; set; }

        public CleanItem CleanDataPM { get; set; }

        public PMCleanViewModel()
        {
            this.DisplayName = " CleanViewModel";

            CleanDataPM = new CleanItem() { ChamberModule = $"{SystemName}", ModuleName = "", IdlePurgeIsSaved = true, IdleCleanIsSaved = true };
        }

        protected override void OnInitialize()
        {
            base.OnInitialize();
        }

        protected override void InvokeBeforeUpdateProperty(Dictionary<string, object> data)
        {
            base.InvokeBeforeUpdateProperty(data);
        }

        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
            MenuPermission = ClientApp.Instance.GetPermission($"Clean{SystemName}");
            base.InvokeAfterUpdateProperty(data);

            CleanDataPM.IdleCleanNextRunTime = IdleCleanNextRunTimePM;
            CleanDataPM.IdlePurgeNextRunTime = IdlePurgeNextRunTimePM;
            CleanDataPM.InvokePropertyChanged("IdleCleanNextRunTime");
            CleanDataPM.InvokePropertyChanged("IdlePurgeNextRunTime");
        }

        #region  Idle Purge
        public void IdlePurgeIsEnableChanged(string ModuleName, bool isEnabled)
        {
            InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"System.IdlePurge.IsEnabled", isEnabled.ToString());
        }
        public void IdlePurgeSetTime(string module, string value)
        {
            if (string.IsNullOrEmpty(value) || !int.TryParse(value, out _))
            {
                DialogBox.ShowWarning("Time not valid");
                return;
            }
            InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"System.IdlePurge.IdlePurgeTime", value);

            CleanDataPM.IdlePurgeIsSaved = true;
            CleanDataPM.InvokePropertyChanged("IdlePurgeIsSaved");
        }

        public void IdlePurgeResetTime(string module)
        {
            InvokeClient.Instance.Service.DoOperation($"System.ResetIdlePurgeTime", module);
        }

        public void IdlePurgeSelectRecipe(string module)
        {
            //RecipeSequenceSelectDialogViewModel dialog = new RecipeSequenceSelectDialogViewModel();
            //dialog.DisplayName = "Select Recipe";

            //List<string> lstFiles = RecipeClient.Instance.Service.GetRecipesByPath($"ALD\\Process\\", false).ToList();

            //dialog.Files = new ObservableCollection<FileNode>(RecipeSequenceTreeBuilder.GetFiles("prefixPath", lstFiles));

            //WindowManager wm = new WindowManager();
            //bool? ret = wm.ShowDialog(dialog);
            //if ((bool)ret)
            //{
            //    CleanDataPM.IdlePurgeRecipe = dialog.DialogResult;
            //    CleanDataPM.InvokePropertyChanged("IdlePurgeRecipe");

            //    InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"{module}.IdlePurge.IdlePurgeRecipe", dialog.DialogResult);
            //}
        }


        public void SelectRecipe(string path)
        {
            RecipeSequenceSelectDialogViewModel dialog = new RecipeSequenceSelectDialogViewModel();
            dialog.DisplayName = "Select Recipe";
 

            string module = ModuleName.System.ToString();
            List<string> lstFiles;

 
                lstFiles = RecipeClient.Instance.Service.GetRecipesByPath($"{module}", false).ToList();
 

            dialog.Files = new ObservableCollection<FileNode>(RecipeSequenceTreeBuilder.GetFiles(lstFiles));

            WindowManager wm = new WindowManager();
            bool? bret = wm.ShowDialog(dialog);
            if ((bool)bret)
            {
                //param.Value = dialog.DialogResult;
                //param.IsSaved = false;
            }
        }


        #endregion

        #region IdleClean

        public void IdleCleanIsEnableChanged(string ModuleName, bool isEnabled)
        {
            InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"{SystemName}.IdleClean.IsEnabled", isEnabled.ToString());
        }
        public void IdleCleanSetTime(string module, string value)
        {
            if (MenuPermission != 3) return;
            if (string.IsNullOrEmpty(value) || !int.TryParse(value, out _))
            {
                DialogBox.ShowWarning("Time not valid");
                return;
            }
            InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"{SystemName}.IdleClean.IdleCleanTime", value);

            CleanDataPM.IdleCleanIsSaved = true;
            CleanDataPM.InvokePropertyChanged("IdleCleanIsSaved");
        }

        public void PreJobSetIdleTime(string module, string value)
        {
            if (MenuPermission != 3) return;
            if (string.IsNullOrEmpty(value) || !int.TryParse(value, out _))
            {
                DialogBox.ShowWarning("Time not valid");
                return;
            }

            InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"{SystemName}.JobClean.IdleCleanTime", value);

            CleanDataPM.PreJobIdleTimeIsSaved = true;
            CleanDataPM.InvokePropertyChanged("PreJobIdleTimeIsSaved");
        }


        public void IdleCleanResetTime(string module)
        {
            if (MenuPermission != 3) return;
            InvokeClient.Instance.Service.DoOperation($"System.ResetIdleCleanTime", $"{SystemName}");
        }

        public void IdleCleanSelectRecipe(string module)
        {
            if (MenuPermission != 3) return;
            RecipeSequenceSelectDialogViewModel dialog = new RecipeSequenceSelectDialogViewModel();
            dialog.DisplayName = "Select Recipe";


            List<string> lstFiles = new List<string>();

            module = SystemName;

            lstFiles.Add("");
            lstFiles.AddRange(RecipeClient.Instance.Service.GetRecipesByPath($"{module}", false).ToList());

            dialog.Files = new ObservableCollection<FileNode>(RecipeSequenceTreeBuilder.GetFiles(lstFiles));

            WindowManager wm = new WindowManager();
            bool? ret = wm.ShowDialog(dialog);
 
            if ((bool)ret)
            {
                CleanDataPM.IdleCleanRecipe = dialog.DialogResult;
                CleanDataPM.InvokePropertyChanged("IdleCleanRecipe");

                InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"{SystemName}.IdleClean.IdleCleanRecipe", dialog.DialogResult);
            }
        }

        #endregion

        #region JobClean

        public void JobCleanIsEnableChanged(string module, bool isEnabled)
        {
            InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"{SystemName}.JobClean.IsEnabled", isEnabled.ToString());
        }
        public void PreJobIsEnableChanged(string module, bool isEnabled)
        {
            InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"{SystemName}.JobClean.EnablePreJobClean", isEnabled.ToString());
        }
        public void CompleteJobIsEnableChanged(string module, bool isEnabled)
        {
            InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"{SystemName}.JobClean.EnableCompleteJobClean", isEnabled.ToString());
        }

        public void PreJobSelectRecipe(string module)
        {
            if (MenuPermission != 3) return;
            RecipeSequenceSelectDialogViewModel dialog = new RecipeSequenceSelectDialogViewModel();
            dialog.DisplayName = "Select Recipe";


            List<string> lstFiles = new List<string>();

            module = SystemName;

            lstFiles.Add("");
            lstFiles.AddRange(RecipeClient.Instance.Service.GetRecipesByPath($"{module}", false).ToList());

            dialog.Files = new ObservableCollection<FileNode>(RecipeSequenceTreeBuilder.GetFiles(lstFiles));

            WindowManager wm = new WindowManager();
            bool? ret = wm.ShowDialog(dialog);
            if ((bool)ret)
            {
                CleanDataPM.PreJobRecipe = dialog.DialogResult;
                CleanDataPM.InvokePropertyChanged("PreJobRecipe");

                InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"{SystemName}.JobClean.PreJobCleanRecipe", dialog.DialogResult);
            }
        }

        public void CompleteJobSelectRecipe(string module)
        {
            if (MenuPermission != 3) return;
            RecipeSequenceSelectDialogViewModel dialog = new RecipeSequenceSelectDialogViewModel();
            dialog.DisplayName = "Select Recipe";


            module =  SystemName;
            List<string> lstFiles = new List<string>();

            lstFiles.Add("");
            lstFiles.AddRange(RecipeClient.Instance.Service.GetRecipesByPath($"{module}", false).ToList());

            dialog.Files = new ObservableCollection<FileNode>(RecipeSequenceTreeBuilder.GetFiles( lstFiles));

            WindowManager wm = new WindowManager();
            bool? ret = wm.ShowDialog(dialog);
            if ((bool)ret)
            {
                CleanDataPM.CompleteJobRecipe = dialog.DialogResult;
                CleanDataPM.InvokePropertyChanged("CompleteJobRecipe");

                InvokeClient.Instance.Service.DoOperation($"System.SetConfig", $"{SystemName}.JobClean.CompleteJobCleanRecipe", dialog.DialogResult);
            }
        }

        #endregion

        protected override void OnActivate()
        {
            base.OnActivate();

            List<string> _lsConfigName = new List<string>()
            {

                $"{SystemName}.IdleClean.IsEnabled",
                $"{SystemName}.IdleClean.IdleCleanRecipe",
                $"{SystemName}.IdleClean.IdleCleanTime",

                $"{SystemName}.JobClean.IsEnabled",
                $"{SystemName}.JobClean.PreJobCleanRecipe",
                $"{SystemName}.JobClean.CompleteJobCleanRecipe",
                $"{SystemName}.JobClean.EnablePreJobClean",
                $"{SystemName}.JobClean.EnableCompleteJobClean",
                $"{SystemName}.JobClean.IdleCleanTime",
            };

            var configs = QueryDataClient.Instance.Service.PollConfig(_lsConfigName);

            CleanDataPM.ChamberModule = SystemName;
 
            CleanDataPM.IdleCleanIdleTimeSetPoint = (int)configs[$"{SystemName}.IdleClean.IdleCleanTime"];
            CleanDataPM.IdleCleanIsEnable = (bool)configs[$"{SystemName}.IdleClean.IsEnabled"];
            CleanDataPM.IdleCleanRecipe = (string)configs[$"{SystemName}.IdleClean.IdleCleanRecipe"];

            CleanDataPM.JobCleanIsEnable = (bool)configs[$"{SystemName}.JobClean.IsEnabled"];
            CleanDataPM.PreJobRecipe = (string)configs[$"{SystemName}.JobClean.PreJobCleanRecipe"];
            CleanDataPM.PreJobIsEnable = (bool)configs[$"{SystemName}.JobClean.EnablePreJobClean"];
            CleanDataPM.CompleteJobRecipe = (string)configs[$"{SystemName}.JobClean.CompleteJobCleanRecipe"];
            CleanDataPM.CompleteJobIsEnable = (bool)configs[$"{SystemName}.JobClean.EnableCompleteJobClean"];
            CleanDataPM.PreJobIdleTimeSetPoint = (int)configs[$"{SystemName}.JobClean.IdleCleanTime"];
        }

        protected override void OnDeactivate(bool close)
        {
            base.OnDeactivate(close);
        }
    }
}