using CloudBuilder.Core.DatabaseAccessor;
using CloudBuilder.Core.DatabaseAccessor.Entity;
using CloudBuilder.Core.Extensions;
using CloudBuilder.Core.Service;
using CloudBuilder.Security.Data;
using CloudBuilder.Security.Entity;
using CloudBuilder.Security.Policy;
using CloudBuilder.Security.SearchCriteria;
using CloudBuilder.Security.Utility;
using Microsoft.AspNetCore.Authorization;
using Microsoft.Extensions.DependencyInjection;
namespace CloudBuilder.Security.Service
{
    public class SecurityHelpFunctionService : ISecurityHelpFunctionService
    {
        private readonly IApplicationService service;

        private IRepository<SecurityHelpFunctionEntity> repository;
        public SecurityHelpFunctionService(IApplicationService service)
        {
            this.service = service;
            repository = service.GetRepository<IRepository<SecurityHelpFunctionEntity>>();
        }

        [PermissionOperate(name: SecurityPermissionPolicy.SecurityHelpFunction, operate: Operate.Find)]
        public SecurityHelpFunctionData FindByKey(string key)
        {
            return FindByFunctionName(key);
        }


        [AllowAnonymous]
        public SecurityHelpFunctionData FindAll()
          {
            IRepository<SecurityHelpFeatureEntity> repositorySecurityHelpFeatureEntity = repository.GetRepository<IRepository<SecurityHelpFeatureEntity>>();
            IRepository<SecurityHelpFeatureGroupEntity> repositorySecurityHelpFeatureGroupEntity = repository.GetRepository<IRepository<SecurityHelpFeatureGroupEntity>>();
            IRepository<SecurityHelpFunctionFeatureEntity> repositorySecurityHelpFunctionFeatureEntity = repository.GetRepository<IRepository<SecurityHelpFunctionFeatureEntity>>();
            IRepository<SecurityHelpStepEntity> repositorySecurityHelpStepEntity = repository.GetRepository<IRepository<SecurityHelpStepEntity>>();

            SecurityHelpFunctionData data = new SecurityHelpFunctionData();
            data.SecurityHelpFunctions = repository.DetachedEntities.ToArray();
            data.SecurityHelpFeatures = repositorySecurityHelpFeatureEntity.DetachedEntities.ToArray();
            data.SecurityHelpFunctionFeatures = repositorySecurityHelpFunctionFeatureEntity.DetachedEntities.ToArray();
            data.SecurityHelpFeatureGroups = repositorySecurityHelpFeatureGroupEntity.DetachedEntities.ToArray();
            data.SecurityHelpSteps = repositorySecurityHelpStepEntity.DetachedEntities.ToArray();

            return data;
        }

        [PermissionOperate(name: SecurityPermissionPolicy.SecurityHelpFunction, operate: Operate.Find)]
        public SecurityHelpFunctionResultData FindBySearchCriteria(SecurityHelpFunctionSearchCriteria criteria)
        {
            SecurityHelpFunctionResultData data = new SecurityHelpFunctionResultData();
            SecurityHelpFunctionEntity[] list = null;

            Int64 count = 0;

            string sqlWhere = null;

            if (criteria.Filter != null && criteria.Filter.Length > 0)
            {
                sqlWhere = SearchFilter.ComposeWhereClause(criteria.Filter);
            }

            SecurityHelpFunctionEntity entity = SecurityHelpFunctionEntity.GetInstance(repository.GetDbContext().Database.ProviderName);
            string sql = entity.GetSelectTopFrom(criteria.limit, criteria.page, criteria.orderby.StringToDbField(), criteria.orderbytag, sqlWhere);

            string err = null;
            try
            {
                list = repository.FromSql(sql).ToArray();
            }
            catch (System.Exception ex)
            {
                err = ex.Message;
            }

            if (list != null && list.Length > 0)
            {
                sql = entity.GetSelectCountFrom(sqlWhere);
                count = Convert.ToInt64(repository.ExecuteScalar(sql));

                data.Datas = list;
            }
            else
            {
                data.Datas = null;
            }

            data.Limit = criteria.limit;
            data.Page = criteria.page;

            data.Total = count;
            data.ErrorMessage = err;
            return data;
        }

