using System;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Xml;
using System.Xml.Linq;
using Abp.Runtime.Caching;
using Abp.UI;
using IwbZero.IwbBase;
using IwbZero.ToolCommon;
using IwbZero.ToolCommon.LogHelpers;
using IwbZero.ToolCommon.StringModel;
using WeEngine.CommonDto.WeInfo;
using WeEngine.ComponentInfo;

namespace WeEngine
{
    public static class PackageHelper
    {
        private static readonly string PackageBasePath = $"{WeEngineConst.DataFileBasePath}Packages/";

        #region 方案包

        /// <summary>
        /// 查询方案包
        /// </summary>
        /// <param name="cacheManager"></param>
        /// <param name="packageId"></param>
        /// <returns></returns>
        public static IwbXmlNode GetPackageXml(this ICacheManager cacheManager, string packageId)
        {
            var xml = cacheManager.GetCache(EngineCacheName.Package).Get(packageId, () => GetPackageXmlById(packageId));
            return xml;
        }

        /// <summary>
        /// 查询方案包
        /// </summary>
        /// <param name="packageId"></param>
        /// <returns></returns>
        public static IwbXmlNode GetPackageXmlById(string packageId)
        {
            var path = $"{PackageBasePath}{packageId}/";
            var fileName = $"{path}Package.iwbx";
            var xDoc = new XmlDocument();
            if (Directory.Exists(path) && File.Exists(fileName))
            {
                return GetPackageXmlFromFile(packageId);
            }

            try
            {
                //访问数据中心获取
                string baseUrl = ConfigurationManager.AppSettings["DataCenter.Platform.BaseUrl"] ?? "http://shvber.com:5015/";
                string apiUrl = ConfigurationManager.AppSettings["DataCenter.Engine.PackageUrl"] ?? "api/services/WePlatform/WePackage/GetPackageXml";
                string url=$"{baseUrl.Ew("/")}{apiUrl}?no={packageId}";
                string authKey = ConfigurationManager.AppSettings["DataCenter.Engine.AuthKey"];
                string result = url.RequestPost(new { PackageNo = packageId }.Obj2String(), authKey);
                WePackageXmlDto xmlDto = result.Str2Obj<WePackageXmlDto>();
                if (!Directory.Exists(path))
                {
                    Directory.CreateDirectory(path);
                }

                if (xmlDto.FlowXml.IsNotEmpty())
                {
                    xDoc.InnerXml = xmlDto.FlowXml;
                    xDoc.Save($"{path}flow.iwbx");
                }
                if (xmlDto.SceneXml.IsNotEmpty())
                {
                    xDoc.InnerXml = xmlDto.SceneXml;
                    xDoc.Save($"{path}scene.iwbx");
                }
                if (xmlDto.BehaviorXml.IsNotEmpty())
                {
                    xDoc.InnerXml = xmlDto.BehaviorXml;
                    xDoc.Save($"{path}behavior.iwbx");
                }
                if (xmlDto.ComponentXml.IsNotEmpty())
                {
                    xDoc.InnerXml = xmlDto.ComponentXml;
                    xDoc.Save($"{path}component.iwbx");
                }
                if (xmlDto.GuideXml.IsNotEmpty())
                {
                    xDoc.InnerXml = xmlDto.GuideXml;
                    xDoc.Save($"{path}guide.iwbx");
                }
                if (xmlDto.EnvironResourceXml.IsNotEmpty())
                {
                    xDoc.InnerXml = xmlDto.EnvironResourceXml;
                    xDoc.Save($"{path}environment.iwbx");
                }

                IwbXmlNode iwbNode = null;
                if (xmlDto.PackageXml.IsNotEmpty())
                {
                    xDoc.InnerXml = xmlDto.PackageXml;
                    xDoc.Save($"{path}package.iwbx");
                    iwbNode = IwbXmlNode.ParseGenericXml(xmlDto.PackageXml);
                }
                return iwbNode;
            }
            catch (Exception e)
            {
                typeof(PackageHelper).LogError(e);
                throw new UserFriendlyException("方案包获取、解析失败！");
            }
        }

