using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using Aitex.Core.RT.Log;
using MECF.Framework.Common.Account.Extends;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.UI.Client.CenterViews.Editors;
using MECF.Framework.UI.Client.ClientBase;
using MECF.Framework.UI.Client.RecipeEditorLib.RecipeModel;

namespace MECF.Framework.UI.Client.CenterViews.Configs.Roles
{
    public class RoleManager
    {
        public RoleManager()
        {

        }

        private readonly RecipeFormatBuilder _recipeBuilder = new RecipeFormatBuilder();

        public ObservableCollection<string> ChamberType { get; set; }

        public ObservableCollection<ProcessTypeFileItem> ProcessTypeFileList { get; set; }

        public bool Initialize()
        {
            _RoleContainer.Clear();
            List<Common.Account.Extends.Role> roles = RoleAccountProvider.Instance.GetRoles();
            if (roles == null)
            {
                LOG.Error("GetRoles method failed,in RoleManager");
                return false;
            }

            List<AppMenu> menus = BaseApp.Instance.MenuLoader.MenuList;
            this._listMenuItems = menus;
            if (menus == null)
            {
                LOG.Error("GetMenus method failed,in RoleManager");
                return false;
            }

            //每个Role下再挂一个Recipe权限
            //Recipe名称从RecipeFormat文件中获取
            var chamberType = QueryDataClient.Instance.Service.GetConfig("System.Recipe.SupportedChamberType");
            if (chamberType == null)
            {
                ChamberType = new ObservableCollection<string>() { "Default" };
            }
            else
            {
                ChamberType = new ObservableCollection<string>(((string)(chamberType)).Split(','));
            }

            var processType = QueryDataClient.Instance.Service.GetConfig("System.Recipe.SupportedProcessType");
            if (processType == null)
            {
                processType = "Process,Routine";
            }

            ProcessTypeFileList = new ObservableCollection<ProcessTypeFileItem>();
            string[] recipeProcessType = ((string)processType).Split(',');

            _recipeInfos = _recipeBuilder.GetRecipeColumnName($"{ChamberType[0]}\\{recipeProcessType[0]}", "PM1");

            _stepInfos = _recipeBuilder.GetRecipeStepNo();

            _permissionInfos = _recipeBuilder.GetContentName($"{ChamberType[0]}\\Content", "PM1");

            foreach (Common.Account.Extends.Role r in roles)
            {
                RoleItem role = new RoleItem(r);
                role.DisplayRoleName = role.RoleName;
                role.DisplayAutoLogoutTime = role.AutoLogoutTime;
                role.DisplayIsAutoLogout = role.IsAutoLogout;
                role.DisplayDescription = role.Description;

                //Parse menu permission
                MenuPermission menuPermissionParse = new MenuPermission();
                menuPermissionParse.ParsePermission(r.MenuPermission);

                MenuInfo mp = new MenuInfo() { ID = "Header" };
                mp.Name = "Header";
                mp.EnumPermission = menuPermissionParse.GetPermissionByPageID("Header");
                role.AddMenuInfo(mp);

                //Get Menu information
                foreach (AppMenu topMenuItem in menus)
                {
                    foreach (AppMenu subMenuItem in topMenuItem.MenuItems)
                    {
                        mp = new MenuInfo() { ID = subMenuItem.MenuID };
                        mp.Name = topMenuItem.ResKey + "." + subMenuItem.ResKey; //Application.Current.FindResource(subMenuItem.ResKey) as string;
                        mp.EnumPermission = menuPermissionParse.GetPermissionByPageID(subMenuItem.MenuID);
                        role.AddMenuInfo(mp);
                    }
                }

                RecipeInfo recipe;

                foreach (RecipeInfo recipeInfo in _recipeInfos)
                {
                    //需要去掉空格
                    recipe = new RecipeInfo();
                    recipe.Name = recipeInfo.Name;
                    recipeInfo.Name = recipeInfo.Name.Replace(" ", "");
                    recipe.EnumPermission = menuPermissionParse.GetPermissionByPageID(recipeInfo.Name);
                    role.AddRecipeInfo(recipe);
                }

                StepInfo step;

                foreach (StepInfo stepInfo in _stepInfos)
                {
                    //需要去掉空格
                    step = new StepInfo();
                    step.Name = stepInfo.Name;
                    stepInfo.Name = stepInfo.Name.Replace(" ", "");
                    step.EnumPermission = menuPermissionParse.GetPermissionByPageID(stepInfo.Name);
                    role.AddStepInfo(step);
                }

                ContentInfo content;

                foreach (ContentInfo contentInfo in _permissionInfos)
                {
                    content = new ContentInfo();
                    content.Name = contentInfo.Name;
                    content.EnumPermission = menuPermissionParse.GetPermissionByPageID(contentInfo.Name);
                    role.AddContentInfo(content);
                }

                _RoleContainer.Add(role);
            }
            return true;
        }