        [PermissionOperate(name: SecurityPermissionPolicy.SecurityHelpFunction, operate: Operate.Find)]
        public SecurityHelpFunctionResultData FindFeatureBySearchCriteria(SecurityHelpFunctionSearchCriteria criteria)
        {
            SecurityHelpFunctionResultData data = new SecurityHelpFunctionResultData();

            IRepository<SecurityHelpFeatureEntity> repositoryFeature = repository.GetRepository<IRepository<SecurityHelpFeatureEntity>>();

            SecurityHelpFeatureEntity[] list = null;

            Int64 count = 0;

            string sqlWhere = null;

            if (criteria.Filter != null && criteria.Filter.Length > 0)
            {
                sqlWhere = SearchFilter.ComposeWhereClause(criteria.Filter);
            }

            SecurityHelpFeatureEntity entity = SecurityHelpFeatureEntity.GetInstance(repositoryFeature.GetDbContext().Database.ProviderName);
            string sql = entity.GetSelectTopFrom(criteria.limit, criteria.page, criteria.orderby.StringToDbField(), criteria.orderbytag, sqlWhere);

            string err = null;
            try
            {
                list = repositoryFeature.FromSql(sql).ToArray();
            }
            catch (System.Exception ex)
            {
                err = ex.Message;
            }

            if (list != null && list.Length > 0)
            {
                sql = entity.GetSelectCountFrom(sqlWhere);
                count = Convert.ToInt64(repositoryFeature.ExecuteScalar(sql));

                data.Features = list;
            }
            else
            {
                data.Features = null;
            }

            data.Limit = criteria.limit;
            data.Page = criteria.page;

            data.Total = count;
            data.ErrorMessage = err;
            return data;
        }

        //[PermissionOperate(name: SecurityPermissionPolicy.SecurityHelpFunction, operate: Operate.Print)]
        public dynamic PrintBySearchCriteria(SecurityHelpFunctionSearchCriteria criteria)
        {
            throw new NotImplementedException();
        }

        [PermissionOperate(name: SecurityPermissionPolicy.SecurityHelpFunction, operate: Operate.Insert)]
        [UnitOfWork]
        public SecurityHelpFunctionData Insert(SecurityHelpFunctionData data)
        {
            throw new NotImplementedException();
        }

        [PermissionOperate(name: SecurityPermissionPolicy.SecurityHelpFunction, operate: Operate.Update)]
        [UnitOfWork]
        public SecurityHelpFunctionData Update(SecurityHelpFunctionData data)
        {
            throw new NotImplementedException();
        }


        [PermissionOperate(name: SecurityPermissionPolicy.SecurityHelpFunction, operate: Operate.Delete)]
        [UnitOfWork]
        public void Delete(string key)
        {
            var ent = repository.DetachedEntities.Where(x => x.HelpFunctionId == key).FirstOrDefault()!;
            if (ent == null) { throw new ValidatedException("记录不存在."); }

            repository.DeleteNow(ent);

            // 一并清掉关联明细，避免留下孤儿记录
            DeleteSteps(ent.HelpFunctionId);
            DeleteFunctionFeatures(ent.FunctionName);
        }

        //==================== 帮助文档维护：主表 + 步骤 + 引用的组 ====================

        [PermissionOperate(name: SecurityPermissionPolicy.SecurityHelpFunction, operate: Operate.Find)]
        public SecurityHelpFunctionData FindByFunctionName(string functionName)
        {
            SecurityHelpFunctionData data = new SecurityHelpFunctionData();
            if (string.IsNullOrEmpty(functionName)) return data;

            SecurityHelpFunctionEntity function = repository.DetachedEntities.Where(x => x.FunctionName == functionName).FirstOrDefault();
            if (function == null) return data;

            data.SecurityHelpFunction = function;

            data.SecurityHelpSteps = repository.GetRepository<IRepository<SecurityHelpStepEntity>>()
                .DetachedEntities.Where(x => x.HelpFunctionId == function.HelpFunctionId)
                .OrderBy(x => x.StepNo).ToArray();

            data.SecurityHelpFunctionFeatures = repository.GetRepository<IRepository<SecurityHelpFunctionFeatureEntity>>()
                .DetachedEntities.Where(x => x.FunctionName == functionName)
                .OrderBy(x => x.SortNo).ToArray();

            return data;
        }

