using Abp.Logging;

using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml;

namespace VberZero.Tools.FileHelpers;

public static class XmlHelper
{
    /// <summary>
    /// XML转换成DataTable
    /// </summary>
    /// <param name="xmlDS"></param>
    /// <returns></returns>
    public static string ConvertDataTableToXML(this DataTable xmlDS)
    {
        XmlTextWriter writer = null;
        try
        {
            var stream = new MemoryStream();
            writer = new XmlTextWriter(stream, Encoding.UTF8);
            xmlDS.WriteXml(writer);
            int count = (int)stream.Length;
            byte[] arr = new byte[count];
            stream.Seek(0, SeekOrigin.Begin);
            stream.Read(arr, 0, count);
            UTF8Encoding utf = new UTF8Encoding();

            return utf.GetString(arr).Trim();
        }
        catch (Exception e)
        {
            LogHelper.LogException(e);
            return "";
        }
        finally
        {
            writer?.Close();
        }
    }

    /// <summary>
    /// XML转换成DataTable
    /// </summary>
    /// <param name="xmlData"></param>
    /// <returns></returns>
    public static DataSet ConvertXMLToDataSet(this string xmlData)
    {
        XmlTextReader reader = null;
        try
        {
            DataSet xmlDS = new DataSet();
            var stream = new StringReader(xmlData);
            reader = new XmlTextReader(stream);
            xmlDS.ReadXml(reader);
            return xmlDS;
        }
        catch (Exception e)
        {
            LogHelper.LogException(e);
            return null;
        }
        finally
        {
            reader?.Close();
        }
    }
}

/// <summary>
/// Object mapping of a xml file
/// </summary>
public class XModel
{
    /// <summary>
    /// Directory of this xml file
    /// </summary>
    public string XmlDirectory { get; set; }

    /// <summary>
    /// Xml file name
    /// </summary>
    public string FileName { get; set; }

    /// <summary>
    /// Xml file encode
    /// </summary>
    public string Encode { get; set; }

    /// <summary>
    /// Root tag
    /// </summary>
    public XmlTag Root { get; set; }

    /// <summary>
    /// XmlDocument object of this xml file
    /// </summary>
    private XmlDocument XmlDoc { get; set; }

    #region constructor

    /// <summary>
    /// Default constructor
    /// </summary>
    public XModel()
    {
    }

    /// <summary>
    /// Constructor: Create XmlModel from XmlTag and save xml file
    /// </summary>
    /// <param name="directory">directory</param>
    /// <param name="fileName">fileName</param>
    /// <param name="encode">encode type</param>
    /// <param name="root">root tag</param>
    public XModel(string directory, string fileName, string encode, XmlTag root)
    {
        CreateWithFile(directory, fileName, encode, root);
    }

    /// <summary>
    /// Constructor: Create XmlModel from XmlTag only
    /// </summary>
    /// <param name="root">root tag</param>
    public XModel(XmlTag root)
    {
        CreateWithOutFile(root);
    }

    /// <summary>
    /// Constructor: Read XmlModel From xml file
    /// </summary>
    /// <param name="directory">directory</param>
    /// <param name="fileName">fileName</param>
    public XModel(string directory, string fileName)
    {
        Read(directory, fileName);
    }

    /// <summary>
    /// Constructor: Read XmlModel From xml string
    /// </summary>
    /// <param name="xml">xml string</param>
    public XModel(string xml)
    {
        Read(xml);
    }

    #endregion constructor

    #region Create and Read XmlModel

    /// <summary>
    /// Create XmlModel from XmlTag and save xml file
    /// </summary>
    /// <param name="directory">directory</param>
    /// <param name="fileName">fileName</param>
    /// <param name="encode">encode type</param>
    /// <param name="root">root tag</param>
    public void CreateWithFile(string directory, string fileName, string encode, XmlTag root)
    {
        XmlDirectory = directory;
        FileName = fileName;
        Encode = encode;
        Root = root;
        Save();
    }

    /// <summary>
    /// Create XmlModel from XmlTag only
    /// </summary>
    /// <param name="root"></param>
    public void CreateWithOutFile(XmlTag root)
    {
        Root = root;
    }