        public List<RoleItem> GetAllRoles()
        {
            return _RoleContainer.ToList();
        }

        public bool AddRole(RoleItem r)
        {
            RoleItem existRole = GetRoleByName(r.RoleName);
            if (existRole != null)
            {
                LOG.Info("the role already exists, in RoleManager");
                return false;
            }
            existRole = GetRoleByID(r.RoleID);
            if (existRole != null)
            {
                LOG.Info("the role already exists, in RoleManager");
                return false;
            }
            _RoleContainer.Add(r);

            return true;
        }

        public string GenerateRoleID()
        {
            RoleItem r = GetRoleByID(_RoleNum.ToString());
            while (r != null)
            {
                _RoleNum++;
                r = GetRoleByID(_RoleNum.ToString());
            }

            return _RoleNum.ToString();
        }

        public RoleItem GetRoleByID(string ID)
        {
            return _RoleContainer.FirstOrDefault(t => t.RoleID == ID);
        }

        public RoleItem GetRoleByName(string name)
        {
            return _RoleContainer.FirstOrDefault(t => t.RoleName == name);
        }

        public RoleItem CreateRole()
        {
            RoleItem r = new RoleItem(GenerateRoleID());

            r.DisplayRoleName = r.RoleName = string.Empty;
            r.DisplayAutoLogoutTime = r.AutoLogoutTime = 10;
            r.DisplayIsAutoLogout = r.IsAutoLogout = false;
            r.DisplayDescription = r.Description = string.Empty;

            r.MenuCollection.Add(new MenuInfo() { ID = "Header", Name = "Header", EnumPermission = MenuPermissionEnum.MP_NONE });

            foreach (AppMenu topMenuItem in _listMenuItems)
            {
                foreach (AppMenu subMenuItem in topMenuItem.MenuItems)
                {
                    MenuInfo mp = new MenuInfo()
                    {
                        ID = subMenuItem.MenuID,
                        Name = topMenuItem.ResKey + "." + subMenuItem.ResKey, //Application.Current.FindResource(subMenuItem.ResKey) as string,
                        EnumPermission = MenuPermissionEnum.MP_NONE
                    };

                    r.MenuCollection.Add(mp);
                }
            }

            foreach (RecipeInfo recipeInfo in _recipeInfos)
            {
                RecipeInfo recipe = new RecipeInfo()
                {
                    Name = recipeInfo.Name,
                    EnumPermission = MenuPermissionEnum.MP_NONE
                };
                r.AddRecipeInfo(recipe);
            }

            foreach (StepInfo sInfo in _stepInfos)
            {
                StepInfo step = new StepInfo()
                {
                    Name = sInfo.Name,
                    EnumPermission = MenuPermissionEnum.MP_NONE
                };
                r.AddStepInfo(step);
            }

            foreach (ContentInfo permissionInfo in _permissionInfos)
            {
                ContentInfo permission = new ContentInfo()
                {
                    Name = permissionInfo.Name,
                    EnumPermission = MenuPermissionEnum.MP_NONE
                };
                r.AddContentInfo(permission);
            }

            return r;
        }

        public RoleItem CreateRole(RoleItem role)
        {
            RoleItem newRole = new RoleItem(GenerateRoleID())
            {
                RoleName = role.RoleName,
                AutoLogoutTime = role.AutoLogoutTime,
                IsAutoLogout = role.IsAutoLogout,
                Description = role.Description,
                DisplayRoleName = role.DisplayRoleName,
                DisplayAutoLogoutTime = role.DisplayAutoLogoutTime,
                DisplayIsAutoLogout = role.DisplayIsAutoLogout,
                DisplayDescription = role.DisplayDescription
            };

            foreach (MenuInfo mInfo in role.MenuCollection)
            {
                newRole.AddMenuInfo(mInfo.Clone());
            }

            foreach (RecipeInfo rInfo in role.RecipeCollection)
            {
                newRole.AddRecipeInfo(rInfo.Clone());
            }

            foreach (StepInfo sInfo in role.RecipeStepCollection)
            {
                newRole.AddStepInfo(sInfo.Clone());
            }

            foreach (ContentInfo pInfo in role.ContentCollection)
            {
                newRole.AddContentInfo(pInfo.Clone());
            }

            return newRole;
        }