        /// <summary>
        /// 从文件加载方案包
        /// </summary>
        /// <param name="packageId"></param>
        /// <returns></returns>
        public static IwbXmlNode GetPackageXmlFromFile(string packageId)
        {
            string fileName = $"{PackageBasePath}{packageId}/package.iwbx";
            if (!File.Exists(fileName))
            {
                return null;
            }
            try
            {
                var xDoc = new XmlDocument();
                xDoc.Load(fileName);
                var iwbNode = IwbXmlNode.ParseGenericXml(xDoc.InnerXml);
                return iwbNode;
            }
            catch (Exception e)
            {
                typeof(PackageHelper).LogError(e);
                throw new UserFriendlyException("方案包解析失败！");
            }
        }

        #endregion

        #region 情景流

        /// <summary>
        /// 加载情景流
        /// </summary>
        /// <param name="cacheManager"></param>
        /// <param name="packageId"></param>
        /// <param name="flowNo"></param>
        /// <returns></returns>
        public static IwbXmlNode GetSceneFlowXml(this ICacheManager cacheManager, string packageId, string flowNo)
        {
            var xml = cacheManager.GetCache(EngineCacheName.EngineSceneFlowCache).Get($"{packageId}.{flowNo}", () => GetSceneFlowXmlFromFile(packageId, flowNo));
            return xml;
        }

        /// <summary>
        /// 从文件加载情景流
        /// </summary>
        /// <param name="packageId"></param>
        /// <param name="flowNo"></param>
        /// <returns></returns>
        public static IwbXmlNode GetSceneFlowXmlFromFile(string packageId, string flowNo)
        {
            string fileName = $"{PackageBasePath}{packageId}/flow.iwbx";
            if (!File.Exists(fileName))
            {
                return null;
            }
            var xDoc = XDocument.Load(fileName);
            var root = xDoc.Root;
            var flow = root != null && root.HasElements
                ? (from e in root.Elements("SceneFlow") where e.Attribute("id")?.Value == flowNo select e).FirstOrDefault()
                : null;
            if (flow == null)
            {
                return null;
            }
            //var xmlDoc= new XmlDocument();
            //xmlDoc.LoadXml(flow.ToString());
            //XmlNode xmlNode = xmlDoc.FirstChild;
            var iwbNode = IwbXmlNode.ParseGenericXml(flow.ToString());
            return iwbNode;
        }

        /// <summary>
        /// 从xml字符串中加载情景流
        /// </summary>
        /// <param name="xml"></param>
        /// <param name="flowNo"></param>
        /// <returns></returns>
        public static IwbXmlNode GetSceneFlowXmlFromXml(string xml, string flowNo)
        {
            if (xml.IsEmpty())
            {
                return null;
            }
            var xDoc = XDocument.Parse(xml);
            var root = xDoc.Root;
            var flow = root != null && root.HasElements
                ? (from e in root.Elements("SceneFlow") where e.Attribute("id")?.Value == flowNo select e).FirstOrDefault()
                : null;
            if (flow == null)
            {
                return null;
            }
            //var xmlDoc= new XmlDocument();
            //xmlDoc.LoadXml(flow.ToString());
            //XmlNode xmlNode = xmlDoc.FirstChild;
            var iwbNode = IwbXmlNode.ParseGenericXml(flow.ToString());
            return iwbNode;
        }


        #endregion

        #region 情景

        /// <summary>
        /// 加载情景
        /// </summary>
        /// <param name="cacheManager"></param>
        /// <param name="packageId"></param>
        /// <param name="sceneNo"></param>
        /// <returns></returns>
        public static IwbXmlNode GetSceneInfoXml(this ICacheManager cacheManager, string packageId, string sceneNo)
        {
            var xml = cacheManager.GetCache(EngineCacheName.EngineSceneInfoCache).Get($"{packageId}.{sceneNo}", () => GetSceneXmlFromFile(packageId, sceneNo));
            return xml;
        }

        /// <summary>
        /// 从文件加载情景
        /// </summary>
        /// <param name="packageId"></param>
        /// <param name="sceneNo"></param>
        /// <returns></returns>
        public static IwbXmlNode GetSceneXmlFromFile(string packageId, string sceneNo)
        {
            string fileName = $"{PackageBasePath}{packageId}/scene.iwbx";
            if (!File.Exists(fileName))
            {
                return null;
            }
            var xDoc = XDocument.Load(fileName);
            var root = xDoc.Root;
            var scene = root != null && root.HasElements
                ? (from e in root.Elements("SceneInfo") where e.Attribute("id")?.Value == sceneNo select e).FirstOrDefault()
                : null;
            if (scene == null)
            {
                return null;
            }
            //var xmlDoc = new XmlDocument();
            //xmlDoc.LoadXml(scene.ToString());
            //XmlNode xmlNode = xmlDoc.FirstChild;
            //return xmlNode;
            var iwbNode = IwbXmlNode.ParseGenericXml(scene.ToString());
            return iwbNode;
        }