    /// <summary>
    /// Read XmlModel From xml file
    /// </summary>
    /// <param name="directory">directory</param>
    /// <param name="fileName">fileName</param>
    public void Read(string directory, string fileName)
    {
        XmlDirectory = directory;
        FileName = fileName;
        XmlDoc = new XmlDocument();
        XmlDoc.Load(directory + fileName);
        Root = NodeToTag(XmlDoc.DocumentElement);
    }

    /// <summary>
    /// Read XmlModel From xml string
    /// </summary>
    /// <param name="xml">xml string</param>
    public void Read(string xml)
    {
        XmlDoc = new XmlDocument();
        XmlDoc.LoadXml(xml);
        Root = NodeToTag(XmlDoc.DocumentElement);
    }

    #endregion Create and Read XmlModel

    /// <summary>
    /// Get current XmlModel's XmlDocument type object
    /// </summary>
    /// <returns></returns>
    public XmlDocument GetXmlDocument()
    {
        //create XmlModel xmldoc is null
        if (XmlDoc == null)
        {
            XmlDoc = new XmlDocument();
        }
        //replace root
        if (XmlDoc.DocumentElement != null)
        {
            XmlDoc.RemoveChild(XmlDoc.DocumentElement);
        }
        XmlDoc.AppendChild(TagToNode(Root));
        //add or edit declaration
        if (XmlDoc.FirstChild is XmlDeclaration declaration)
        {
            if (!string.IsNullOrEmpty(Encode))
            {
                declaration.Encoding = Encode;
            }
        }
        else
        {
            if (string.IsNullOrEmpty(Encode))
            {
                throw new Exception("Encode can't be empty");
            }
            XmlDoc.InsertBefore(XmlDoc.CreateXmlDeclaration("1.0", Encode, ""), XmlDoc.FirstChild);
        }
        return XmlDoc;
    }

    /// <summary>
    /// Save Object to file
    /// XmlDirectory and FileName and Encode need to be set before save
    /// </summary>
    public void Save()
    {
        if (Root == null)
        {
            throw new Exception("Root can't be null");
        }
        if (string.IsNullOrEmpty(XmlDirectory) || string.IsNullOrEmpty(FileName))
        {
            throw new Exception("XmlDirectory and FileName need to be set before save");
        }
        //generate xmldocument
        GetXmlDocument();
        if (!Directory.Exists(XmlDirectory))
        {
            Directory.CreateDirectory(XmlDirectory);
        }
        XmlDoc.Save(XmlDirectory + FileName);
    }

    /// <summary>
    /// Delete file
    /// </summary>
    public void Delete()
    {
        if (File.Exists(XmlDirectory + FileName))
        {
            File.Delete(XmlDirectory + FileName);
        }
    }

    /// <summary>
    /// Get xml string
    /// </summary>
    /// <returns></returns>
    public override string ToString()
    {
        return GetXmlDocument().OuterXml;
    }

    #region Helper

    /// <summary>
    /// Recurtion transfer XmlNode into XmlTag
    /// </summary>
    /// <param name="node">XmlNode</param>
    /// <returns></returns>
    public XmlTag NodeToTag(XmlNode node)
    {
        //不转化注释
        for (int i = 0; i < node.ChildNodes.Count; i++)
        {
            if (node.ChildNodes[i].Name == ("#comment"))
            {
                node.RemoveChild(node.ChildNodes[i]);
            }
        }
        //判断当前节点类型返回对应类型节点
        if (node.ChildNodes.Count > 0 && node.FirstChild.NodeType != XmlNodeType.Text)
        {
            XmlChildTag childTag = new XmlChildTag(node.Name);
            //属性不为空添加属性
            if (node.Attributes != null)
            {
                foreach (XmlAttribute attr in node.Attributes)
                {
                    childTag.Attrs.Add(attr.Name, attr.Value);
                }
            }
            //递归添加子节点
            foreach (XmlNode childNode in node.ChildNodes)
            {
                XmlTag tag = NodeToTag(childNode);
                if (tag is XmlChildTag xmlChildTag)//根据子节点类型加入对应列表
                {
                    childTag.ChildTagList.Add(xmlChildTag);
                }
                else
                {
                    childTag.BaseTagList.Add(tag as XmlBaseTag);
                }
            }
            return childTag;
        }
        else
        {
            XmlBaseTag baseTag = new XmlBaseTag(node.Name);
            //属性不为空添加属性
            if (node.Attributes != null)
            {
                foreach (XmlAttribute attr in node.Attributes)
                {
                    baseTag.Attrs.Add(attr.Name, attr.Value);
                }
            }
            baseTag.InnerText = node.InnerText;
            return baseTag;
        }
    }

