using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Toolkit.Mvvm.ComponentModel;
using System.Collections.ObjectModel;
using Microsoft.Toolkit.Mvvm.Input;
using BPASmartClient.Helper;
using BPASmartClient.DosingHKProject.Model;
using BPASmartClient.CustomResource.Pages.Model;
using BPASmartClient.Model;
using BPASmartClient.DosingHKProject.Model.RawMaterial;

namespace BPASmartClient.DosingHKProject.ViewModel
{
    public class NewRecipeViewModel : ObservableObject
    {
        public NewRecipeViewModel()
        {
            ActionManage.GetInstance.Register(new Action<object>((o) =>
            {
                if (o != null && o is RecipeModel rm)
                {
                    RecipeName = rm.RecipeName;
                    foreach (var item in rm.RawMaterials)
                    {
                        RawMaterials.Add(item);
                    }
                    RecipeCode = rm.RecipCode;
                }
            }), "Details");

            AddCommand = new RelayCommand(() =>
            {
            p:
                string guid = Guid.NewGuid().ToString();
                if (RawMaterials.FirstOrDefault(p => p.RawMaterialId == guid) == null)
                {
                    RawMaterials.Add(new RawMaterialModel()
                    {
                        RawMaterialId = guid
                    });
                }
                else goto p;
            });

            RemoveCommand = new RelayCommand<object>((obj) =>
            {
                if (obj is string rm)
                {
                    var res = RawMaterials.FirstOrDefault(p => p.RawMaterialId == rm);
                    if (res != null) Global.DeviceRawMaterials.Remove(res);
                }
            });

            SaveCommand = new RelayCommand(() =>
            {
                ErrorInfo = String.Empty;
                if (RecipeName == String.Empty) { ErrorInfo = "配方名称未填写"; return; }
                for (int i = 0; i < RawMaterials.Count; i++)
                {
                    var res = DeviceInquire.GetInstance.devices.FirstOrDefault(p => p.DeviceName == RawMaterials.ElementAt(i).RawMaterialName);
                    if (res != null)
                    {
                        RawMaterials.ElementAt(i).DeviceIp = res.IpAddress;//根据设备名称和原料名称的唯一匹配关系，给原料配置IP
                        RawMaterials.ElementAt(i).RawMaterialSource = 1;
                    }
                    var su = Global.DeviceRawMaterials.FirstOrDefault(p => p.RawMaterialName == RawMaterials.ElementAt(i).RawMaterialName);
                    if (su != null)
                    {
                        RawMaterials.ElementAt(i).RawMaterialSource = su.RawMaterialSource;
                    }
                }

                if (RecipeCode.Length <= 0)//新建配方
                {
                    var res = Array.FindIndex(Json<LocaPar>.Data.Recipes.ToArray(), p => p.RecipeName == RecipeName);

                    if (res >= 0 && res < Json<LocaPar>.Data.Recipes.Count)
                    {
                        ErrorInfo = "该配方已存在，请重新输入";
                    }
                    else
                    {
                        AddRecipes();
                    }
                }
                else//修改配方
                {
                    var res = Array.FindIndex(Json<LocaPar>.Data.Recipes.ToArray(), p => p.RecipCode == RecipeCode);
                    if (res >= 0 && res < Json<LocaPar>.Data.Recipes.Count)
                    {
                        Json<LocaPar>.Data.Recipes.ElementAt(res).RecipeName = RecipeName;
                        Json<LocaPar>.Data.Recipes.ElementAt(res).RawMaterials.Clear();
                        foreach (var item in RawMaterials)
                        {
                            Json<LocaPar>.Data.Recipes.ElementAt(res).RawMaterials.Add(item);
                        }
                    }
                }
                ActionManage.GetInstance.Send("CloseNewRecipeView");
            });

            if (Global.userInfo.permission == CustomResource.Pages.Enums.Permission.管理员)
            {
                foreach (var item in Global.DeviceRawMaterials)
                {
                    RawMaterialNames.Add(item.RawMaterialName);

                }
                foreach (var item in Json<LocaMaterial>.Data.LocalMaterails)
                {
                    RawMaterialNames.Add(item.RawMaterialName);
                }
            }
            else
            {
                foreach (var item in Global.DeviceRawMaterials)
                {
                    if (Global.userInfo.devRawMaterials.FirstOrDefault(p => p.RawMaterialName == item.RawMaterialName) != null) RawMaterialNames.Add(item.RawMaterialName);
                }
                foreach (var item in Json<LocaMaterial>.Data.LocalMaterails)
                {
                    if (Global.userInfo.locaRawMaterials.FirstOrDefault(p => p.RawMaterialName == item.RawMaterialName) != null) RawMaterialNames.Add(item.RawMaterialName);
                }
            }
        }

        private void AddRecipes()
        {
            string date = DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss");
            var dates = date.Split("-").ToList();
            StringBuilder sb = new StringBuilder();
            dates?.ForEach((item) => { sb.Append(item); });
            Json<LocaPar>.Data.Recipes.Add(new RecipeModel()
            {
                SerialNum = Json<LocaPar>.Data.Recipes.Count + 1,
                RawMaterials = RawMaterials,
                RecipCode = sb.ToString(),
                RecipeName = RecipeName,
            });
        }

        public string RecipeCode { get { return _mRecipeCode; } set { _mRecipeCode = value; OnPropertyChanged(); } }
        private string _mRecipeCode = string.Empty;

        public string RecipeName { get { return _mRecipeName; } set { _mRecipeName = value; OnPropertyChanged(); } }
        private string _mRecipeName = string.Empty;

        public string ErrorInfo { get { return _mErrorInfo; } set { _mErrorInfo = value; OnPropertyChanged(); } }
        private string _mErrorInfo;

        public RelayCommand AddCommand { get; set; }

        public RelayCommand<object> RemoveCommand { get; set; }

        public RelayCommand SaveCommand { get; set; }

        public ObservableCollection<RawMaterialModel> RawMaterials { get; set; } = new ObservableCollection<RawMaterialModel>();

        public ObservableCollection<string> RawMaterialNames { get; set; } = new ObservableCollection<string>();
    }
}