        [PermissionOperate(name: SecurityPermissionPolicy.SecurityHelpFunction, operate: Operate.Update)]
        [UnitOfWork]
        public SecurityHelpFunctionData SaveFunction(SecurityHelpFunctionData data)
        {
            if (data == null || data.SecurityHelpFunction == null) throw new ValidatedException("没有要保存的内容.");

            SecurityHelpFunctionEntity function = data.SecurityHelpFunction;

            ValidateHelper.Validate(service, function, SecurityHelpFunctionEntity.DB_NAME_SECURITY_HELP_FUNCTION);

            SecurityHelpFunctionEntity exist = repository.DetachedEntities.Where(x => x.FunctionName == function.FunctionName).FirstOrDefault();

            if (exist == null)
            {
                if (string.IsNullOrEmpty(function.HelpFunctionId))
                {
                    function.HelpFunctionId = NewId(SecurityPrefixPolicy.SECURITY_HELP_FUNCTION_ID);
                }
                repository.InsertNow(function);
            }
            else
            {
                ObjectCopyHelper.Copy(function, exist);
                repository.UpdateNow(exist);
                function = exist;
            }

            SaveSteps(function.HelpFunctionId, data.SecurityHelpSteps);
            SaveFunctionFeatures(function.FunctionName, data.SecurityHelpFunctionFeatures);

            return FindByFunctionName(function.FunctionName);
        }

        [PermissionOperate(name: SecurityPermissionPolicy.SecurityHelpFunction, operate: Operate.Delete)]
        [UnitOfWork]
        public void DeleteByFunctionName(string functionName)
        {
            SecurityHelpFunctionEntity function = repository.DetachedEntities.Where(x => x.FunctionName == functionName).FirstOrDefault();
            if (function == null) throw new ValidatedException("记录不存在.");

            repository.DeleteNow(function);

            DeleteSteps(function.HelpFunctionId);
            DeleteFunctionFeatures(function.FunctionName);
        }

        //==================== 功能点组维护：组 + 组内功能点 ====================

        [PermissionOperate(name: SecurityPermissionPolicy.SecurityHelpFunction, operate: Operate.Find)]
        public SecurityHelpFeatureData FindByGroupCode(string groupCode)
        {
            SecurityHelpFeatureData data = new SecurityHelpFeatureData();
            if (string.IsNullOrEmpty(groupCode)) return data;

            IRepository<SecurityHelpFeatureGroupEntity> repositoryGroup = repository.GetRepository<IRepository<SecurityHelpFeatureGroupEntity>>();

            SecurityHelpFeatureGroupEntity group = repositoryGroup.DetachedEntities.Where(x => x.GroupCode == groupCode).FirstOrDefault();
            if (group == null) return data;

            data.SecurityHelpFeatureGroup = group;

            data.SecurityHelpFeatures = repository.GetRepository<IRepository<SecurityHelpFeatureEntity>>()
                .DetachedEntities.Where(x => x.HelpFeatureGroupId == group.HelpFeatureGroupId)
                .OrderBy(x => x.SortNo).ToArray();

            return data;
        }

