using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Furion.DependencyInjection;
using Microsoft.Extensions.Localization;
using Newtonsoft.Json.Linq;
using RoadFlow.Data;
using RoadFlow.Utility;


namespace RoadFlow.Data
{
    public class Dictionary : RoadFlowRepository<RoadFlow.Model.rf_dictionary>, IDictionary, ITransient
    {
        /// <summary>
        /// 值字段
        /// </summary>
        public enum ValueField
        {
            Id,
            Title,
            Code,
            Value,
            Other,
            Note
        }
    /// <summary>
    /// 得到所有下级ID
    /// </summary>
    /// <param name="id"></param>
    /// <param name="isMe">是包含自己</param>
    /// <returns></returns>
    public List<string> GetAllChildsId(string id, bool isMe = true)
        {
            List<string> guids = new();
            if (isMe)
            {
                guids.Add(id);
            }
            var allChilds = GetAllChilds(id);
            foreach (var child in allChilds)
            {
                guids.Add(child.Id);
            }
            return guids;
        }
        /// <summary>
        /// 根据ID得到所有下级
        /// </summary>
        /// <param name="id"></param>
        /// <param name="isMe">是否包含自己</param>
        /// <returns></returns>
        public List<RoadFlow.Model.rf_dictionary> GetAllChilds(string id, bool isMe = false)
        {
            List<RoadFlow.Model.rf_dictionary> dictionaries = new();
            var dict =id.IsGuid()? this.GetOneById(id):this.GetOneBy(x=>x.Code==id);
            if (null == dict)
            {
                return dictionaries;
            }
            if (isMe)
            {
                dictionaries.Add(dict);
            }
            AddChilds(dict, dictionaries);
            return dictionaries;
        }
        /// <summary>
        /// 递归添加下级
        /// </summary>
        /// <param name="dictionary"></param>
        /// <param name="dictionaries"></param>
        private void AddChilds(RoadFlow.Model.rf_dictionary dictionary, List<RoadFlow.Model.rf_dictionary> dictionaries)
        {
            var childs = GetChilds(dictionary.Id);
            if (childs.Count == 0)
            {
                return;
            }
            foreach (RoadFlow.Model.rf_dictionary child in childs)
            {
                dictionaries.Add(child);
                AddChilds(child, dictionaries);
            }
        }

        /// <summary>
        /// 根据ID得到下级
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public List<RoadFlow.Model.rf_dictionary> GetChilds(string id)
        {
            return this.GetAll().FindAll(p => p.ParentId == id.ToString()).OrderBy(p => p.Sort).ToList();
        }
        /// <summary>
        /// 根据唯一代码得到ID
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public string GetIdByCode(string code)
        {
            var dict = this.GetOneBy(a => a.Code.EqualsIgnoreCase(code));
            return null == dict ? string.Empty : dict.Id;
        }
        /// <summary>
        /// 得到字典根
        /// </summary>
        /// <returns></returns>
        public RoadFlow.Model.rf_dictionary GetRoot()
        {
            return this.GetAll().Find(p => p.ParentId == string.Empty);
        }
        /// <summary>
        /// 判断一个字典是否有下级字典
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public bool HasChilds(string id)
        {
            return this.GetAll().Exists(p => p.ParentId == id.ToString());
        }


        /// <summary>
        /// 得到多语言标题
        /// </summary>
        /// <param name="dictionary">字典实体</param>
        /// <param name="language">语言</param>
        /// <returns></returns>
        public string GetLanguageTitle(RoadFlow.Model.rf_dictionary dictionary, string language = "")
        {
            string title = string.Empty;
            if (null == dictionary)
            {
                return title;
            }
            if (language.IsNullOrWhiteSpace())
            {
                language = Tools.GetCurrentLanguage();
            }
            switch (language)
            {
                case "en-US":
                    title = dictionary.Title_en;
                    break;
                case "zh":
                    title = dictionary.Title_zh;
                    break;
                default:
                    title = dictionary.Title;
                    break;
            }
            if (title.IsNullOrWhiteSpace())
            {
                title = dictionary.Title;
            }
            return title;
        }

        /// <summary>
        /// 根据ID查询字典标题
        /// </summary>
        /// <param name="id"></param>
        /// <param name="language">语言</param>
        /// <returns></returns>
        public string GetTitle(string id, string language = "")
        {
            var dict = this.GetOneById(id);
            return null == dict ? "" : GetLanguageTitle(dict, language);
        }

