using AutoMapper.QueryableExtensions;
using LifePayment.Application.Contracts;
using LifePayment.Application.Contracts.LifePay;
using LifePayment.Domain;
using LifePayment.Domain.LifePay;
using LifePayment.Domain.Models;
using LifePayment.Domain.Shared;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.ObjectMapping;
using ZeroD.Util;
using ZeroD.Util.Fadd;

namespace LifePayment.Application.LifePay;


public class LifePayAnnouncementService : ApplicationService, ILifePayAnnouncementService
{
    private readonly IRepository<LifePayAnnouncement, Guid> _lifePayAnnouncementRepository;

    public LifePayAnnouncementService(IRepository<LifePayAnnouncement, Guid> lifePayAnnouncementRepository)
    {
        _lifePayAnnouncementRepository = lifePayAnnouncementRepository;
    }

    /// <summary>
    /// 获取公告分页
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<PageOutput<CreateEditLifePayAnnouncementOutput>> GetLifePayAnnouncementPage(GetLifePayAnnouncementPageInput input)
    {
        var currentTime = DateTime.Now;
        var query = _lifePayAnnouncementRepository
            .WhereIf(input.CreationTimeBegin.HasValue, x => x.CreationTime >= input.CreationTimeBegin)
            .WhereIf(input.CreationTimeEnd.HasValue, x => x.CreationTime <= input.CreationTimeEnd)
            .WhereIf(input.StartTime.HasValue, x => x.StartTime >= input.StartTime)
            .WhereIf(input.EndTime.HasValue, x => x.EndTime <= input.EndTime)
            .WhereIf(input.Status.HasValue, x => input.Status.Value == AnnouncementStatusEnum.Wait
                ? currentTime < x.StartTime
                    : input.Status.Value == AnnouncementStatusEnum.Showing
                        ? currentTime >= x.StartTime && currentTime <= x.EndTime
                        : input.Status.Value == AnnouncementStatusEnum.Stop
                            ? currentTime > x.EndTime
                            : false)
            .Select(x =>
                    new CreateEditLifePayAnnouncementOutput()
                    {
                        Id = x.Id,
                        AnnouncementType = x.AnnouncementType,
                        StartTime = x.StartTime,
                        EndTime = x.EndTime,
                        AnnouncementContent = x.AnnouncementContent,
                        CreationTime = x.CreationTime,
                        Status = GetLifePayAnnouncementStatus(x.StartTime, x.EndTime)
                    });

        var result = await query.GetPageResult(input.PageModel);

        return result;
    }

    /// <summary>
    /// 新增编辑公告
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<int> CreateOrEditLifePayAnnouncement(CreateEditLifePayAnnouncementInput input)
    {
        CheckExtensions.IfTrueThrowUserFriendlyException(input.EndTime <= input.StartTime, "截止日期不能低于生效日期");

        bool isExist = await _lifePayAnnouncementRepository.AnyAsync(r => (!input.Id.HasValue||r.Id != input.Id.Value)&&input.AnnouncementType==r.AnnouncementType&&!(input.EndTime < r.StartTime || input.StartTime > r.EndTime));
        CheckExtensions.IfTrueThrowUserFriendlyException(isExist, "同一时间段只能存在一条公告");


        if (input.Id.HasValue)
        {
            
            var dto = await _lifePayAnnouncementRepository.FirstOrDefaultAsync(r => r.Id == input.Id.Value);
            CheckExtensions.IfTrueThrowUserFriendlyException(dto == null, "未获取到公告数据");

            dto.AnnouncementType = input.AnnouncementType;
            dto.StartTime = input.StartTime;
            dto.EndTime = input.EndTime;
            dto.AnnouncementContent = input.AnnouncementContent;
        }
        else
        {
            input.Id = Guid.NewGuid();
            var entity = ObjectMapper.Map<CreateEditLifePayAnnouncementInput, LifePayAnnouncement>(input);
            await _lifePayAnnouncementRepository.InsertAsync(entity);
        }

        return Constant.SUCCESS;
    }

    /// <summary>
    /// 删除公告
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public async Task<int> DeleteLifePayAnnouncement(Guid id)
    {
        await _lifePayAnnouncementRepository.DeleteAsync(s => s.Id == id);

        return Constant.SUCCESS;
    }

    /// <summary>
    /// 获取当前展示中的公告
    /// </summary>
    /// <returns></returns>
    public async Task<CreateEditLifePayAnnouncementOutput> GetShowingLifePayAnnouncement(GetShowingLifePayAnnouncementInput input)
    {
        DateTime now = DateTime.Now;
        var announcement = await _lifePayAnnouncementRepository
            .WhereIf(input.AnnouncementType.HasValue,x=>x.AnnouncementType==input.AnnouncementType)
            .Where(x => now >= x.StartTime && now <= x.EndTime).OrderBy(r => r.StartTime).FirstOrDefaultAsync();
        if (announcement == null)
        {
            return null;
        }

        var model = ObjectMapper.Map<LifePayAnnouncement, CreateEditLifePayAnnouncementOutput>(announcement);
        model.Status = GetLifePayAnnouncementStatus(announcement.StartTime, announcement.EndTime);
        return model;
    }

    private static AnnouncementStatusEnum GetLifePayAnnouncementStatus(DateTime startTime, DateTime endTime)
    {
        DateTime now = DateTime.Now;
        if (now < startTime)
        {
            return AnnouncementStatusEnum.Wait;
        }
        else if (now >= startTime && now <= endTime)
        {
            return AnnouncementStatusEnum.Showing;
        }
        else
        {
            return AnnouncementStatusEnum.Stop;
        }
    }
}