using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using Venus_Core;
using Venus_Unity;
using RoleDefine = Venus_MainPages.Roles.RoleDefine;
using Menu = Venus_MainPages.Roles.Menu;
using Venus_MainPages.Views;
using Venus_MainPages.Roles;
using System.Windows.Data;
using WPF.Themes.UserControls;
using System.IO;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.ControlDataContext;
using System.Windows;
using System.Threading.Tasks;
using Venus_MainPages.Unity;

namespace Venus_MainPages.ViewModels
{
    internal class RoleViewModel : BindableBase
    {
        #region 私有属性
        List<VenusMenu> m_venusMenus = new List<VenusMenu>();
        //ObservableCollection<Menu> m_Menus = new ObservableCollection<Menu>();
        ICollectionView vm;
        ObservableCollection<string> m_Roles = new ObservableCollection<string>();

        ObservableCollection<RoleDefine> m_RoleDefines = new ObservableCollection<RoleDefine>();
        private bool firstLoad = true;
        private RoleView roleView;

        private RoleDefine m_CurrentRoleDefine;

        ObservableCollection<UserItem> m_Users= new ObservableCollection<UserItem>();

        private UserItem m_SelectedUser=new UserItem();
        #endregion

        #region 依赖项属性
        public UserItem SelectedUser
        {
            get { return m_SelectedUser; }
            set
            {
                SetProperty(ref m_SelectedUser, value);
            }
        }
        public ObservableCollection<UserItem> Users
        {
            get { return m_Users; }
            set
            {
                SetProperty(ref m_Users, value);
            }
        }
        public List<VenusMenu> VenusMenus
        {
            get { return m_venusMenus; }
            set
            {
                SetProperty(ref m_venusMenus, value);
            }
        }
        //public ObservableCollection<Menu> Menus
        //{
        //    get { return m_Menus; }
        //    set
        //    {
        //        SetProperty(ref m_Menus, value);
        //    }
        //}
        public ObservableCollection<string> Roles 
        {
            get
            {
                return m_Roles; 
            }
            set 
            {
                SetProperty(ref m_Roles, value);
            }
        }
        public ObservableCollection<RoleDefine> RoleDefines
        {
            get { return m_RoleDefines; }
            set 
            {
                SetProperty(ref m_RoleDefines, value);
            }
        }
        public RoleDefine CurrentRoleDefine
        {
            get { return m_CurrentRoleDefine; }
            set
            {
                SetProperty(ref m_CurrentRoleDefine, value);
            }
        }
        #endregion

        #region 命令
        private DelegateCommand _SaveCommand;
        public DelegateCommand SaveCommand =>
            _SaveCommand ?? (_SaveCommand = new DelegateCommand(OnSave));

        private DelegateCommand<Object> _LoadedCommand;
        public DelegateCommand<Object> LoadedCommand =>
            _LoadedCommand ?? (_LoadedCommand = new DelegateCommand<Object>(OnLoaded));


        private DelegateCommand _AddUserCommand;
        public DelegateCommand AddUserCommand =>
            _AddUserCommand ?? (_AddUserCommand = new DelegateCommand(OnAddUser));

        private DelegateCommand _DeleteUserCommand;
        public DelegateCommand DeleteUserCommand =>
            _DeleteUserCommand ?? (_DeleteUserCommand = new DelegateCommand(OnDeleteUser));
        #endregion


        string uiConfig;
        public RoleViewModel()
        {
            string configPath = "";
            uiConfig = "";
            object obj = QueryDataClient.Instance.Service.GetData("System.ConfigType");
            var configType = (ConfigType)Convert.ToInt32(obj);
            if (configType == ConfigType.Other || configType == ConfigType.Kepler2300 || configType == ConfigType.Kepler2200)
            {
                uiConfig = "_Kepler";
            }
            else if (configType == ConfigType.VenusSE)
            {
                uiConfig = "_VenusSE";
            }
            else if (configType == ConfigType.VenusDE)
            {
                uiConfig = "_VenusDE";
            }
            //else if (configType == ConfigType.Venus)
            //{
            //    uiConfig = "_Venus";
            //}

            if (File.Exists($"Config/UIMenu{uiConfig}.json"))
            {
                configPath = $"Config/UIMenu{uiConfig}.json";
            }
            else if (File.Exists($"Config/Menu{uiConfig}.json"))
            {
                configPath = $"Config/Menu{uiConfig}.json";
            }
            else
            {
                
            }
            RoleDefines = SerializeHelper.Instance.ReadFromJsonFile<ObservableCollection<RoleDefine>>(configPath);

            for (int i = 0; i < RoleDefines.Count; i++)
            {
                Roles.Add(RoleDefines[i].RoleName);
            }

        }
        private void OnSave()
        {
            SerializeHelper.Instance.WriteToJsonFile<List<RoleDefine>>(RoleDefines.ToList(), $"Config/UIMenu{uiConfig}.json");
        }
        private void OnAddUser()
        {
            var _mainWindow = Application.Current.Windows.Cast<Window>().FirstOrDefault(window => window is Window) as Window;
            var userItem = new UserItemView();
            userItem.Show();
            userItem.Owner = _mainWindow;
            Users = new ObservableCollection<UserItem>(QueryDataClient.Instance.Service.QueryAllUsers());
        }

        private async void OnDeleteUser() 
        {
            if (SelectedUser == null)
            {
                WPFMessageBox.ShowWarning("Please Select User");
                return;
            }
            if (WPFMessageBox.ShowQuestion($"Delete User {SelectedUser.Name}?", "") == MessageBoxResult.Yes)
            {
                QueryDataClient.Instance.Service.DeleteUser(SelectedUser.Name);
                await Task.Delay(500);
                Users = new ObservableCollection<UserItem>(QueryDataClient.Instance.Service.QueryAllUsers());
            }
        }
        private void OnLoaded(Object myrecipeView)
        {
            if (firstLoad == true)
            {
                firstLoad = false;
                roleView = myrecipeView as RoleView;
                roleView.roleTreeView.SelectedItemChanged += RoleTreeView_SelectedItemChanged;

                GlobalEvents.Instance.UserViewUpdateEvent += Instance_UserViewUpdateEvent;
            }
            Users = new ObservableCollection<UserItem>(QueryDataClient.Instance.Service.QueryAllUsers());
        }

        private void Instance_UserViewUpdateEvent()
        {
            Users = new ObservableCollection<UserItem>(QueryDataClient.Instance.Service.QueryAllUsers());
        }

        private void RoleTreeView_SelectedItemChanged(object sender, System.Windows.RoutedPropertyChangedEventArgs<object> e)
        {
            int index = Roles.IndexOf(e.NewValue.ToString());
            CurrentRoleDefine = RoleDefines[index];

            vm = CollectionViewSource.GetDefaultView(CurrentRoleDefine.Menus);
            vm.GroupDescriptions.Clear();
            vm.GroupDescriptions.Add(new PropertyGroupDescription("FirstMenu"));
        }
    }
}