        /// <summary>
        /// 按code获取字典项
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public RoadFlow.Model.rf_dictionary GetOneByCode(string code)
        {
            return code.IsNullOrWhiteSpace() ? null : this.GetAll().Find(x => x.Code.EqualsIgnoreCase(code));
        }

        /// <summary>
        /// 根据ID得到选项
        /// </summary>
        /// <param name="id"></param>
        /// <param name="valueField">值字段，默认id</param>
        /// <param name="value">默认值</param>
        /// <param name="isAllChild">是否显示所有下级</param>
        /// <param name="existsFlowType">是否包含流程分类（流程设计时选表单不能选择流程分类）</param>
        /// <returns></returns>
        public string GetOptionsByID(string id, ValueField valueField = ValueField.Id, string value = "", bool isAllChild = true, bool existsFlowType = true)
        {
            if (id.IsNullOrWhiteSpace())
            {
                return "";
            }
            var childs = isAllChild ? GetAllChilds(id) : GetChilds(id);
            StringBuilder options = new StringBuilder(childs.Count * 60);
            StringBuilder space = new StringBuilder();
            var flowChilds = existsFlowType ? new List<Model.rf_dictionary>() : GetAllChilds("system_applibrarytype_flow", true);//取出流程分类的下级，为了如果不包含流程分类时要排除
            foreach (var child in childs)
            {
                if (child.Status == 1)//标记为已删除的不作为选项
                {
                    continue;
                }
                if (!existsFlowType && flowChilds.Exists(p => p.Id == child.Id))//如果不包含流程分类要排除
                {
                    continue;
                }
                space.Clear();
                int parentCount = GetParentCount(childs, child);
                for (int i = 0; i < parentCount; i++)
                {
                    space.Append("&nbsp;&nbsp;");
                }
                if (parentCount > 0)
                {
                    space.Append("├");
                }
                string value1 = GetOptionValue(valueField, child);
                options.AppendFormat("<option value=\"{0}\"{1}>{2}{3}</option>", value1, value1.Equals(value) ? " selected=\"selected\"" : "", space.ToString(), GetLanguageTitle(child));
            }
            return options.ToString();
        }
        /// <summary>
        /// 得到一个字典项的上级节点数
        /// </summary>
        /// <param name="dictList"></param>
        /// <param name="dict"></param>
        /// <returns></returns>
        private int GetParentCount(List<Model.rf_dictionary> dictList, Model.rf_dictionary dict)
        {
            int parent = 0;
            Model.rf_dictionary parentDict = dictList.Find(p => p.Id == dict.ParentId);
            while (parentDict != null)
            {
                parentDict = dictList.Find(p => p.Id == parentDict.ParentId);
                parent++;
            }
            return parent;
        }
        /// <summary>
        /// 得到选项值
        /// </summary>
        /// <param name="valueField"></param>
        /// <param name="dictionary"></param>
        /// <returns></returns>
        private string GetOptionValue(ValueField valueField, Model.rf_dictionary dictionary)
        {
            string value = string.Empty;
            switch (valueField)
            {
                case ValueField.Id:
                    value = dictionary.Id.ToString();
                    break;
                case ValueField.Code:
                    value = dictionary.Code;
                    break;
                case ValueField.Note:
                    value = dictionary.Note;
                    break;
                case ValueField.Other:
                    value = dictionary.Other;
                    break;
                case ValueField.Title:
                    value = GetLanguageTitle(dictionary, Tools.GetCurrentLanguage());
                    break;
                case ValueField.Value:
                    value = dictionary.Value;
                    break;
            }
            return value ?? string.Empty;
        }


        /// <summary>
        /// 根据字符串得到ValueField
        /// </summary>
        /// <param name="valueField"></param>
        /// <returns></returns>
        public ValueField GetValueField(string valueField)
        {
            return valueField.IsNullOrEmpty() ? ValueField.Id : valueField switch
            {
                "code" => ValueField.Code,
                "value" => ValueField.Value,
                "title" => ValueField.Title,
                "note" => ValueField.Note,
                "other" => ValueField.Other,
                _ => ValueField.Id,
            };
        }