        /// <summary>
        /// 从xml加载情景
        /// </summary>
        /// <param name="xml"></param>
        /// <param name="sceneNo"></param>
        /// <returns></returns>
        public static IwbXmlNode GetSceneXmlFromXml(string xml, string sceneNo)
        {
            if (xml.IsEmpty())
            {
                return null;
            }
            var xDoc = XDocument.Parse(xml);
            var root = xDoc.Root;
            var scene = root != null && root.HasElements
                ? (from e in root.Elements("SceneInfo") where e.Attribute("id")?.Value == sceneNo select e).FirstOrDefault()
                : null;
            if (scene == null)
            {
                return null;
            }
            //var xmlDoc = new XmlDocument();
            //xmlDoc.LoadXml(scene.ToString());
            //XmlNode xmlNode = xmlDoc.FirstChild;
            //return xmlNode;
            var iwbNode = IwbXmlNode.ParseGenericXml(scene.ToString());
            return iwbNode;
        }

        #endregion

        #region 行为

        /// <summary>
        /// 加载处理行为
        /// </summary>
        /// <param name="cacheManager"></param>
        /// <param name="packageId"></param>
        /// <param name="behaviorNo"></param>
        /// <returns></returns>
        public static IwbXmlNode GetBehaviorXml(this ICacheManager cacheManager, string packageId, string behaviorNo)
        {
            var xml = cacheManager.GetCache(EngineCacheName.EngineBehaviorCache).Get($"{packageId}.{behaviorNo}", () => GetBehaviorXmlFromFile(packageId, behaviorNo));
            return xml;
        }

        /// <summary>
        /// 从文件加载处理行为
        /// </summary>
        /// <param name="packageId"></param>
        /// <param name="behaviorNo"></param>
        /// <returns></returns>
        public static IwbXmlNode GetBehaviorXmlFromFile(string packageId, string behaviorNo)
        {

            string fileName = $"{PackageBasePath}{packageId}/behavior.iwbx";
            if (!File.Exists(fileName))
            {
                return null;
            }
            var xDoc = XDocument.Load(fileName);
            var root = xDoc.Root;
            var behavior = root != null && root.HasElements
                ? (from e in root.Elements("Behavior") where e.Attribute("id")?.Value == behaviorNo select e).FirstOrDefault()
                : null;
            if (behavior == null)
            {
                return null;
            }
            var iwbNode = IwbXmlNode.ParseGenericXml(behavior.ToString());
            return iwbNode;
        }

        /// <summary>
        /// 从xml加载处理行为
        /// </summary>
        /// <param name="xml"></param>
        /// <param name="behaviorNo"></param>
        /// <returns></returns>
        public static IwbXmlNode GetBehaviorXmlFromXml(string xml, string behaviorNo)
        {
            if (xml.IsEmpty())
            {
                return null;
            }
            var xDoc = XDocument.Parse(xml);
            var root = xDoc.Root;
            var behavior = root != null && root.HasElements
                ? (from e in root.Elements("Behavior") where e.Attribute("id")?.Value == behaviorNo select e).FirstOrDefault()
                : null;
            if (behavior == null)
            {
                return null;
            }
            var iwbNode = IwbXmlNode.ParseGenericXml(behavior.ToString());
            return iwbNode;
        }


        #endregion

        #region 引导信息

        /// <summary>
        /// 加载引导信息
        /// </summary>
        /// <param name="cacheManager"></param>
        /// <param name="packageId"></param>
        /// <param name="guideNo"></param>
        /// <returns></returns>
        public static IwbXmlNode GetGuideXml(this ICacheManager cacheManager, string packageId, string guideNo)
        {
            var xml = cacheManager.GetCache(EngineCacheName.EngineGuideCache).Get($"{packageId}.{guideNo}", () => GetGuideXmlFromFile(packageId, guideNo));
            return xml;
        }

