using Fake;
using InterfaceForward.Domain.Shared.Dtos;
using InterfaceForward.Domain.Shared.Enum;
using InterfaceForward.Domain.Shared.Helpers;
using InterfaceForward.Repositories.App.Entitys;
using InterfaceForward.Repositories.App.ValueObjects;
using InterfaceForward.Repositories.Dictionary.Entitys;
using InterfaceForward.Repositories.Interface.Entitys;
using InterfaceForward.Repositories.Parameter.Entities;
using InterfaceForward.Repositories.ServiceProvider.Entitys;

namespace InterfaceForward.Repositories;

/// <summary>
/// 
/// </summary>
public class InterfaceForwardQuery : BasicRepository<FixedParameterEntity>, IScopedDependency
{
    /// <summary>
    /// 通过服务商id和主体id查找账户id，如果账户不存在则返回null
    /// </summary>
    /// <param name="serviceProviderId">服务商id</param>
    /// <param name="appId">应用id</param>
    /// <returns></returns>
    public async Task<int> GetAccountIdAsync(int serviceProviderId, int appId)
    {
        return await Context.Queryable<ServiceProviderAccountEntity>()
            .Where(x => x.ServiceProviderId == serviceProviderId && x.AppId == appId)
            .Select(x => x.Id)
            .FirstAsync();
    }


    /// <summary>
    /// 通过服务商code获取服务商
    /// </summary>
    /// <param name="serviceProviderCode">服务商code</param>
    /// <returns></returns>
    public async Task<ServiceProviderDto> GetServiceProviderByCodeAsync(string serviceProviderCode)
    {
        return await Context.Queryable<ServiceProviderEntity>()
            .Where(x => x.Code == serviceProviderCode).Select<ServiceProviderDto>()
            .FirstAsync();
    }

    /// <summary>
    /// 通过服务商Id获取服务商
    /// </summary>
    /// <param name="serviceProviderId">服务商Id</param>
    /// <returns></returns>
    public async Task<ServiceProviderDto> GetServiceProviderByIdAsync(int serviceProviderId)
    {
        return await Context.Queryable<ServiceProviderEntity>()
            .Where(x => x.Id == serviceProviderId).Select<ServiceProviderDto>()
            .FirstAsync();
    }

    /// <summary>
    /// 通过账户id获取账户字段列表
    /// </summary>
    /// <param name="accountId">账户id</param>
    /// <returns></returns>
    public async Task<List<ServiceProviderAccountFieldWithValueDto>> GetAccountFieldListAsync(int accountId)
    {
        if (accountId == default) return new List<ServiceProviderAccountFieldWithValueDto>();
        var query = Context.Queryable<ServiceProviderAccountFieldEntity>()
            .LeftJoin<ServiceProviderAccountFieldValueEntity>((a, b) => a.Id == b.AccountFieldId);

        return await query.Where((a, b) => b.AccountId == accountId)
            .Select((a, b) => new ServiceProviderAccountFieldWithValueDto
            {
                FieldName = a.FieldName,
                FieldValue = b.FieldValue
            })
            .ToListAsync();
    }

    /// <summary>
    /// 查找app
    /// </summary>
    /// <param name="appKey"></param>
    /// <param name="appSecret"></param>
    /// <returns></returns>
    public async Task<AppVO> FindAppAsync(string appKey, string appSecret)
    {
        return await Context.Queryable<AppEntity>()
            .Where(x => x.AppKey == appKey && x.AppSecret == appSecret)
            .Select<AppVO>()
            .FirstAsync();
    }

    /// <summary>
    /// 获取接口QPS
    /// </summary>
    /// <param name="appId"></param>
    /// <param name="interfaceCode"></param>
    /// <returns></returns>
    public async Task<int> GetQpsAsync(int appId, string interfaceCode)
    {
        return await Context.Queryable<AppScopeEntity>()
            .Where(x =>
                x.AppId == appId && x.InterfaceCode == interfaceCode)
            .Select(x => x.QPS)
            .FirstAsync();
    }