        [PermissionOperate(name: SecurityPermissionPolicy.SecurityHelpFunction, operate: Operate.Update)]
        [UnitOfWork]
        public SecurityHelpFeatureData SaveFeatureGroup(SecurityHelpFeatureData data)
        {
            if (data == null || data.SecurityHelpFeatureGroup == null) throw new ValidatedException("没有要保存的内容.");

            IRepository<SecurityHelpFeatureGroupEntity> repositoryGroup = repository.GetRepository<IRepository<SecurityHelpFeatureGroupEntity>>();

            SecurityHelpFeatureGroupEntity group = data.SecurityHelpFeatureGroup;

            SecurityHelpFeatureGroupEntity exist = repositoryGroup.DetachedEntities.Where(x => x.GroupCode == group.GroupCode).FirstOrDefault();

            if (exist == null)
            {
                if (string.IsNullOrEmpty(group.HelpFeatureGroupId))
                {
                    group.HelpFeatureGroupId = NewId(SecurityPrefixPolicy.SECURITY_HELP_FEATURE_GROUP_ID);
                }
                repositoryGroup.InsertNow(group);
            }
            else
            {
                ObjectCopyHelper.Copy(group, exist);
                repositoryGroup.UpdateNow(exist);
                group = exist;
            }

            SaveFeatures(group.HelpFeatureGroupId, data.SecurityHelpFeatures);

            return FindByGroupCode(group.GroupCode);
        }

        [PermissionOperate(name: SecurityPermissionPolicy.SecurityHelpFunction, operate: Operate.Delete)]
        [UnitOfWork]
        public void DeleteByGroupCode(string groupCode)
        {
            IRepository<SecurityHelpFeatureGroupEntity> repositoryGroup = repository.GetRepository<IRepository<SecurityHelpFeatureGroupEntity>>();

            SecurityHelpFeatureGroupEntity group = repositoryGroup.DetachedEntities.Where(x => x.GroupCode == groupCode).FirstOrDefault();
            if (group == null) throw new ValidatedException("记录不存在.");

            repositoryGroup.DeleteNow(group);

            DeleteFeatures(group.HelpFeatureGroupId);
        }

        //==================== 下拉选项 ====================

        [AllowAnonymous]
        public SecurityFunctionDisplayData[] FindFunctionNameOptions()
        {
            return service.ServiceProvider.GetService<ISecurityFunctionService>()!.FindMenus();
        }

        //==================== 私有辅助 ====================

        /// <summary>
        /// 生成主键，走统一的流水号服务
        /// </summary>
        private string NewId(string subsystemId)
        {
            ISecurityGeneratorNumberService generatorNumberService = service.ServiceProvider.GetService<ISecurityGeneratorNumberService>()!;

            return generatorNumberService.GetNo(
                SecurityPrefixPolicy.SECURITY_HELP,
                subsystemId,
                null,
                YesNoPolicy.NO,
                SecurityPrefixPolicy.SECURITY_HELP_FORMAT);
        }

        /// <summary>
        /// 步骤整存：先清旧再插新，StepNo 按传入顺序重排
        /// </summary>
        private void SaveSteps(string helpFunctionId, SecurityHelpStepEntity[]? steps)
        {
            IRepository<SecurityHelpStepEntity> repositoryStep = repository.GetRepository<IRepository<SecurityHelpStepEntity>>();

            SecurityHelpStepEntity[] olds = repositoryStep.Entities.Where(x => x.HelpFunctionId == helpFunctionId).ToArray();
            if (olds != null && olds.Length > 0)
            {
                foreach (SecurityHelpStepEntity old in olds) repositoryStep.DeleteNow(old);
            }

            if (steps == null || steps.Length == 0) return;

            int i = 1;
            foreach (SecurityHelpStepEntity step in steps.OrderBy(x => x.StepNo).ToArray())
            {
                if (string.IsNullOrEmpty(step.HelpStepId))
                {
                    step.HelpStepId = NewId(SecurityPrefixPolicy.SECURITY_HELP_STEP_ID);
                }
                step.HelpFunctionId = helpFunctionId;
                step.StepNo = i++;

                repositoryStep.InsertNow(step);
            }
        }