        /// <summary>
        /// 从文件加载引导信息
        /// </summary>
        /// <param name="packageId"></param>
        /// <param name="guideNos"></param>
        /// <returns></returns>
        public static IwbXmlNode GetGuidesXmlFromFile(string packageId, string guideNos)
        {

            string xmlStr = "";
            foreach (var guideNo in guideNos.StrToArray())
            {
                xmlStr += GetGuideStrXmlFromFile(packageId, guideNo);
            }

            if (xmlStr.IsEmpty())
            {
                return null;
            }

            xmlStr = $"<Guides>{xmlStr}</Guides>";
            var iwbNode = IwbXmlNode.ParseGenericXml(xmlStr);
            return iwbNode;
        }

        /// <summary>
        /// 从文件加载引导信息
        /// </summary>
        /// <param name="packageId"></param>
        /// <param name="guideNo"></param>
        /// <returns></returns>
        public static IwbXmlNode GetGuideXmlFromFile(string packageId, string guideNo)
        {
            string xmlStr = GetGuideStrXmlFromFile(packageId, guideNo);
            var iwbNode = IwbXmlNode.ParseGenericXml(xmlStr);
            return iwbNode;
        }

        /// <summary>
        /// 从文件加载引导信息
        /// </summary>
        /// <param name="packageId"></param>
        /// <param name="guideNo"></param>
        /// <returns></returns>
        public static string GetGuideStrXmlFromFile(string packageId, string guideNo)
        {
            string fileName = $"{PackageBasePath}{packageId}/guide.iwbx";
            if (!File.Exists(fileName))
                return null;
            var xDoc = XDocument.Load(fileName);
            var root = xDoc.Root;
            var guide = root != null && root.HasElements
                ? (from e in root.Elements("GuideInfo") where e.Attribute("id")?.Value == guideNo select e).FirstOrDefault()
                : null;
            return guide?.ToString() ?? "";
        }
       
        /// <summary>
        /// 从xml加载引导信息
        /// </summary>
        /// <param name="xml"></param>
        /// <param name="guideNo"></param>
        /// <returns></returns>
        public static IwbXmlNode GetGuidesXmlFromXml(string xml, string guideNo)
        {
            if (xml.IsEmpty())
            {
                return null;
            }
            var xDoc = XDocument.Parse(xml);
            var root = xDoc.Root;
            var guide = root != null && root.HasElements
                ? (from e in root.Elements("GuideInfo") where e.Attribute("id")?.Value == guideNo select e).FirstOrDefault()
                : null;
            if (guide == null)
            {
                return null;
            }
            var iwbNode = IwbXmlNode.ParseGenericXml(guide.ToString());
            return iwbNode;
        }

        #endregion

        #region 环境资源

        /// <summary>
        /// 加载环境资源信息
        /// </summary>
        /// <param name="cacheManager"></param>
        /// <param name="packageId"></param>
        /// <param name="resourceNo"></param>
        /// <returns></returns>
        public static IwbXmlNode GetEnvironResourceXml(this ICacheManager cacheManager, string packageId, string resourceNo)
        {
            var xml = cacheManager.GetCache(EngineCacheName.EngineEnvironResourceCache).Get($"{packageId}.{resourceNo}", () => GetEnvironResourceXmlFromFile(packageId, resourceNo));
            return xml;
        }

        /// <summary>
        /// 从文件加载环境资源信息
        /// </summary>
        /// <param name="packageId"></param>
        /// <param name="resourceNos"></param>
        /// <returns></returns>
        public static IwbXmlNode GetEnvironResourcesXmlFromFile(string packageId, string resourceNos)
        {

            string xmlStr = "";
            foreach (var no in resourceNos.StrToArray())
            {
                xmlStr += GetEnvironResourceXmlFromFile(packageId, no);
            }

            if (xmlStr.IsEmpty())
            {
                return null;
            }

            xmlStr = $"<Environments>{xmlStr}</Environments>";
            //var xmlDoc= new XmlDocument();
            //xmlDoc.LoadXml(xmlStr);
            //XmlNode xmlNode = xmlDoc.FirstChild;
            //return xmlNode;
            var iwbNode = IwbXmlNode.ParseGenericXml(xmlStr);
            return iwbNode;
        }

        /// <summary>
        /// 从文件加载环境资源信息
        /// </summary>
        /// <param name="packageId"></param>
        /// <param name="resourceNo"></param>
        /// <returns></returns>
        public static IwbXmlNode GetEnvironResourceXmlFromFile(string packageId, string resourceNo)
        {
            string xmlStr = GetEnvironResourceStrXmlFromFile(packageId, resourceNo);
            //var xmlDoc= new XmlDocument();
            //xmlDoc.LoadXml(xmlStr);
            //XmlNode xmlNode = xmlDoc.FirstChild;
            //return xmlNode;

            var iwbNode = IwbXmlNode.ParseGenericXml(xmlStr);
            return iwbNode;
        }