    /// <summary>
    /// Recurtion transfer XmlTag into XmlNode
    /// </summary>
    /// <param name="tag">XmlTag</param>
    /// <returns></returns>
    public XmlNode TagToNode(XmlTag tag)
    {
        XmlNode node = XmlDoc.CreateElement(tag.Name);
        foreach (var attr in tag.Attrs)
        {
            XmlAttribute xmlAttr = XmlDoc.CreateAttribute(attr.Key);
            xmlAttr.Value = attr.Value;
            node.Attributes?.Append(xmlAttr);
        }
        if (tag is XmlChildTag childTag)
        {
            if (childTag.BaseTagList.Count == 0 && childTag.ChildTagList.Count == 0)
            {
                throw new Exception("A XmlChildTag " + childTag.Name + "'s BaseTagList and ChildTagList can't both empty，if this tag don't have any child please use XmlBaseTag type");
            }
            //添加对应的子节点
            foreach (XmlBaseTag innerTag in childTag.BaseTagList)
            {
                node.AppendChild(TagToNode(innerTag));
            }
            foreach (XmlChildTag innerTag in childTag.ChildTagList)
            {
                node.AppendChild(TagToNode(innerTag));
            }
        }
        else
        {
            if (tag is XmlBaseTag baseTag) node.InnerText = baseTag.InnerText;
        }
        return node;
    }

    /// <summary>
    /// Quickly get a XmlChildTag
    /// </summary>
    /// <param name="tagNames">tag's name input by order</param>
    /// <returns></returns>
    public XmlChildTag GetChildTag(params string[] tagNames)
    {
        if (tagNames[0] != Root.Name)
        {
            throw new Exception("Root tag doesn't match");
        }
        if (!(Root is XmlChildTag))
        {
            throw new Exception("Root " + tagNames[0] + " must be XmlChildTag type");
        }
        XmlChildTag result = (XmlChildTag)Root;
        for (int i = 1; i < tagNames.Length; i++)
        {
            if (result != null && result.ChildTagList.All(t => t.Name != tagNames[i]))
            {
                throw new Exception("Can't find XmlChildTag tag " + tagNames[i] + " by the input tag names with this order");
            }

            result = result?.ChildTagList.FirstOrDefault(t => t.Name == tagNames[i]);
        }
        return result;
    }

    /// <summary>
    /// Quickly get a XmlBaseTag
    /// </summary>
    /// <param name="tagNames">按顺序输入的节点名称/tag's name input by order</param>
    /// <returns></returns>
    public XmlBaseTag GetBaseTag(params string[] tagNames)
    {
        if (tagNames[0] != Root.Name)
        {
            throw new Exception("Root tag doesn't match");
        }
        if (Root is XmlBaseTag tag)
        {
            if (tagNames.Length == 1)
            {
                return tag;
            }

            throw new Exception("Root " + tagNames[0] + " is XmlBaseTag type, don't have any childs");
        }
        XmlChildTag childTag = Root as XmlChildTag;
        for (int i = 1; i < tagNames.Length; i++)
        {
            if (childTag != null && (childTag.ChildTagList.All(t => t.Name != tagNames[i]) && childTag.BaseTagList.All(t => t.Name != tagNames[i])))
            {
                throw new Exception("Can't find XmlTag " + tagNames[i] + " by the input tag names with this order");
            }
            //最后一个节点查找BaseTagList，否则查找ChildTagList
            if (i == tagNames.Length - 1)
            {
                if (childTag != null && childTag.BaseTagList.Any(t => t.Name == tagNames[i]))
                {
                    return childTag.BaseTagList.FirstOrDefault(t => t.Name == tagNames[i]);
                }

                throw new Exception("Tag：" + tagNames[i] + " must be XmlBaseTag type");
            }

            //找到对应XmlChildTag节点缩小查找范围
            if (childTag != null && childTag.ChildTagList.Any(t => t.Name == tagNames[i]))
            {
                childTag = childTag.ChildTagList.FirstOrDefault(t => t.Name == tagNames[i]);
            }
            else
            {
                throw new Exception("Tag：" + tagNames[i] + " must be XmlChildTag type");
            }
        }
        return null;
    }

