using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

using Abp.Application.Services.Dto;
using Abp.Auditing;
using Abp.Domain.Repositories;
using Abp.Runtime.Caching;

using IwbZero.ToolCommon.LogHelpers;
using IwbZero.ToolCommon.StringModel;
using WeEngine.CommonDto.WeInfo;
using WeEngine.ComponentInfo;
using WeEngine.Enum;
using WeEngine.ModelInfo;
using WePlatform.Configuration;
using WePlatform.DataCenter.SjPackage.Dto;
using WePlatform.WeLib;
using WePlatform.WeLib.Package;

namespace WePlatform.DataCenter.SjPackage
{
    /// <summary>
    /// 方案包API
    /// </summary>
    [DisableAuditing]
    public class SjPackageAppService : DataCenterAppServiceBase, ISjPackageAppService
    {
        public SjPackageAppService(IRepository<PackageXmlInfo> xmlRepository, IRepository<PackageInfo, string> packageRepository, PackageAppService packageApp, ICacheManager cacheManager, IRepository<SceneFlowInfo, string> flowRepository, IRepository<SceneInfo, string> sceneRepository, IRepository<BehaviorInfo, string> behaviorRepository, IRepository<SceneBehaviorInfo> sbRepository)
        {
            XmlRepository = xmlRepository;
            PackageRepository = packageRepository;
            PackageApp = packageApp;
            FlowRepository = flowRepository;
            SceneRepository = sceneRepository;
            BehaviorRepository = behaviorRepository;
            SbRepository = sbRepository;
            CacheManager = cacheManager;
        }

        protected IRepository<PackageXmlInfo> XmlRepository { get; }
        protected IRepository<PackageInfo, string> PackageRepository { get; }
        protected IRepository<SceneFlowInfo, string> FlowRepository { get; }
        protected IRepository<SceneInfo, string> SceneRepository { get; }
        protected IRepository<BehaviorInfo, string> BehaviorRepository { get; }
        protected IRepository<SceneBehaviorInfo> SbRepository { get; }
        protected PackageAppService PackageApp { get; }

        #region SJ

        /// <summary>
        /// 导入方案包（松江沙盘演练）
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<string> Export(SjExportPackage input)
        {
            var package = input.PackageNo.IsEmpty()
                ? new PackageInfo()
                {
                    Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.PackageInfo),
                    PackageName = input.Title,
                    SceneCategory = input.CategoryNo.IsEmpty() ? IwbConsts.SjShaPanCategoryNo : input.CategoryNo,
                    Description = input.InitFaultInfo,
                    EngineModelNo = IwbConsts.NonEvolutionEngineModelNo,
                    EvalModelNo = IwbConsts.EvalModelNo,
                    PackageState = PackageStateDefinition.Solidified,
                    Remark = "松江沙盘演练系统导入",
                    AssessAuto = true,
                    AssessRoleNames = "",
                    AssessRoleNos = "",
                    ContentInfo = ""
                }
                : await PackageRepository.FirstOrDefaultAsync(a => a.Id == input.PackageNo);
            if (package == null)
            {
                this.LogError($"未查到方案包！[{input.PackageNo}]");
                return "";
            }
            var pModel = await PackageFrom(input, package);
            package.ContentInfo = package.ContentInfo.IsEmpty() ? GetPackageContentInfo(pModel) : package.ContentInfo;
            pModel.Components = pModel.Components ?? new List<EngineComponent>();
            var xmlDto = pModel.Package2Xml();
            xmlDto.PackageNo = package.Id;
            if (input.PackageNo.IsEmpty())
            {
                var xmlEntity = xmlDto.Obj2String().Str2Obj<PackageXmlInfo>();
                await XmlRepository.InsertAsync(xmlEntity);
                await PackageRepository.InsertAsync(package);
            }
            else
            {
                package.PackageName = input.Title;
                package.Description = input.InitFaultInfo;
                await PackageRepository.UpdateAsync(package);
                var xmlEntity = await XmlRepository.FirstOrDefaultAsync(a => a.PackageNo == input.PackageNo);
                xmlEntity.PackageXml = xmlDto.PackageXml;
                xmlEntity.FlowXml = xmlDto.FlowXml;
                xmlEntity.SceneXml = xmlDto.SceneXml;
                xmlEntity.BehaviorXml = xmlDto.BehaviorXml;
                xmlEntity.GuideXml = xmlDto.GuideXml;
                xmlEntity.EnvironResourceXml = xmlDto.EnvironResourceXml;
                xmlEntity.ComponentXml = xmlDto.ComponentXml;
                xmlEntity.AllRoles = xmlDto.AllRoles;
                await XmlRepository.UpdateAsync(xmlEntity);
            }