        /// <summary>
        /// 从文件加载环境资源信息
        /// </summary>
        /// <param name="packageId"></param>
        /// <param name="resourceNo"></param>
        /// <returns></returns>
        public static string GetEnvironResourceStrXmlFromFile(string packageId, string resourceNo)
        {
            string fileName = $"{PackageBasePath}{packageId}/environment.iwbx";
            if (!File.Exists(fileName))
                return null;
            var xDoc = XDocument.Load(fileName);
            var root = xDoc.Root;
            var resource = root != null && root.HasElements
                ? (from e in root.Elements("Environment") where e.Attribute("id")?.Value == resourceNo select e).FirstOrDefault()
                : null;
            return resource?.ToString() ?? "";
        }

        /// <summary>
        /// 从xml加载环境资源信息
        /// </summary>
        /// <param name="xml"></param>
        /// <param name="resourceNo"></param>
        /// <returns></returns>
        public static IwbXmlNode GetEnvironResourceXmlFromXml(string xml, string resourceNo)
        {
            if (xml.IsEmpty())
            {
                return null;
            }
            var xDoc = XDocument.Parse(xml);
            var root = xDoc.Root;
            var resource = root != null && root.HasElements
                ? (from e in root.Elements("Environment") where e.Attribute("id")?.Value == resourceNo select e).FirstOrDefault()
                : null;
            if (resource == null)
            {
                return null;
            }
            var iwbNode = IwbXmlNode.ParseGenericXml(resource.ToString());
            return iwbNode;
        }

        #endregion

        #region 事务组件

        /// <summary>
        /// 加载事务组件
        /// </summary>
        /// <param name="cacheManager"></param>
        /// <param name="packageId"></param>
        /// <param name="compId"></param>
        /// <returns></returns>
        public static EngineComponent GetEngineComponent(this ICacheManager cacheManager, string packageId, string compId)
        {
            var key = packageId.IsEmpty() ? compId : $"{packageId}.{compId}";
            var component = cacheManager.GetCache(EngineCacheName.EngineComponentCache).Get(key, () => GetEngineComponent(packageId, compId));
            return component;
        }

        /// <summary>
        /// 加载事务组件
        /// </summary>
        /// <param name="packageId"></param>
        /// <param name="compId"></param>
        /// <returns></returns>
        public static EngineComponent GetEngineComponent(string packageId, string compId)
        {
            var componentXml = GetComponentFromFile(packageId, compId);
            if (componentXml == null)
                return null;
            var component = new EngineComponent().ModelFrom(componentXml);
            return component;
        }

        /// <summary>
        /// 从文件加载事务组件
        /// </summary>
        /// <param name="packageId"></param>
        /// <param name="compId"></param>
        /// <returns></returns>
        public static IwbXmlNode GetComponentFromFile(string packageId, string compId)
        {
            string fileName = $"{PackageBasePath}{packageId}/component.iwbx";
            if (!File.Exists(fileName))
                return null;
            var xDoc = XDocument.Load(fileName);
            var root = xDoc.Root;
            var component = root != null && root.HasElements
                ? (from e in root.Elements("ComponentInfo") where e.Attribute("id")?.Value == compId select e).FirstOrDefault()
                : null;
            if (component == null)
                return null;
            var iwbNode = IwbXmlNode.ParseGenericXml(component.ToString());
            return iwbNode;
        }

        /// <summary>
        /// 从xml加载事务组件
        /// </summary>
        /// <param name="xml"></param>
        /// <param name="compId"></param>
        /// <returns></returns>
        public static IwbXmlNode GetComponentFromXml(string xml, string compId)
        {
            if (xml.IsEmpty())
            {
                return null;
            }
            var xDoc = XDocument.Parse(xml);
            var root = xDoc.Root;
            var component = root != null && root.HasElements
                ? (from e in root.Elements("ComponentInfo") where e.Attribute("id")?.Value == compId select e).FirstOrDefault()
                : null;
            if (component == null)
                return null;
            var iwbNode = IwbXmlNode.ParseGenericXml(component.ToString());
            return iwbNode;
        }


        #endregion

    }
}