    /// <summary>
    /// 获取参数映射列表
    /// </summary>
    /// <param name="mapIds">映射id集合</param>
    /// <param name="isInParaMap">是入参映射</param>
    /// <returns></returns>
    public async Task<IReadOnlyCollection<InterfaceParameterMapDto>> GetParameterMapListAsync(List<int> mapIds,
        bool isInParaMap)
    {
        // tips：这里要拿所有节点，而非仅叶子，因为要构建参数树

        /*
SELECT  `b`.`Id` AS `Id` , `b`.`PId` AS `PId` , b.InterfaceId, `b`.`Name` AS `Name` ,b.Sort, `b`.`Type` AS `Type` , `b`.`Alias` AS `Alias` , CONCAT(d.Code, '.', c.Alias) AS `MapAlias` , `b`.`IsRequired` AS `IsRequired` 
from t_interface_map t 
LEFT JOIN `t_parameter` `b` ON ( `t`.`DownStreamId` = `b`.`InterfaceId` ) and b.IsInPara and `b`.`IsDeleted` = 0 -- AND ( `b`.`Type` <> 12 ) AND ( `b`.`Type` <> 10 )
Left JOIN `t_interface_map_detail` `a` ON ( `t`.`Id` = `a`.`InterfaceMapId` )  and b.id = a.ParaId and a.IsDeleted = 0
Left JOIN `t_parameter` `c` ON ( `a`.`MappedParaId` = `c`.`Id` )  AND ( `c`.`IsDeleted` = 0 )
Left JOIN t_interface d on c.interfaceid = d.id
WHERE t.id in (403) and t.IsDeleted = 0 
ORDER BY `b`.`Sort` ASC
*/
        var ids = mapIds.JoinAsString(",");
        var isMultiMap = mapIds.Count > 1;
        // 因为入参映射有多个 出参映射只有一个（挂在第一个映射）
        return await Context.SqlQueryable<InterfaceParameterMapDto>(@$"
select `b`.`Id` AS `Id` , `b`.`PId` AS `PId` , b.InterfaceId, `b`.`Name` AS `Name` ,b.Sort, `b`.`Type` AS `Type` , `b`.`Alias` AS `Alias` , {(isMultiMap ? "CONCAT(d.Code, '.', c.Alias)" : "c.Alias")} AS `MapAlias` , `b`.`IsRequired` AS `IsRequired`  
from t_interface_map t 
LEFT JOIN `t_parameter` `b` ON {(isInParaMap ? "t.DownStreamId" : "t.UpStreamId")} = `b`.`InterfaceId` and b.IsInPara = {isInParaMap} AND ( `b`.`IsDeleted` = 0 )
Left JOIN `t_interface_map_detail` `a` ON ( `t`.`Id` = `a`.`InterfaceMapId` )  and b.id = a.ParaId and a.IsDeleted = 0
Left JOIN `t_parameter` `c` ON ( `a`.`MappedParaId` = `c`.`Id` )  AND ( `c`.`IsDeleted` = 0 )
Left JOIN t_interface d on c.interfaceid = d.id
WHERE {(isInParaMap ? $"t.id in ({ids})" : $"t.id = {mapIds.First()}")} and t.IsDeleted = 0
ORDER BY `b`.`Sort` ASC").ToListAsync();
    }

    /// <summary>
    /// 获取接口根据接口code
    /// </summary>
    /// <param name="interfaceCode"></param>
    /// <returns></returns>
    public async Task<InterfaceDto?> GetInterfaceByCodeAsync(string interfaceCode)
    {
        var res = await GetInterfaceByCodesAsync(interfaceCode);
        return res.FirstOrDefault();
    }

    /// <summary>
    /// 构建转发核心上下文
    /// </summary>
    /// <param name="systemInterface"></param>
    /// <param name="serviceProvider"></param>
    /// <returns></returns>
    /// <exception cref="BusinessException"></exception>
    public async Task<ForwardCoreContextCache> BuildForwardCoreContext(InterfaceDto systemInterface,
        ServiceProviderDto serviceProvider)
    {
        var maps = await Context.Queryable<InterfaceMapEntity>()
            .Where(x => x.UpStreamCode == systemInterface.Code && x.ServiceProviderId == serviceProvider.Id)
            .Select(x => new { x.Id, x.DownStreamCode, x.PrefixScript, x.PostfixScript })
            .ToArrayAsync();
        if (maps == null || maps.Length == 0) throw new BusinessException(message: "映射不存在");

        var downStreamIds = maps.Select(x => x.DownStreamCode).ToArray();
        var targetInterfaceList = await GetInterfaceByCodesAsync(downStreamIds);
        if (targetInterfaceList == null || targetInterfaceList.Count != downStreamIds.Length)
            throw new BusinessException(message: "服务商一个或多个接口不存在");

        var mapIds = maps.Select(x => x.Id).ToList();
        var context = new ForwardCoreContextCache
        {
            OriginalInterface = systemInterface,
            TargetServiceProvider = serviceProvider,
            ServiceProviderAuthConfigs = await Context.Queryable<ServiceProviderAuthConfigEntity>()
                .LeftJoin<ParameterEntity>((a, b) => a.ParameterId == b.Id)
                .Where(a => a.ServiceProviderId == serviceProvider.Id)
                .Select((a, b) => new ServiceProviderAuthConfigDto
                {
                    Flag = a.Flag,
                    ParameterAlias = b.Alias,
                    Value1 = a.Value1,
                    Value2 = a.Value2,
                    Value3 = a.Value3
                })
                .ToListAsync(),
            OutParamTreeList = JsonHelper.BuildTreeList(
                await GetParameterMapListAsync(mapIds, false)
            ) // 构建系统返参数树形结构
        };

        if (serviceProvider.AuthInterfaceCode != null)
        {
            var authInterface = await GetInterfaceByCodeAsync(serviceProvider.AuthInterfaceCode);
            if (authInterface == null)
            {
                throw new BusinessException($"授权接口{serviceProvider.AuthInterfaceCode}不存在");
            }
            
            context.ServiceProviderAuthInterface = new TargetInterfaceSummary
            {
                TargetInterface = authInterface,
                FixedFieldList = await GetAllFixedFieldListAsync(serviceProvider.Id, authInterface.Id),
                ReturnConfigList = await GetInterfaceReturnConfigListAsync(authInterface.Id),
                FormFieldList = await GetFormFieldListAsync(authInterface.Id),
            };
        }

        var inParaMaps = await GetParameterMapListAsync(mapIds, true);
        foreach (var map in maps)
        {
            var targetInterface = targetInterfaceList.First(x => map.DownStreamCode == x.Code);
            var items = inParaMaps.Where(x => x.InterfaceId == targetInterface.Id).ToList();
            var fixedFieldList = await GetAllFixedFieldListAsync(serviceProvider.Id, targetInterface.Id);
            if (targetInterface.MappedParamType == ParameterType.Array)
            {
                var rootLen = items.First(x => x.PId == 0).Alias.Length;
                foreach (var item in fixedFieldList.Where(x => x.FieldPosition == FieldPosition.Body))
                {
                    // 去除固定参数[*]前面的路径
                    item.FieldName = item.FieldName[rootLen..];
                }
            }

            context.TargetInterfaces.Add(new TargetInterfaceSummary
            {
                TargetInterface = targetInterface,
                InParamTreeList = JsonHelper.BuildTreeList(items), // 构建目标接口入参树形结构
                FixedFieldList = fixedFieldList,
                ReturnConfigList = await GetInterfaceReturnConfigListAsync(targetInterface.Id),
                PrefixScript = map.PrefixScript,
                PostfixScript = map.PostfixScript,
                FormFieldList = await GetFormFieldListAsync(targetInterface.Id),
            });
        }

        return context;
    }

    private async Task<List<InterfaceFormFieldDto>> GetFormFieldListAsync(int interfaceId)
    {
        return await Context.Queryable<FormParameterEntity>()
            .Where(x => x.InterfaceId == interfaceId)
            .Select<InterfaceFormFieldDto>()
            .ToListAsync();
    }

    /// <summary>
    /// 获取所有固定字段（服务商+接口）
    /// </summary>
    /// <param name="serviceProviderId">服务商id</param>
    /// <param name="interfaceId">接口id</param>
    /// <returns></returns>
    private async Task<List<FixedFieldWithValueDto>> GetAllFixedFieldListAsync(int serviceProviderId,
        int interfaceId)
    {
        var fixedFieldList = await Context.Queryable<FixedParameterEntity>()
            .Where(a => a.ServiceProviderId == serviceProviderId || a.InterfaceId == interfaceId)
            .Select(x => new
            {
                x.ServiceProviderId,
                x.InterfaceId,
                x.FieldName,
                x.FieldValue,
                x.FieldPositions,
                x.Description
            })
            .ToListAsync();

        // 接口字段
        var list1 = from interfaceField in fixedFieldList.Where(x => x.InterfaceId == interfaceId)
            from position in interfaceField.FieldPositions.Split(",").Select(Enum.Parse<FieldPosition>)
            select new FixedFieldWithValueDto
            {
                FieldOwner = FieldOwner.Interface, FieldName = interfaceField.FieldName,
                FieldValue = interfaceField.FieldValue, Description = interfaceField.Description,
                FieldPosition = position,
            };

        // 接口不曾拥有的服务商参数
        var list2 = from serviceProviderField in fixedFieldList.Where(x => x.ServiceProviderId == serviceProviderId)
            from position in serviceProviderField.FieldPositions.Split(",")
                .Select(Enum.Parse<FieldPosition>)
            where !list1.Any(it => it.FieldName.Equals(serviceProviderField.FieldName) && it.FieldPosition == position)
            select new FixedFieldWithValueDto
            {
                FieldOwner = FieldOwner.ServiceProvider, FieldName = serviceProviderField.FieldName,
                FieldValue = serviceProviderField.FieldValue, Description = serviceProviderField.Description,
                FieldPosition = position,
            };

        return list1.Concat(list2).ToList();
    }

    /// <summary>
    /// 获取接口返回配置集合
    /// </summary>
    /// <param name="interfaceId">接口id</param>
    /// <returns></returns>
    private async Task<List<InterfaceReturnConfigDto>> GetInterfaceReturnConfigListAsync(int interfaceId)
    {
        return await Context.Queryable<InterfaceReturnConfigEntity>()
            .LeftJoin<ParameterEntity>((a, b) => a.ParameterId == b.Id)
            .Where(a => a.InterfaceId == interfaceId)
            .Select((a, b) => new InterfaceReturnConfigDto
            {
                InterfaceId = a.InterfaceId,
                ConfigType = a.ConfigType,
                Path = b.Alias,
                Value = a.Value,
            }).ToListAsync();
    }

    /// <summary>
    /// 获取接口根据接口code
    /// </summary>
    /// <param name="interfaceCodes"></param>
    /// <returns></returns>
    private async Task<List<InterfaceDto>> GetInterfaceByCodesAsync(params string[] interfaceCodes)
    {
        var query = Context.Queryable<InterfaceEntity, DictionaryEntity>(
                (a, d) => new JoinQueryInfos(
                    JoinType.Left, a.RequestMethod == d.Id
                ))
            .Where(a => interfaceCodes.Contains(a.Code) && a.IsDeleted == false)
            .Filter(null, true)
            .Select((a, d) =>
                new InterfaceDto
                {
                    Id = a.Id,
                    Name = a.Name,
                    ServiceProviderId = a.ServiceProviderId,
                    Code = a.Code,
                    RequestAddress = a.RequestAddress,
                    RequestProtocol = a.RequestProtocol,
                    ContentType = a.ContentType,
                    ResponseContentType = a.ResponseContentType,
                    RequestMethod = d.Name,
                    IsBatch = a.IsBatch,
                    Limit = a.Limit,
                    Qps = a.Qps,
                    FlowCode = a.FlowCode,
                    IsDisableAuth = a.IsDisableAuth,
                    MappedParamType = a.MappedParamType
                });

        return await query.ToListAsync();
    }
}