using SJZY.Track.Application.Contract.Services;
using SJZY.Track.Domain.Aggregates.KPIAreaAggregate;
using SJZY.Track.Domain.Dtos.Forewarning;

namespace SJZY.Track.Application.Services.ForewarningServices;

[ApiExplorerSettings(GroupName = "预警服务")]
[Route("/ForewarningService")]
public class KpiAreaService : ApplicationService
{
    private readonly IForewarningCacheService _forewarningCacheService;
    private readonly IKpiAreaRepository _ruleAreaRepository;

    public KpiAreaService(IKpiAreaRepository ruleAreaRepository, IForewarningCacheService forewarningCacheService)
    {
        _ruleAreaRepository = ruleAreaRepository;
        _forewarningCacheService = forewarningCacheService;
    }

    /// <summary>
    /// 创建分区
    /// </summary>
    /// <param name="input"></param>
    /// <returns>分区id</returns>
    [HttpPost("KpiArea/CreateKpiArea")]
    public async ValueTask<UnifyResultDto> CreateKpiArea(CreateRuleAreaRequest input)
    {
        var ruleAreaEntity = ObjectMapper.Map<CreateRuleAreaRequest, RuleAreaEntity>(input);
        var hasSameName =
            await _ruleAreaRepository.IsAnyAsync(val => val.SubSystemId == input.SystemId && val.Name == input.Name);
        if (hasSameName)
        {
            return new UnifyResultDto(false, "分区名称重复，请重新修改提交");
        }

        var areaId = await _ruleAreaRepository.CreateAreaAsync(ruleAreaEntity);
        return new UnifyResultDto(true, areaId, "创建成功");
    }

    /// <summary>
    /// 添加区域信息
    /// </summary>
    /// <param name="input"></param>
    /// <returns>区域id</returns>
    [HttpPost("KpiArea/AddAreaInfo")]
    public async ValueTask<UnifyResultDto> AddAreaInfoAsync(AddRuleAreaInfoRequest input)
    {
        var ruleAreaEntity = ObjectMapper.Map<AddRuleAreaInfoRequest, RuleAreaInfoEntity>(input);
        var ruleInfoId = await _ruleAreaRepository.AddAreaInfoAsync(ruleAreaEntity);
        await _forewarningCacheService.ClearRedisByAreaId(input.AreaId);
        return new UnifyResultDto(true, ruleInfoId, "添加成功");
    }

    /// <summary>
    /// 删除分区
    /// </summary>
    /// <param name="id">分区id</param>
    /// <returns></returns>
    [HttpDelete("KpiArea/DeleteKpiArea")]
    public async ValueTask<UnifyResultDto> DeleteKpiArea(int id)
    {
        await _ruleAreaRepository.DeleteArea(id);
        await _forewarningCacheService.ClearRedisByAreaId(id);
        return new UnifyResultDto(true, "删除成功");
    }

    /// <summary>
    /// 删除分区信息
    /// </summary>
    /// <param name="id">分区信息id</param>
    /// <returns></returns>
    [HttpDelete("KpiArea/DeleteKpiAreaInfo")]
    public async ValueTask<UnifyResultDto> DeleteKpiAreaInfo(int id)
    {
        var info = await _ruleAreaRepository.GetAreaInfoById(id);
        if (info == null) return new UnifyResultDto(false, "未找到该区域信息");
        await _ruleAreaRepository.DeleteAreaInfo(id);
        await _forewarningCacheService.ClearRedisByAreaId(info.AreaId);
        return new UnifyResultDto(true, "删除成功");
    }

    /// <summary>
    /// 更新区域信息
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("KpiArea/ModifyKpiArea")]
    public async Task<UnifyResultDto> ModifyKpiArea(UpdateRuleAreaRequest input)
    {
        if (input.Id <= 0)
            return new UnifyResultDto(false, "id不能为空");

        var ruleArea = await _ruleAreaRepository.GetFirstAsync(val => val.Id == input.Id);
        if (ruleArea == null)
            return new UnifyResultDto(false, "未找到该区域");

        ruleArea.Name = input.Name;
        await _ruleAreaRepository.UpdateAsync(ruleArea);
        return new UnifyResultDto(true, "更新成功");
    }

    /// <summary>
    /// 更新区域信息
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("KpiArea/ModifyKpiAreaInfo")]
    public async Task<UnifyResultDto> ModifyKpiAreaInfo(UpdateRuleAreaInfoRequest input)
    {
        if (input.Id <= 0)
            return new UnifyResultDto(false, "id不能为空");

        var areaInfo = await _ruleAreaRepository.GetAreaInfoById(input.Id);
        if (areaInfo == null)
            return new UnifyResultDto(false, "未找到该区域信息");

        var ruleAreaEntity = ObjectMapper.Map(input, areaInfo);
        await _ruleAreaRepository.UpdateAreaInfoAsync(ruleAreaEntity);

        await _forewarningCacheService.ClearRedisByAreaId(areaInfo.AreaId);
        return new UnifyResultDto(true, "更新成功");
    }

    /// <summary>
    /// 查询分区列表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("KpiArea/GetKpiAreas")]
    public async Task<UnifyPageResultDto<AreaDto>> GetKpiAreas(QueryAreaRequest input)
    {
        return await _ruleAreaRepository.GetAreas(input);
    }

    /// <summary>
    /// 查询分区列表
    /// </summary>
    /// <param name="query"></param>
    /// <returns></returns>
    [HttpPost("KpiArea/GetKpiAreaInfos")]
    public async Task<UnifyPageResultDto<RuleAreaInfoDto>> GetKpiAreaInfos(QueryAreaInfoRequest query)
    {
        return await _ruleAreaRepository.GetAreaInfos(query);
    }
}