using System.ComponentModel.DataAnnotations;
using InterfaceForward.Application.Contracts.Dtos.ServiceProvider;
using InterfaceForward.Application.Helpers;
using InterfaceForward.Domain.Shared.Enum;
using InterfaceForward.Repositories;
using InterfaceForward.Repositories.Interface.Entitys;
using InterfaceForward.Repositories.ServiceProvider.Entitys;
using InterfaceForward.Repositories.ServiceProvider.Services;
using InterfaceForward.Repositories.ServiceProvider.ValueObjects;
using Microsoft.AspNetCore.Mvc;

namespace InterfaceForward.Application.Services.ServiceProvider;

/// <summary>
/// 服务商授权配置
/// </summary>
[ApiExplorerSettings(GroupName = "服务商服务")]
public class ServiceProviderAuthService : ApplicationService
{
    private readonly IBasicRepository<InterfaceEntity> _interfaceRepository;
    private readonly IBasicRepository<ParameterEntity> _parameterRepository;
    private readonly IBasicRepository<ServiceProviderAuthConfigEntity> _serviceProviderAuthConfigRepository;
    private readonly IServiceProviderRepository _serviceProviderRepository;

    public ServiceProviderAuthService(
        IBasicRepository<ServiceProviderAuthConfigEntity> serviceProviderAuthConfigRepository,
        IBasicRepository<InterfaceEntity> interfaceRepository, IServiceProviderRepository serviceProviderRepository,
        IBasicRepository<ParameterEntity> parameterRepository)
    {
        _serviceProviderAuthConfigRepository = serviceProviderAuthConfigRepository;
        _interfaceRepository = interfaceRepository;
        _serviceProviderRepository = serviceProviderRepository;
        _parameterRepository = parameterRepository;
    }

    /// <summary>
    /// 修改服务商授权接口
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    /// <exception cref="BusinessException"></exception>
    [HttpGet("ServiceProvider/ChangeAuthInterface")]
    public async Task<bool> ChangeAuthInterface(ChangeAuthInterfaceInput input)
    {
        var serviceProvider = await _serviceProviderRepository.GetFirstAsync(x =>
            x.Id == input.ServiceProviderId);
        if (serviceProvider == null)
        {
            throw new BusinessException(message: "服务商不存在");
        }

        serviceProvider.AuthInterfaceCode = input.InterfaceCode;
        return await _serviceProviderRepository.UpdateAsync(serviceProvider);
    }

    /// <summary>
    /// 获取服务商授权配置信息
    /// </summary>
    /// <param name="serviceProviderId"></param>
    /// <returns></returns>
    [HttpGet("ServiceProvider/GetAuthInfo")]
    public async Task<ServiceProviderAuthInfoOutput> GetAuthInfo([Required] int serviceProviderId)
    {
        var res = new ServiceProviderAuthInfoOutput();
        var interfaceCode = await _serviceProviderRepository.GetFirstAsync(x =>
            x.Id == serviceProviderId, x => x.AuthInterfaceCode);
        if (interfaceCode.IsNullOrEmpty())
        {
            return res;
        }

        res.InterfaceCode = interfaceCode;
        var interfaceId = await _interfaceRepository.GetFirstAsync(x => x.Code == interfaceCode, x => x.Id);
        if (interfaceId == default)
        {
            return res;
        }

        res.InterfaceId = interfaceId;

        var parameters = await _parameterRepository.GetListAsync(x => x.InterfaceId == interfaceId && x.IsInPara);

        var authConfigs =
            await _serviceProviderAuthConfigRepository.GetListAsync(x => x.ServiceProviderId == serviceProviderId);
        var inParameterConfigs = authConfigs.Where(x => x.Flag == AuthParameterFlag.InParameter);
        res.InParameterSummaries = parameters.Select(parameter =>
        {
            return new AuthInParameterSummary
            {
                Id = parameter.Id,
                Name = parameter.Name,
                CnName = parameter.CnName,
                Type = parameter.Type.ToString(),
                IsRequired = parameter.IsRequired,
                Value = inParameterConfigs.FirstOrDefault(it => it.ParameterId == parameter.Id)?.Value1
            };
        }).ToList();

        var tokenConfig = authConfigs.FirstOrDefault(x => x.Flag == AuthParameterFlag.Token);
        res.TokenParameterId = tokenConfig?.ParameterId;
        res.TokenPrefix = tokenConfig?.Value1;

        var effectTimeConfig = authConfigs.FirstOrDefault(x => x.Flag == AuthParameterFlag.EffectTime);
        if (effectTimeConfig != null)
        {
            res.EffectTimeParameterId = effectTimeConfig.ParameterId;
            res.EffectTimeUnit = Enum.Parse<EffectTimeUnit>(effectTimeConfig.Value1);
        }

        res.FixedEffectTime = authConfigs.FirstOrDefault(x => x.Flag == AuthParameterFlag.FixedEffectTime)?.Value1.ToInt();
        res.Script = authConfigs.FirstOrDefault(x => x.Flag == AuthParameterFlag.Script)?.Value1;

        return res;
    }