        /// <summary>
        /// 根据ID得到选项(返回jarray，vue项目用)
        /// </summary>
        /// <param name="id"></param>
        /// <param name="valueField">值字段，默认id</param>
        /// <param name="value">默认值</param>
        /// <param name="isAllChild">是否显示所有下级</param>
        /// <param name="isSelectParent">是否可以选择上级</param>
        /// <returns></returns>
        public JArray GetArrayOptionsByID(string id, ValueField valueField = ValueField.Id, string value = "", bool isAllChild = true, bool isSelectParent = true)
        {
            JArray jArray = new JArray();
            if (id.IsNullOrWhiteSpace())
            {
                return jArray;
            }
            string lang = Tools.GetCurrentLanguage();
            var childs = isAllChild ? GetAllChilds(id) : GetChilds(id);
            StringBuilder space = new StringBuilder();
            foreach (var child in childs)
            {
                if (child.Status == 1)//标记为已删除的不作为选项
                {
                    continue;
                }

                space.Clear();
                int parentCount = GetParentCount(childs, child);
                for (int i = 0; i < parentCount; i++)
                {
                    space.Append("&nbsp;&nbsp;&nbsp;&nbsp;");
                }
                if (parentCount > 0)
                {
                    space.Append("├");
                }
                string value1 = GetOptionValue(valueField, child);
                jArray.Add(new JObject() {
                    { "value", value1 },
                    { "title",  space.ToString() + GetLanguageTitle(child, lang) },
                    { "selected", value1.EqualsIgnoreCase(value) },

                });
            }
            return jArray;
        }


        /// <summary>
        /// 根据ID得到所有下级(控件选项)
        /// </summary>
        /// <param name="id">根节点字典id</param>
        /// <param name="valueField">值字段</param>
        /// <param name="isRoot">是否显示根节点</param>
        /// <param name="lang">标题语言</param>
        /// <returns></returns>
        public JArray GetAllChildsArray(string id, ValueField valueField, bool isRoot = false, string lang = "")
        {
            var childs = GetChilds(id);
            JArray jArray = new JArray();
            foreach (Model.rf_dictionary child in childs)
            {
                JObject jObject = child.ToJObject();
                jObject.Add("Value1", child.Value);
                jObject.Remove("Value");
                jObject.Add("value", GetOptionValue(valueField, child));
                jObject.Add("label", GetLanguageTitle(child, lang));
                jArray.Add(jObject);
                AddChildsArray(child, jObject, valueField, lang);
            }
            JArray jArray1;
            if (isRoot)
            {
                var rootDict = GetOneById(id);
                if (null == rootDict)
                {
                    return new JArray();
                }
                JObject rootObj = rootDict.ToJObject();
                rootObj.Add("Value1", rootDict.Value);
                rootObj.Add("value", GetOptionValue(valueField, rootDict));
                rootObj.Add("label", GetLanguageTitle(rootDict, lang));
                rootObj.Add("children", jArray);
                rootObj.Add("isLeaf", jArray.Count == 0);
                rootObj.Add("slots", new JObject() { { "icon", "custom" } });
                jArray1 = new JArray() { rootObj };
            }
            else
            {
                jArray1 = jArray;
            }
            return jArray1;
        }

        /// <summary>
        /// 递归添加下级(控件选项)
        /// </summary>
        /// <param name="dictionary"></param>
        /// <param name="dictionaries"></param>
        private void AddChildsArray(Model.rf_dictionary dictionary, JObject jObject, ValueField valueField, string lang = "")
        {
            var childs = GetChilds(dictionary.Id);
            if (childs.Count == 0)
            {
                jObject.Add("isLeaf", true);
                jObject.Add("slots", new JObject() { { "icon", "custom" } });
                return;
            }
            JArray jArray = new JArray();
            jObject.Add("children", jArray);
            jObject.Add("isLeaf", false);
            jObject.Add("slots", new JObject() { { "icon", "custom" } });
            foreach (Model.rf_dictionary child in childs)
            {
                JObject jObject1 = child.ToJObject();
                jObject1.Add("Value1", child.Value);
                jObject1.Remove("Value");
                jObject1.Add("value", GetOptionValue(valueField, child));
                jObject1.Add("label", GetLanguageTitle(child, lang));
                jArray.Add(jObject1);
                AddChildsArray(child, jObject1, valueField, lang);
            }
        }