            return package.Id;
        }

        /// <summary>
        /// 查询方案包（松江沙盘演练）
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<SjExportPackage> Query(EntityDto<string> input)
        {
            return await QueryByNo(input.Id);
        }

        /// <summary>
        /// 查询方案包（松江沙盘演练）
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<SjExportPackage> QueryByNo(string no)
        {
            var package = await PackageRepository.FirstOrDefaultAsync(a => a.Id == no);
            var xmlEntity = await XmlRepository.FirstOrDefaultAsync(a => a.PackageNo == no);
            if (package == null || xmlEntity == null)
            {
                return null;
            }
            var weXmlDto = new WePackageXmlDto()
            {
                PackageXml = xmlEntity.PackageXml,
                FlowXml = xmlEntity.FlowXml,
                SceneXml = xmlEntity.SceneXml,
                BehaviorXml = xmlEntity.BehaviorXml,
                GuideXml = xmlEntity.GuideXml,
                EnvironResourceXml = xmlEntity.EnvironResourceXml,
                ComponentXml = xmlEntity.ComponentXml,
                AllRoles = xmlEntity.AllRoles
            };
            var packageModel= new PackageModel().BuildPackageModelByXml(weXmlDto);
            var behaviorModels = packageModel.AllBehaviorModels;

            var sceneModels = packageModel.AllSceneModels;
            var scenes = new List<SjExportScene>();
            if (sceneModels != null && sceneModels.Any())
            {
                foreach (var sceneModel in sceneModels)
                {
                    var behavior = behaviorModels.FirstOrDefault(a => sceneModel.BehaviorNos == a.Id);//.Where(a => sceneModel.BehaviorNos.Contains(a.Id)).ToList();
                    scenes.Add(new SjExportScene()
                    {
                        SceneNo = sceneModel.Id,
                        Question = sceneModel.Description,
                        Section = sceneModel.SceneTag,
                        Description = sceneModel.Description,
                        CorrectAnswer = behavior?.Description,
                        StandardTotalScore = behavior?.Weights ?? 0
                    });
                }
            }

            var dto = new SjExportPackage()
            {
                PackageNo = package.Id,
                Title = package.PackageName,
                InitFaultInfo = package.Description,
                SceneList = scenes
            };

            return dto;
        }