    /// <summary>
    /// 保存服务商授权配置信息
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("ServiceProvider/SaveAuthInfo")]
    public async Task<bool> SaveAuthInfo(ServiceProviderAuthInfoInput input)
    {
        var serviceProvider = await _serviceProviderRepository.GetFirstAsync(x =>
            x.Id == input.ServiceProviderId);
        if (serviceProvider == null)
        {
            throw new BusinessException(message: "服务商不存在");
        }

        var authConfigsEntities = BuildServiceProviderAuthConfigEntities(input);

        using var ts = TransacationHelper.GetReadCommitted();
        await _serviceProviderAuthConfigRepository.SoftDeleteAsync(x => x.ServiceProviderId == input.ServiceProviderId);
        await _serviceProviderAuthConfigRepository.InsertRangeAsync(authConfigsEntities);

        // del cache
        var keys = await RedisHelper.Client.KeysAsync(
            InterfaceForwardCommon.GetAccountCacheKey(serviceProvider.Code));
        foreach (var key in keys)
        {
            await RedisHelper.Client.DelAsync(key);
        }

        ts.Complete();

        return true;
    }

    private static List<ServiceProviderAuthConfigEntity> BuildServiceProviderAuthConfigEntities(
        ServiceProviderAuthInfoInput input)
    {
        var authConfigsEntities = new List<ServiceProviderAuthConfigEntity>();
        var inParameterConfigs = input.InParameters.Select(x => new ServiceProviderAuthConfigEntity
        {
            Flag = AuthParameterFlag.InParameter,
            ParameterId = x.Id,
            Value1 = x.Value,
        });
        authConfigsEntities.AddRange(inParameterConfigs);

        if (input.TokenParameterId != null)
        {
            authConfigsEntities.Add(new ServiceProviderAuthConfigEntity
            {
                Flag = AuthParameterFlag.Token,
                ParameterId = input.TokenParameterId,
                Value1 = input.TokenPrefix,
            });
        }

        if (input.EffectTimeParameterId != null)
        {
            authConfigsEntities.Add(new ServiceProviderAuthConfigEntity
            {
                Flag = AuthParameterFlag.EffectTime,
                ParameterId = input.EffectTimeParameterId,
                Value1 = input.EffectTimeUnit,
            });
        }

        if (input.FixedEffectTime != null && input.FixedEffectTime > 0)
        {
            authConfigsEntities.Add(new ServiceProviderAuthConfigEntity
            {
                Flag = AuthParameterFlag.FixedEffectTime,
                Value1 = input.FixedEffectTime.ToString(),
            });
        }

        if (!input.Script.IsNullOrWhiteSpace())
        {
            authConfigsEntities.Add(new ServiceProviderAuthConfigEntity
            {
                Flag = AuthParameterFlag.Script,
                Value1 = input.Script,
            });
        }

        authConfigsEntities.ForEach(x => x.ServiceProviderId = input.ServiceProviderId);
        return authConfigsEntities;
    }
}