        /// <summary>
        /// 根据ID得到选项(返回jarray，vue项目用)
        /// </summary>
        /// <param name="id"></param>
        /// <param name="valueField">值字段，默认id</param>
        /// <param name="value">默认值</param>
        /// <param name="isAllChild">是否显示所有下级</param>
        /// <param name="isSelectParent">是否可以选择上级</param>
        /// <returns></returns>
        public JArray GetArrayComboxsByID(string id, ValueField valueField = ValueField.Id, string value = "", bool isAllChild = true, bool isSelectParent = true)
        {
            JArray jArray = new JArray();
            if (id.IsNullOrWhiteSpace())
            {
                return jArray;
            }
            var childs = isAllChild ? GetAllChilds(id) : GetChilds(id);
            string lang = Tools.GetCurrentLanguage();
            foreach (var child in childs)
            {
                if (child.Status == 1)//标记为已删除的不作为选项
                {
                    continue;
                }

                int parentCount = GetParentCount(childs, child);
                string value1 = GetOptionValue(valueField, child);
                jArray.Add(new JObject() {
                    { "value", value1 },
                    { "title", GetLanguageTitle(child, lang)},
                    { "selected", value1.EqualsIgnoreCase(value) },
                    { "parentCount", parentCount },
                    { "group", !isSelectParent && childs.Exists(p=>p.ParentId == child.Id) },
                });
            }
            return jArray;
        }

        /// <summary>
        /// 得到单选或复选按钮组选项
        /// </summary>
        /// <param name="id"></param>
        /// <param name="valueField">值字段</param>
        /// <returns></returns>
        public JArray GetRadioOrCheckboxItems(string id, ValueField valueField = ValueField.Id)
        {
            JArray jArray = new JArray();
            if (id.IsNullOrWhiteSpace())
            {
                return jArray;
            }
            var childs = GetChilds(id);
            string lang = Tools.GetCurrentLanguage();
            foreach (var child in childs)
            {
                if (child.Status == 1)
                {
                    continue;
                }
                string value1 = GetOptionValue(valueField, child);
                jArray.Add(new JObject() {
                    { "value", value1 },
                    { "title", GetLanguageTitle(child, lang) },
                });
            }
            return jArray;
        }

        /// <summary>
        /// 得到一个字典下级的最大排序号
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public int GetMaxSort(string id)
        {
            var childs = GetChilds(id);
            return childs.Count == 0 ? 5 : childs.Max(p => p.Sort) + 5;
        }
        /// <summary>
        /// 检查唯一代码是否重复
        /// </summary>
        /// <param name="id"></param>
        /// <param name="code"></param>
        /// <returns>true 没有重复 false 重复</returns>
        public bool CheckCode(string id, string code)
        {
            var dict = GetOneById(code);
            return null == dict ? true : dict.Id == id;
        }

        /// <summary>
        /// 得到字典根ID
        /// </summary>
        /// <returns></returns>
        public string GetRootId()
        {
            var root = GetRoot();
            return null == root ? string.Empty : root.Id;
        }

        /// <summary>
        /// 导入数据字典
        /// </summary>
        /// <param name="json"></param>
        /// <param name="localizer">语言包</param>
        public string Import(string json, IStringLocalizer localizer = null)
        {
            if (json.IsNullOrWhiteSpace())
            {
                return localizer == null ? "要导入的json为空！" : localizer["ImportJsonEmpty"].Value;
            }
            Newtonsoft.Json.Linq.JArray jArray = null;
            try
            {
                jArray = Newtonsoft.Json.Linq.JArray.Parse(json);
            }
            catch
            {
                jArray = null;
            }
            if (null == jArray)
            {
                return localizer == null ? "json解析错误！" : localizer["JsonParseError"].Value;
            }
            StringBuilder stringBuilder = new StringBuilder();
            foreach (Newtonsoft.Json.Linq.JObject jObject in jArray)
            {
                try
                {
                    Model.rf_dictionary dictionaryModel = jObject.ToObject<Model.rf_dictionary>();
                    if (null == dictionaryModel)
                    {
                        continue;
                    }
                    if (GetOneById(dictionaryModel.Id) != null)
                    {
                        Update(dictionaryModel);
                    }
                    else
                    {
                        Add(dictionaryModel);
                    }
                }
                catch (Exception err)
                {
                    stringBuilder.Append(err.Message + "；");
                    new Log().Add(err);
                }
            }
            return stringBuilder.Length == 0 ? "1" : stringBuilder.ToString();
        }
    }
}