using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Xml.Linq;
using System.Xml.Serialization;
using WorkData;

namespace DQ.Construction.NewLook.DataTemplate
{
    /// <summary>
    /// DataTemplateManager
    /// </summary>
    public static class DataTemplateConfigManager
    {
        static DataTemplateConfigManager()
        {
            InitDataTemplate();

            LoadTemplate();
        }

        /// <summary>
        /// 当前模板
        /// </summary>
        public static DataTemplateConfig Current { get; private set; }

        /// <summary>
        /// 新建模板
        /// </summary>
        /// <param name="template">template</param>
        public static void NewTemplate(string template)
        {
            InitDataTemplate(template);

            ToggleTemplate(template);
        }

        /// <summary>
        /// 删除模板
        /// </summary>
        /// <param name="template">template</param>
        public static void DeleteTemplate(string template)
        {
            string path = FileHelp.GetDataTemplateFile(template, string.Empty);
            Directory.Delete(path, true);
        }

        /// <summary>
        /// 创建DataTemplate目录
        /// </summary>
        public static void InitDataTemplate()
        {
            try
            {
                InitDataTemplate(WorkConfig.Data.DataTemplate);
            }
            finally { }
        }

        /// <summary>
        /// 创建DataTemplate目录
        /// </summary>
        /// <param name="template">模板</param>
        public static void InitDataTemplate(string template)
        {
            template = string.IsNullOrWhiteSpace(template) ? "Default" : template;

            string configFile = FileHelp.GetDataTemplateFile(template, $"default.config");

            XDocument docConfig;

            try
            {
                docConfig = XDocument.Parse(File.ReadAllText(configFile));
            }
            catch (Exception)
            {
                docConfig = new XDocument(new XElement("Config"));
            }

            foreach (SqlSugar.EntityInfo item in EntityHelp.AllEntity)
            {
                try
                {
                    if (item.TableDescription == null || item.TableDescription.StartsWith("Class "))
                    {
                        continue;
                    }

                    string templateFile = FileHelp.GetDataTemplateFile(template, $"_default.{item.TableDescription}");

                    if (!File.Exists(templateFile))
                    {
                        XDocument docTable = new XDocument(new XElement("Config"));

                        foreach (SqlSugar.EntityColumnInfo col in item.Columns)
                        {
                            if (col.ColumnDescription == null || col.ColumnDescription.StartsWith("Gets ") || col.PropertyName == "Unique")
                            {
                                continue;
                            }

                            docTable.Root.Add(new XElement(
                                "Entry",
                                new XAttribute("From", col.ColumnDescription),
                                new XAttribute("TO", col.ColumnDescription)));
                        }

                        docTable.Save(templateFile);
                    }

                    bool bExist = docConfig.Root.Elements("Template").Any(o => o.Attribute("Table").Value == item.TableDescription);

                    if (!bExist)
                    {
                        docConfig.Root.Add(new XElement(
                            "Template",
                            new XAttribute("Table", item.TableDescription),
                            new XAttribute("Link", item.TableDescription),
                            new XAttribute("Last", Path.GetFileName(templateFile))));
                    }
                }
                catch (Exception)
                {
                    // ignore
                }
            }

            using (Stream stream = File.Create(configFile))
            {
                docConfig.Save(stream);
            }
        }

        /// <summary>
        /// 切换模板
        /// </summary>
        /// <param name="template">template</param>
        public static void ToggleTemplate(string template)
        {
            WorkConfig.Data.DataTemplate = template;
            WorkConfig.SaveData();

            LoadTemplate();
        }

        /// <summary>
        /// 加载模板
        /// </summary>
        public static void LoadTemplate()
        {
            Current = LoadForm(FileHelp.GetDataTemplateFile($"default.config"));
        }

        /// <summary>
        /// 保存模板
        /// </summary>
        public static void SaveTemplate()
        {
            SaveTo(FileHelp.GetDataTemplateFile($"default.config"), Current);
        }

        /// <summary>
        /// 加载模板
        /// </summary>
        /// <param name="path">path</param>
        /// <returns>config</returns>
        internal static DataTemplateConfig LoadForm(string path)
        {
            try
            {
                using (var stream = File.OpenRead(path))
                {
                    XmlSerializer xmlSearializer = new XmlSerializer(typeof(DataTemplateConfig));
                    return (DataTemplateConfig)xmlSearializer.Deserialize(stream);
                }
            }
            catch (Exception)
            {
            }

            return null;
        }

        /// <summary>
        /// 保存模板
        /// </summary>
        /// <param name="path">path</param>
        /// <param name="config">config</param>
        internal static void SaveTo(string path, DataTemplateConfig config)
        {
            string strSolutionPath = AppDomain.CurrentDomain.BaseDirectory;

            if (!Directory.Exists(strSolutionPath))
            {
                Directory.CreateDirectory(strSolutionPath);
            }

            try
            {
                using (var sw = new StreamWriter(path))
                {
                    // 创建XML命名空间
                    XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                    ns.Add(string.Empty, string.Empty);
                    XmlSerializer serializer = new XmlSerializer(typeof(DataTemplateConfig));
                    serializer.Serialize(sw, config, ns);
                }
            }
            catch (Exception)
            {
            }
        }

        /// <summary>
        /// 读取模板列表
        /// </summary>
        /// <param name="desc">模板类型</param>
        /// <returns>模板列表</returns>
        internal static IEnumerable<string> EnumerateTemplate(string desc)
        {
            string dir = FileHelp.GetDataTemplateFile();

            foreach (string item in Directory.EnumerateFiles(dir, $"*.{desc}"))
            {
                yield return Path.GetFileName(item);
            }
        }
    }
}