    #endregion Helper
}

/// <summary>
/// XmlTag: A xml tag
/// </summary>
public abstract class XmlTag
{
    /// <summary>
    /// Name
    /// </summary>
    public string Name { get; set; }

    /// <summary>
    /// Attributes
    /// </summary>
    public Dictionary<string, string> Attrs { get; set; }
}

/// <summary>
/// XmlChildTag: A XmlTag that at least have a XmlChildTag or XmlBaseTag inside
/// </summary>
public class XmlChildTag : XmlTag
{
    /// <summary>
    /// XmlChildTags of this XmlChildTag
    /// </summary>
    public List<XmlChildTag> ChildTagList { get; set; }

    /// <summary>
    /// XmlBaseTags of this XmlChildTag
    /// </summary>
    public List<XmlBaseTag> BaseTagList { get; set; }

    /// <summary>
    /// Constructor
    /// </summary>
    /// <param name="name">Tag's Name</param>
    public XmlChildTag(string name)
    {
        Name = name;
        Attrs = new Dictionary<string, string>();
        ChildTagList = new List<XmlChildTag>();
        BaseTagList = new List<XmlBaseTag>();
    }

    /// <summary>
    /// Get a XmlChildTag from this tag
    /// </summary>
    /// <param name="tagNames">tag's name input by order</param>
    /// <returns></returns>
    public XmlChildTag GetChildTag(params string[] tagNames)
    {
        XmlChildTag result = this;
        foreach (var tagName in tagNames)
        {
            if (result != null && result.ChildTagList.All(t => t.Name != tagName))
            {
                throw new Exception("Can't find XmlChildTag tag " + tagName + " by the input tag names with this order");
            }

            result = result?.ChildTagList.FirstOrDefault(t => t.Name == tagName);
        }
        return result;
    }

    /// <summary>
    /// Get a XmlBaseTag from this tag
    /// </summary>
    /// <param name="tagNames">tag's name input by order</param>
    /// <returns></returns>
    public XmlBaseTag GetBaseTag(params string[] tagNames)
    {
        XmlChildTag childTag = this;
        for (int i = 0; i < tagNames.Length; i++)
        {
            if (childTag != null && (childTag.ChildTagList.All(t => t.Name != tagNames[i]) && childTag.BaseTagList.All(t => t.Name != tagNames[i])))
            {
                throw new Exception("Can't find XmlTag tag " + tagNames[i] + " by the input tag names with this order");
            }
            //最后一个节点查找BaseTagList，否则查找ChildTagList
            if (i == tagNames.Length - 1)
            {
                if (childTag != null && childTag.BaseTagList.Any(t => t.Name == tagNames[i]))
                {
                    return childTag.BaseTagList.FirstOrDefault(t => t.Name == tagNames[i]);
                }

                throw new Exception("Tag：" + tagNames[i] + " must be XmlBaseTag type");
            }

            //找到对应XmlChildTag节点缩小查找范围
            if (childTag != null && childTag.ChildTagList.Any(t => t.Name == tagNames[i]))
            {
                childTag = childTag.ChildTagList.FirstOrDefault(t => t.Name == tagNames[i]);
            }
            else
            {
                throw new Exception("Tag：" + tagNames[i] + " must be XmlChildTag type");
            }
        }
        return null;
    }
}

/// <summary>
/// Xml基础标签：基础标签内不能有子标签，可以有内部文字
/// XmlBaseTag:XmlBaseTag don't have child tag, but inner text
/// </summary>
public class XmlBaseTag : XmlTag
{
    /// <summary>
    /// InnerText
    /// </summary>
    public string InnerText { get; set; }

    /// <summary>
    /// Constructor
    /// </summary>
    /// <param name="name">Tag's Name</param>
    public XmlBaseTag(string name)
    {
        Name = name;
        Attrs = new Dictionary<string, string>();
    }
}