        public RoleItem CloneRole(RoleItem role)
        {
            RoleItem newRole = new RoleItem(role.RoleID)
            {
                RoleName = role.RoleName,
                AutoLogoutTime = role.AutoLogoutTime,
                IsAutoLogout = role.IsAutoLogout,
                Description = role.Description,
                DisplayRoleName = role.DisplayRoleName,
                DisplayAutoLogoutTime = role.DisplayAutoLogoutTime,
                DisplayIsAutoLogout = role.DisplayIsAutoLogout,
                DisplayDescription = role.DisplayDescription
            };

            foreach (MenuInfo mInfo in role.MenuCollection)
            {
                newRole.AddMenuInfo(mInfo.Clone());
            }

            foreach (RecipeInfo rInfo in role.RecipeCollection)
            {
                newRole.AddRecipeInfo(rInfo.Clone());
            }

            foreach (StepInfo sInfo in role.RecipeStepCollection)
            {
                newRole.AddStepInfo(sInfo.Clone());
            }

            foreach (ContentInfo pInfo in role.ContentCollection)
            {
                newRole.AddContentInfo(pInfo.Clone());
            }

            return newRole;
        }

        public RoleItem CloneRole(string strRoleID)
        {
            RoleItem orignalRole = GetRoleByID(strRoleID);
            if (null == orignalRole)
                return null;

            RoleItem newRole = new RoleItem(strRoleID)
            {
                AutoLogoutTime = orignalRole.AutoLogoutTime,
                IsAutoLogout = orignalRole.IsAutoLogout,
                RoleName = orignalRole.RoleName,
                Description = orignalRole.Description,
                DisplayRoleName = orignalRole.DisplayRoleName,
                DisplayAutoLogoutTime = orignalRole.DisplayAutoLogoutTime,
                DisplayIsAutoLogout = orignalRole.DisplayIsAutoLogout,
                DisplayDescription = orignalRole.DisplayDescription
            };

            foreach (MenuInfo mInfo in orignalRole.MenuCollection)
            {
                newRole.AddMenuInfo(mInfo.Clone());
            }

            foreach (RecipeInfo rInfo in orignalRole.RecipeCollection)
            {
                newRole.AddRecipeInfo(rInfo.Clone());
            }

            foreach (ContentInfo pInfo in orignalRole.ContentCollection)
            {
                newRole.AddContentInfo(pInfo.Clone());
            }

            foreach (StepInfo sInfo in orignalRole.RecipeStepCollection)
            {
                newRole.AddStepInfo(sInfo.Clone());
            }

            return newRole;
        }

        public bool CheckAvailable(RoleItem role)
        {
            if (role == null)
                return false;

            foreach (RoleItem r in _RoleContainer)
            {
                if (role.RoleName == r.RoleName && role.RoleID != r.RoleID)
                {
                    LOG.Info("Check account available fail because the name already exists, in RoleManager");
                    return false;
                }
            }

            return true;
        }

        public bool SaveRole(RoleItem pRoletoSave)
        {
            if (!CheckAvailable(pRoletoSave))
                return false;


            Common.Account.Extends.Role r = new Common.Account.Extends.Role(
                pRoletoSave.RoleID,
                pRoletoSave.RoleName,
                pRoletoSave.IsAutoLogout,
                pRoletoSave.AutoLogoutTime,
                MenuPermission.PermissionToString(pRoletoSave.MenuCollection, pRoletoSave.RecipeCollection,
                pRoletoSave.ContentCollection,pRoletoSave.RecipeStepCollection),
                pRoletoSave.Description
                );

            if (RoleAccountProvider.Instance.UpdateRole(r))
            {
                RoleItem orignalRole = GetRoleByID(pRoletoSave.RoleID);
                if (null == orignalRole)
                {
                    RoleItem NewRole = CloneRole(pRoletoSave);
                    AddRole(NewRole);
                    return true;
                }

                orignalRole.RoleName = pRoletoSave.RoleName;
                orignalRole.IsAutoLogout = pRoletoSave.IsAutoLogout;
                orignalRole.AutoLogoutTime = pRoletoSave.AutoLogoutTime;
                orignalRole.Description = pRoletoSave.Description;
                orignalRole.MenuCollection.Clear();
                foreach (MenuInfo mInfo in pRoletoSave.MenuCollection)
                {
                    orignalRole.AddMenuInfo(mInfo.Clone());
                    mInfo.ComboBoxSaved = true;
                }

                foreach (RecipeInfo rInfo in pRoletoSave.RecipeCollection)
                {
                    orignalRole.AddRecipeInfo(rInfo.Clone());
                    rInfo.ComboBoxSaved = true;
                }

                foreach (ContentInfo pInfo in pRoletoSave.ContentCollection)
                {
                    orignalRole.AddContentInfo(pInfo.Clone());
                    pInfo.ComboBoxSaved = true;
                }

                foreach (StepInfo sInfo in pRoletoSave.RecipeStepCollection)
                {
                    orignalRole.AddStepInfo(sInfo.Clone());
                    sInfo.ComboBoxSaved = true;
                }
            }
            else
            {
                LOG.Error("UpdateRoles method failed, in RoleManager");
                return false;
            }

            return true;
        }