        /// <summary>
        /// 组合关系整存：先清旧再插新，SortNo 按传入顺序重排
        /// </summary>
        private void SaveFunctionFeatures(string functionName, SecurityHelpFunctionFeatureEntity[]? functionFeatures)
        {
            IRepository<SecurityHelpFunctionFeatureEntity> repositoryFunctionFeature = repository.GetRepository<IRepository<SecurityHelpFunctionFeatureEntity>>();

            SecurityHelpFunctionFeatureEntity[] olds = repositoryFunctionFeature.Entities.Where(x => x.FunctionName == functionName).ToArray();
            if (olds != null && olds.Length > 0)
            {
                foreach (SecurityHelpFunctionFeatureEntity old in olds) repositoryFunctionFeature.DeleteNow(old);
            }

            if (functionFeatures == null || functionFeatures.Length == 0) return;

            int i = 1;
            foreach (SecurityHelpFunctionFeatureEntity functionFeature in functionFeatures.OrderBy(x => x.SortNo).ToArray())
            {
                if (string.IsNullOrEmpty(functionFeature.HelpFunctionFeatureId))
                {
                    functionFeature.HelpFunctionFeatureId = NewId(SecurityPrefixPolicy.SECURITY_HELP_FUNCTION_FEATURE_ID);
                }
                functionFeature.FunctionName = functionName;
                functionFeature.SortNo = i++;

                repositoryFunctionFeature.InsertNow(functionFeature);
            }
        }

        /// <summary>
        /// 组内功能点整存：先清旧再插新，SortNo 按传入顺序重排
        /// </summary>
        private void SaveFeatures(string helpFeatureGroupId, SecurityHelpFeatureEntity[]? features)
        {
            IRepository<SecurityHelpFeatureEntity> repositoryFeature = repository.GetRepository<IRepository<SecurityHelpFeatureEntity>>();

            SecurityHelpFeatureEntity[] olds = repositoryFeature.Entities.Where(x => x.HelpFeatureGroupId == helpFeatureGroupId).ToArray();
            if (olds != null && olds.Length > 0)
            {
                foreach (SecurityHelpFeatureEntity old in olds) repositoryFeature.DeleteNow(old);
            }

            if (features == null || features.Length == 0) return;

            int i = 1;
            foreach (SecurityHelpFeatureEntity feature in features.OrderBy(x => x.SortNo).ToArray())
            {
                if (string.IsNullOrEmpty(feature.HelpFeatureId))
                {
                    feature.HelpFeatureId = NewId(SecurityPrefixPolicy.SECURITY_HELP_FEATURE_ID);
                }
                feature.HelpFeatureGroupId = helpFeatureGroupId;
                feature.SortNo = i++;

                repositoryFeature.InsertNow(feature);
            }
        }

        private void DeleteSteps(string helpFunctionId)
        {
            IRepository<SecurityHelpStepEntity> repositoryStep = repository.GetRepository<IRepository<SecurityHelpStepEntity>>();

            SecurityHelpStepEntity[] olds = repositoryStep.Entities.Where(x => x.HelpFunctionId == helpFunctionId).ToArray();
            if (olds == null || olds.Length == 0) return;

            foreach (SecurityHelpStepEntity old in olds) repositoryStep.DeleteNow(old);
        }

        private void DeleteFunctionFeatures(string functionName)
        {
            IRepository<SecurityHelpFunctionFeatureEntity> repositoryFunctionFeature = repository.GetRepository<IRepository<SecurityHelpFunctionFeatureEntity>>();

            SecurityHelpFunctionFeatureEntity[] olds = repositoryFunctionFeature.Entities.Where(x => x.FunctionName == functionName).ToArray();
            if (olds == null || olds.Length == 0) return;

            foreach (SecurityHelpFunctionFeatureEntity old in olds) repositoryFunctionFeature.DeleteNow(old);
        }

        private void DeleteFeatures(string helpFeatureGroupId)
        {
            IRepository<SecurityHelpFeatureEntity> repositoryFeature = repository.GetRepository<IRepository<SecurityHelpFeatureEntity>>();

            SecurityHelpFeatureEntity[] olds = repositoryFeature.Entities.Where(x => x.HelpFeatureGroupId == helpFeatureGroupId).ToArray();
            if (olds == null || olds.Length == 0) return;

            foreach (SecurityHelpFeatureEntity old in olds) repositoryFeature.DeleteNow(old);
        }
    }
}