#region Test

////Create a xmlfile
//public static void Create()
//{
//    XmlChildTag rootTag = new XmlChildTag("Root");
//    rootTag.BaseTagList.Add(new XmlBaseTag("BaseTagOne"));
//    XModel myXModel = new XModel("D:\\XML\\", "MyXModel.xml", "utf-8", rootTag);
//    Console.WriteLine("Create success");
//}

////Read a xml file
//public static void Read()
//{
//    XModel myXml = new XModel("D:\\XML\\", "MyXModel.xml");
//    string rootName = myXml.Root.Name;
//    string baseTagOneName = (myXml.Root as XmlChildTag).BaseTagList.First().Name;
//    Console.WriteLine("Read success");
//}

////Edit a xml file
//public static void Edit()
//{
//    XModel myXml = new XModel("D:\\XML\\", "MyXModel.xml");
//    //edit root name and attributes
//    XmlChildTag root = myXml.Root as XmlChildTag;
//    root.Name = "NewRoot";
//    root.Attrs.Add("attr1", "value1");
//    //root add a child tag which have three base tag
//    XmlChildTag newChild = new XmlChildTag("NewChild");
//    newChild.BaseTagList.Add(new XmlBaseTag("BaseTagTwo"));

//    XmlBaseTag baseTagThree = new XmlBaseTag("BaseTagThree");
//    baseTagThree.Attrs.Add("testa", "testv");
//    newChild.BaseTagList.Add(baseTagThree);

//    newChild.BaseTagList.Add(new XmlBaseTag("BaseTagFour") { InnerText = "some text" });
//    root.ChildTagList.Add(newChild);
//    //save to file
//    myXml.Save();
//    Console.WriteLine("Edit success");
//}

////Quickly Get and edit
//public static void QuicklyGet()
//{
//    XModel myXml = new XModel("D:\\XML\\", "MyXModel.xml");
//    //GetChildTag
//    XmlChildTag childA = myXml.GetChildTag("NewRoot", "NewChild");
//    childA.Attrs.Add("find", "ture");

//    //GetBaseTag
//    XmlBaseTag baseTagTwo = myXml.GetBaseTag("NewRoot", "NewChild", "BaseTagTwo");
//    baseTagTwo.InnerText = "default return first tag be found";

//    //quickly get tag from a XmlChildTag
//    XmlChildTag childB = myXml.GetChildTag("NewRoot", "NewChild");
//    //lambda
//    XmlBaseTag target = childB.BaseTagList.Where(b => b.Attrs.Keys.Contains("testa")).First();
//    target.InnerText = "quickly get combine with lambda let you read write xml file very quick";
//    //continue quickly get
//    XmlBaseTag target2 = childB.GetBaseTag("BaseTagTwo");
//    target2.InnerText = "quickly get can be use on XmlChildTag too.";

//    myXml.Save();
//    Console.WriteLine("QuicklyGet success");
//}

////Delete
//public static void Delete()
//{
//    XModel myXml = new XModel("D:\\XML\\", "MyXModel.xml");
//    myXml.Delete();
//    Console.WriteLine("Delete success");
//}

////To string
//public static void PrintXModel()
//{
//    XModel myXml = new XModel("D:\\XML\\", "MyXModel.xml");
//    Console.WriteLine(myXml.ToString());
//}

////Create from tag only
//public static void CreateWithOutFile()
//{
//    XmlChildTag root = new XmlChildTag("root");
//    root.BaseTagList.Add(new XmlBaseTag("base") { InnerText = "test" });
//    XModel myXml = new XModel(root);
//    myXml.XmlDirectory = "d:\\";
//    myXml.FileName = "nofile.xml";
//    myXml.Encode = "utf-8";
//    myXml.Save();
//}

////Read from xml String
//public static void ReadXmlString()
//{
//    XModel newxml = new XModel(new XModel("D:\\XML\\", "MyXModel.xml").ToString());
//    newxml.Root.Name = "newroot";
//    newxml.XmlDirectory = "d:\\";
//    newxml.FileName = "newxml.xml";
//    newxml.Encode = "gbk";
//    newxml.Save();
//}

#endregion Test