        private async Task<PackageModel> PackageFrom(SjExportPackage input, PackageInfo package)
        {
            PackageModel pModel;
            SceneFlowModel flow;
            if (package.ContentInfo.IsEmpty())
            {
                pModel = new PackageModel()
                {
                    Id = package.Id,
                    No = "P",
                    Name = package.PackageName,
                    SceneCategory = package.SceneCategory,
                    ParentPath = null,
                    Path = "P",
                    Children = new List<RoundModel>()
                };
                var round = new RoundModel()
                {
                    Id = "R1",
                    No = "R1",
                    Name = "第一轮",
                    RoundIndex = 1,
                    SceneCategory = package.SceneCategory,
                    Path = $"{pModel.Path}_R1",
                    ParentPath = pModel.Path,
                    Children = new List<BlockModel>()
                };
                var block = new BlockModel()
                {
                    Id = "SBF1",
                    No = "SBF1",
                    Name = "题库",
                    SceneCategory = package.SceneCategory,
                    Path = $"{round.Path}_SBF1",
                    ParentPath = round.Path,
                    Children = new List<SceneFlowModel>()
                };
                var flowId = await AppGuidManager.GetNextRecordIdAsync(DataLibType.SceneFlowInfo);
                flow = new SceneFlowModel()
                {
                    Id = flowId,
                    No = flowId,
                    Name = $"题库_沙盘演练（{input.Title}）",
                    SceneCategory = package.SceneCategory,
                    Path = $"{block.Path}_{flowId}",
                    ParentPath = block.Path,
                    Children = new List<FlowModel>(),
                };
                flow = await FlowFrom(input.SceneList, flow);

                block.Children.Add(flow);
                round.Children.Add(block);
                pModel.Children.Add(round);
               

                var flowEntity = new SceneFlowInfo()
                {
                    Id = flowId,
                    FlowName = flow.Name,
                    SceneCategory = package.SceneCategory,
                    ContentInfo = GetFlowContentInfo(flow),
                    ComponentInfo = "",
                    SceneFlowState = SceneFlowStateDefinition.Solidified,
                    Variable = ""
                };
                await FlowRepository.InsertAsync(flowEntity);
            }
            else
            {
                pModel = package.ContentInfo.Str2Obj<PackageModel>();
                var block =pModel?.Children?.FirstOrDefault()?.Children?.FirstOrDefault();
                var flowNo = block?.FlowNos;

                var flowEntity = await FlowRepository.FirstOrDefaultAsync(a => a.Id == flowNo);
                if (flowEntity != null)
                {
                    flow = flowEntity.ContentInfo.Str2Obj<SceneFlowModel>();
                    flow = await FlowFrom(input.SceneList, flow);
                    flowEntity.FlowName = $"题库_沙盘演练（{input.Title}）";
                    flowEntity.ContentInfo = GetFlowContentInfo(flow);
                    await FlowRepository.UpdateAsync(flowEntity);
                }
            }
            return pModel;
        }

        private async Task<SceneFlowModel> FlowFrom(List<SjExportScene> scenes, SceneFlowModel flow)
        {
            if (scenes.Any())
            {
                var flowNode = new FlowModel()
                {
                    Id = "FN1",
                    No = "FN1",
                    SceneCategory = flow.SceneCategory,
                    Name = flow.Name,
                    Path = $"{flow.Path}_FN1",
                    ParentPath = flow.Path,
                    Children = new List<FlowModel>(),
                    SceneInfos = new List<SceneModel>()
                };
                var i = 0;
                foreach (var s in scenes)
                {
                    i++;
                    var sModel = await SceneFrom(i, s, flowNode, flow);
                    flowNode.SceneInfos.Add(sModel);
                    
                }
                flow.Children?.Add(flowNode);
            }

            return flow;
        }

        private async Task<SceneModel> SceneFrom(int index, SjExportScene scene, FlowModel flowNode, SceneFlowModel flow)
        {
            var sModel = new SceneModel()
            {
                Id = scene.SceneNo.IsEmpty() ? $"SN{index}" : scene.SceneNo,
                No = $"SN{index}",
                SceneCategory = flow.SceneCategory,
                Name = scene.Question.Length>SceneInfo.NameLength? scene.Question.Substring(0, SceneInfo.NameLength - 1):scene.Question,
                SceneTag = scene.Section,
                SceneType = (int)SceneType.NonEvolution,
                _description = scene.Question,
                Path = $"{flowNode.Path}_SN{index}",
                ParentPath = flowNode.Path,
                Children = new List<BehaviorModel>()
            };
            if (scene.CorrectAnswer.IsEmpty())
            {
                scene.CorrectAnswer = scene.Question;
            }
            var bModel = new BehaviorModel()
            {
                Id = $"BN1",
                No = $"BN1",
                SceneCategory = flow.SceneCategory,
                Name = scene.CorrectAnswer.Length > BehaviorInfo.NameLength
                    ? scene.CorrectAnswer.Substring(0, BehaviorInfo.NameLength)
                    : scene.CorrectAnswer,
                Description = scene.CorrectAnswer,
                Weights = scene.StandardTotalScore,
                Path = $"{sModel.Path}_BN1",
                ParentPath = sModel.Path,
            };
            sModel.Children.Add(bModel);
            var sceneEntity = await SaveScene(sModel);
            sModel.Id = sceneEntity.Id;
            return sModel;
        }