        public bool DeleteRole(string strRoleID)
        {
            RoleItem r = GetRoleByID(strRoleID);
            if (r != null)
            {
                if (RoleAccountProvider.Instance.DeleteRole(strRoleID))
                {
                    _RoleContainer.Remove(r);
                    return true;
                }
                else
                {
                    LOG.Error("DeleteRole method failed, in RoleManager");
                }
            }
            else
            {
                LOG.Warning("Can not find the role to delete, in RoleManager");
            }

            return false;
        }


        private static RoleManager _Instance = null;
        public static RoleManager Instance
        {
            get
            {
                if (_Instance == null)
                {
                    _Instance = new RoleManager();
                }

                return _Instance;
            }
        }

        private ObservableCollection<RoleItem> _RoleContainer = new ObservableCollection<RoleItem>();
        public ObservableCollection<RoleItem> RoleContainer
        {
            get { return _RoleContainer; }
        }

        private static int _RoleNum = 0;
        private List<AppMenu> _listMenuItems = null;
        private ObservableCollection<RecipeInfo> _recipeInfos = null;
        private ObservableCollection<StepInfo> _stepInfos = null;
        private ObservableCollection<ContentInfo> _permissionInfos = null;
    }

    public class MenuPermission
    {
        public void ParsePermission(string strPermission)
        {
            try
            {
                strPermission = strPermission.Replace("\n", "").Replace(" ", "");
                int groupIndex = strPermission.IndexOf(';');
                if (groupIndex == -1)
                {
                    AddToDictionary(strPermission);
                    return;
                }

                string strGroup = strPermission.Substring(0, groupIndex);
                AddToDictionary(strGroup);

                ParsePermission(strPermission.Substring(groupIndex + 1));

            }
            catch (System.Exception ex)
            {
                LOG.Write(ex);
            }
        }

        public MenuPermissionEnum GetPermissionByPageID(string strPageID)
        {
            if (MenuPermissionDictionary.ContainsKey(strPageID))
            {
                return MenuPermissionDictionary[strPageID];
            }

            return MenuPermissionEnum.MP_NONE;
        }

        public static string PermissionToString(ObservableCollection<MenuInfo> listPermission, 
            ObservableCollection<RecipeInfo> recipeListPermission, ObservableCollection<ContentInfo> permissionListPermission,
            ObservableCollection<StepInfo> recipeStepPermission)
        {
            string strResult = "";

            if (listPermission == null)
                return strResult;

            foreach (MenuInfo info in listPermission)
            {
                strResult += info.ID;
                strResult += ",";
                strResult += info.IndexPermission;
                strResult += ";";
            }

            foreach (RecipeInfo info in recipeListPermission)
            {
                strResult += info.Name;
                strResult += ",";
                strResult += info.IndexPermission;
                strResult += ";";
            }

            foreach (ContentInfo info in permissionListPermission)
            {
                strResult += info.Name;
                strResult += ",";
                strResult += info.IndexPermission;
                strResult += ";";
            }

            foreach (StepInfo info in recipeStepPermission)
            {
                strResult += info.Name;
                strResult += ",";
                strResult += info.IndexPermission;
                strResult += ";";
            }

            return strResult;
        }

        private void AddToDictionary(string strGroupName)
        {
            int Index = strGroupName.IndexOf(',');
            if (Index == -1)
                return;

            string strMenuID = strGroupName.Substring(0, Index);
            string strMenuPermision = strGroupName.Substring(Index + 1);

            MenuPermissionDictionary.Add(strMenuID, (MenuPermissionEnum)Convert.ToInt32(strMenuPermision));
        }

        public MenuPermissionEnum this[string strPageID]
        {
            get
            {
                return GetPermissionByPageID(strPageID);
            }

        }

        private Dictionary<string, MenuPermissionEnum> _dicPermission = new Dictionary<string, MenuPermissionEnum>();
        public Dictionary<string, MenuPermissionEnum> MenuPermissionDictionary
        {
            get { return _dicPermission; }
        }
    }
}