        private async Task<SceneInfo> SaveScene(SceneModel s)
        {
            var sceneEntity = await SceneRepository.FirstOrDefaultAsync(a => a.Id == s.Id || s.Name.StartsWith(a.Name));
            if (sceneEntity == null)
            {
                sceneEntity = new SceneInfo()
                {
                    Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.SceneInfo),
                    Name = s.Name,
                    Description = s.Description,
                    SceneCategory = s.SceneCategory,
                    SceneTag = s.SceneTag,
                    SceneType = s.SceneType,
                    Remark = "松江EXCEL导入"
                };
                await SceneRepository.InsertAndGetIdAsync(sceneEntity);
            }
            else
            {
                sceneEntity.Name = s.Name;
                sceneEntity.Description = s.Description;
                sceneEntity.SceneTag = s.SceneTag;
                await SceneRepository.UpdateAsync(sceneEntity);
            }

            foreach (var child in s.Children)
            {
                var b = child;
                var behaviorEntity = await SaveBehavior(b, sceneEntity.Id);
                b.Id = behaviorEntity.Id;
            }

            return sceneEntity;
        }

        private async Task<BehaviorInfo> SaveBehavior(BehaviorModel b, string sceneNo)
        {
            var behaviorEntity = await BehaviorRepository.FirstOrDefaultAsync(a => a.Id == b.Id || b.Name.StartsWith(a.BehaviorName));
            if (behaviorEntity == null)
            {
                behaviorEntity = new BehaviorInfo
                {
                    Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.BehaviorInfo),
                    BehaviorName = b.Name,
                    SceneCategory = b.SceneCategory,
                    Description = b.Description,
                    RoleLogicType = (int)BehaviorRoleLogicType.Or,
                    BehaviorTag = "",
                };
                await BehaviorRepository.InsertAndGetIdAsync(behaviorEntity);
                await SbRepository.InsertAsync(new SceneBehaviorInfo()
                {
                    BehaviorNo = behaviorEntity.Id,
                    SceneNo = sceneNo,
                    BehaviorEvalType = (int)BehaviorScoreType.Normal,
                    BehaviorWeight = b.Weights
                });
            }
            else
            {
                if (b.Name.IsNotEmpty())
                {
                    behaviorEntity.BehaviorName = b.Name;
                    behaviorEntity.Description = b.Description;
                    var sb = await SbRepository.FirstOrDefaultAsync(a =>
                        a.SceneNo == sceneNo && a.BehaviorNo == behaviorEntity.Id);
                    if (sb != null)
                    {
                        sb.BehaviorWeight = b.Weights;
                        await SbRepository.UpdateAsync(sb);
                    }
                }
               
            }

            return behaviorEntity;
        }

        private string GetPackageContentInfo(PackageModel pModel)
        {
            var pm = new PackageModel()
            {
                Id = pModel.Id,
                No = pModel.No,
                Name = pModel.Name,
                Path = "P",
                ParentPath = "",
                Children = new List<RoundModel>()
            };
            if (pModel.Children != null)
                foreach (var child in pModel.Children)
                {
                    var r = child;
                    var round = new RoundModel()
                    {
                        Id = r.Id,
                        No = r.No,
                        Name = r.Name,
                        Path = r.Path,
                        ParentPath = r.ParentPath,
                        RoundFullScore = 0,
                        ControlRate = 0,
                        SceneCount = 0,
                        RoundIndex = r.RoundIndex,
                        Children = new List<BlockModel>()
                    };
                    if (r.Children != null)
                        foreach (var b in r.Children)
                        {
                            round.Children.Add(new BlockModel()
                            {
                                Id = b.Id,
                                No = b.No,
                                Name = b.Name,
                                Path = b.Path,
                                ParentPath = b.ParentPath,
                                FlowNos = string.Join(",", b.Children?.Select(a => a.Id).ToArray() ?? new string[0]),
                                FlowNames = string.Join(",", b.Children?.Select(a => a.Name).ToArray() ?? new string[0])
                            });
                        }

                    pm.Children.Add(round);
                }

            return pm.Obj2StringCamelCase();
        }

        public string GetFlowContentInfo(SceneFlowModel fModel)
        {
            var flowNode = fModel.Children.FirstOrDefault();
            if (flowNode != null)
            {
                var flow = new FlowModel()
                {
                    Id = flowNode.Id,
                    No = flowNode.No,
                    Name = flowNode.Name,
                    Path = flowNode.Path,
                    ParentPath = "",
                    Children = new List<FlowModel>(),
                };
                return flow.Obj2StringCamelCase();
            }
            return "";
        }

        //private async Task FlowFrom(SjExportPackage input, PackageInfo package)
        //{
        //    var flow = await FlowFrom(input.SceneList, package);
        //    SceneFlowInfo flowEntity;
        //    if (package.ContentInfo.IsEmpty())
        //    {
        //        flowEntity = new SceneFlowInfo()
        //        {
        //            Id = flow.Id,
        //            FlowName = flow.Name,
        //            SceneCategory = package.SceneCategory,
        //        };

        //        await FlowRepository.InsertAsync(flowEntity);
        //    }
        //    else
        //    {
        //        flowEntity = await FlowRepository.FirstOrDefaultAsync(a => a.Id == flow.Id);
        //        await FlowRepository.UpdateAsync(flowEntity);
        //    }

        //}

        //private async Task<FlowModel> FlowFrom(List<SjExportScene> scenes, PackageInfo package)
        //{
        //    var flowModel = package.ContentInfo.IsEmpty()
        //        ? new FlowModel()
        //        {
        //            Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.SceneFlowInfo),
        //            Name = $"题库_沙盘演练({package.PackageName})"
        //        }
        //        : package.ContentInfo.Str2Obj<FlowModel>();
        //    if (scenes.Any())
        //    {
        //        var sceneModels= new List<SceneModel>();
        //        foreach (var s in scenes)
        //        {
        //            var sModel = await SceneFrom(s,package);
        //            if (sModel != null)
        //            {
        //                sceneModels.Add(sModel);
        //            }
        //        }
        //        flowModel.SceneInfos = sceneModels;
        //    }

        //    return flowModel;
        //}

        //private async Task<SceneModel> SceneFrom(SjExportScene scene, PackageInfo package)
        //{
        //    var sceneModel = new SceneModel()
        //    {
        //        Id = scene.SceneNo,
        //        No = scene.SceneNo,
        //        Name = scene.Question,
        //        Description = scene.Description,
        //        SceneTag = scene.Section
        //    };

        //    if (scene.SceneNo.IsEmpty())
        //    {
        //        sceneModel.Id = scene.SceneNo;
        //        sceneModel.Name = scene.Question;
        //        sceneModel.Description = scene.Description;
        //        sceneModel.SceneTag = scene.Section;
        //    }
        //    else
        //    {
        //        var sceneEntity = await SceneRepository.FirstOrDefaultAsync(a => a.Id == scene.SceneNo);
        //        sceneModel.Id = sceneEntity.Id;
        //    }

        //    return sceneModel;
        //}

        #endregion SJ
    }
}