using Hotline.Orders;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.Article;
using Hotline.Share.Dtos.Snapshot;
using Hotline.Share.Tools;
using Hotline.Snapshot;
using Hotline.Users;
using SqlSugar;
using XF.Domain.Authentications;
using XF.Domain.Dependency;
using XF.Domain.Repository;
using Hotline.Repository.SqlSugar.Extensions;
using Hotline.Share.Enums;
using Hotline.Share.Enums.Order;
using Hotline.Share.Requests;
using Hotline.Share.Enums.Snapshot;
using Mapster;
using Hotline.Caching.Interfaces;
using NPOI.Util.ArrayExtensions;
using XF.Domain.Exceptions;
using Hotline.Settings;
using Hotline.Share.Dtos.Settings;
using Hotline.File;

namespace Hotline.Application.Snapshot;

/// <summary>
/// 随手拍应用层
/// </summary>
public abstract class SnapshotApplicationBase
{
    private readonly IThirdAccountRepository _thirdAccountRepository;
    private readonly IRepository<Order> _orderRepository;
    private readonly IRepository<Article.Bulletin> _bulletinRepository;

    /// <summary>
    /// 行业
    /// </summary>
    private readonly IRepository<Industry> _industryRepository;
    private readonly IThirdIdentiyService _thirdLoginService;
    private readonly ISessionContext _sessionContext;
    private readonly IRepository<RedPackRecord> _redPackRecordRepository;
    private readonly IRepository<OrderSnapshot> _orderSnapshotRepository;
    private readonly ISystemSettingCacheManager _systemSettingCacheManager;
    private readonly ISystemAreaDomainService _systemAreaDomainService;
    private readonly IFileRepository _fileRepository;
    private readonly ISystemDicDataCacheManager _systemDicDataCacheManager;

    public SnapshotApplicationBase(IThirdIdentiyService thirdLoginService, IRepository<Industry> industryRepository, IRepository<Article.Bulletin> bulletinRepository, ISessionContext sessionContext, IRepository<RedPackRecord> redPackRecordRepository, IRepository<Order> orderRepository, IThirdAccountRepository thirdAccountRepository, IRepository<OrderSnapshot> orderSnapshotRepository, ISystemSettingCacheManager systemSettingCacheManager, ISystemAreaDomainService systemAreaDomainService, IFileRepository fileRepository, ISystemDicDataCacheManager systemDicDataCacheManager)
    {
        _thirdLoginService = thirdLoginService;
        _industryRepository = industryRepository;
        _bulletinRepository = bulletinRepository;
        _sessionContext = sessionContext;
        _redPackRecordRepository = redPackRecordRepository;
        _orderRepository = orderRepository;
        _thirdAccountRepository = thirdAccountRepository;
        _orderSnapshotRepository = orderSnapshotRepository;
        _systemSettingCacheManager = systemSettingCacheManager;
        _systemAreaDomainService = systemAreaDomainService;
        _fileRepository = fileRepository;
        _systemDicDataCacheManager = systemDicDataCacheManager;
    }

    /// <summary>
    /// 获取随手拍小程序首页数据
    /// </summary>
    /// <returns></returns>
    public async Task<HomePageOutDto> GetHomePageAsync()
    {
        var fileServiceUrl = _systemSettingCacheManager.FileServerUrl;
        var fileDownloadApi = fileServiceUrl + _systemSettingCacheManager.FileDownloadApi;
        var items = await _industryRepository.Queryable()
            .Where(m => m.IsEnable)
            .OrderBy(m => m.DisplayOrder)
            .ToListAsync(m => new HomeIndustryOutDto());
        items.ForEach(m =>
        {
            if (m.BackgroundImgUrl.NotNullOrEmpty())
                m.BackgroundImgUrl = fileDownloadApi + m.BackgroundImgUrl;
            if (m.BannerImgUrl.NotNullOrEmpty())
                m.BannerImgUrl = fileDownloadApi + m.BannerImgUrl;
            if (m.CareCellImgUrl.NotNullOrEmpty())
                m.CareCellImgUrl = fileDownloadApi + m.CareCellImgUrl;
            if (m.CellImgUrl.NotNullOrEmpty())
                m.CellImgUrl = fileDownloadApi + m.CellImgUrl;
        });

        return new HomePageOutDto
        {
            Banners = _systemSettingCacheManager.AppBanner.Split('|').Select(m => fileDownloadApi + m).ToList(),
            Industrys = items
        };
    }

    /// <summary>
    /// 行业页面基础数据
    /// </summary>
    /// <param name="id"></param>
    /// <param name="requestAborted"></param>
    /// <returns></returns>
    public async Task<IndustryBaseOutDto> GetIndustryBaseAsync(string id, CancellationToken requestAborted)
    {
        var fileServiceUrl = _systemSettingCacheManager.FileServerUrl;
        var fileDownloadApi = fileServiceUrl + _systemSettingCacheManager.FileDownloadApi;
        var indurstry = await _industryRepository.GetAsync(id, requestAborted)
            ?? throw UserFriendlyException.SameMessage("行业不存在:" + id);

        var outDto = new IndustryBaseOutDto
        {
            Industry = indurstry.Adapt<IndustryOutDto>()
        };
        if (indurstry.IndustryType == EIndustryType.Declare)
        {
            outDto.AreaTree = (await _systemAreaDomainService.GetAreaTree(parentId: "510300")).Adapt<List<SystemAreaOutDto>>();
            outDto.Files = (await _fileRepository.GetByKeyAsync(indurstry.Id, requestAborted)).Adapt<List<IndustryFileDto>>();
            outDto.Files.ToList().ForEach(m => m.Url = fileDownloadApi + m.AdditionId);
            outDto.WorkArea = _systemDicDataCacheManager.WorkArea.Adapt<List<SystemDicDataOutDto>>();
            outDto.Workplace = _systemDicDataCacheManager.Workplace.Adapt<List<SystemDicDataOutDto>>();
        }
        return outDto;
    }

    /// <summary>
    /// 获取随手拍小程序公告
    /// </summary>
    /// <returns></returns>
    public async Task<IReadOnlyList<BulletinOutDto>> GetBulletinsAsync(BulletinInDto dto)
    {
        var items = await _bulletinRepository.Queryable()
            .Where(m => m.BulletinState == Share.Enums.Article.EBulletinState.ReviewPass)
            .LeftJoin<Industry>((bulletin, industry) => bulletin.BulletinTypeId == industry.BulletinTypePublicityId)
            .Where((bulletin, industry) => industry.Id == dto.IndustryId)
            .ToPageListAsync(dto.PageIndex, dto.PageSize);

        return items.Adapt<IReadOnlyList<BulletinOutDto>>();
    }

    /// <summary>
    /// 获取个人中心数据
    /// </summary>
    /// <returns></returns>
    public async Task<SnapshotUserInfoOutDto> GetSnapshotUserInfoAsync()
    {
        var openId = _sessionContext.OpenId;
        var thirdAccount = await _thirdAccountRepository.QueryByOpenIdAsync(openId);
        var dayTime = DateTime.Now;
        var readPack = await _redPackRecordRepository.Queryable()
            .Where(m => m.WXOpenId == openId && m.PickupStatus == Share.Enums.Snapshot.ERedPackPickupStatus.Received)
            .Where(m => m.CreationTime.Date == dayTime.Date)
            .Select(m => SqlFunc.AggregateSum(m.Amount))
            .FirstAsync();

        var outDto = await _orderRepository.Queryable()
            .Where(m => m.Contact == thirdAccount.PhoneNumber)
            .Select(m => new SnapshotUserInfoOutDto
            {
                NoReplyCount = SqlFunc.AggregateSum(SqlFunc.IIF(m.Status < Share.Enums.Order.EOrderStatus.Filed, 1, 0)),
                ReplyCount = SqlFunc.AggregateSum(SqlFunc.IIF(m.Status >= Share.Enums.Order.EOrderStatus.Filed, 1, 0)),
                AppraiseCount = SqlFunc.AggregateSum(SqlFunc.IIF(m.Status == Share.Enums.Order.EOrderStatus.Visited, 1, 0)),
            }).FirstAsync();

        outDto.DayAmount = readPack;
        outDto.TotalAmount = thirdAccount.TotalAmount;
        outDto.PhoneNumber = thirdAccount.PhoneNumber;
        return outDto;
    }

    public async Task<PagedDto<OrderOutDto>> GetSnapshotOrdersAsync(OrderInDto dto)
    {
        var member = await _thirdAccountRepository.QueryByOpenIdAsync(_sessionContext.OpenId);
        if (member == null)
        {
            return new PagedDto<OrderOutDto>(0, new List<OrderOutDto>());
        }
        var (total, items) = await _orderSnapshotRepository.Queryable()
            .LeftJoin<Order>((snapshot, order) => snapshot.OrderId == order.Id)
            .Where((snapshot, order) => order.Contact == member.PhoneNumber)
            .WhereIF(dto.Status == EOrderQueryStatus.Appraise, (snapshot, order) => order.Status == EOrderStatus.Visited)
            .WhereIF(dto.Status == EOrderQueryStatus.NoReply, (snapshot, order) => order.Status < EOrderStatus.Filed)
            .WhereIF(dto.Status == EOrderQueryStatus.Reply, (snapshot, order) => order.Status >= EOrderStatus.Filed)
            .WhereIF(dto.KeyWords.NotNullOrEmpty(), (snapshot, order) => order.Title.Contains(dto.KeyWords))
            .Select((snapshot, order) => new OrderOutDto
            {
                Id = snapshot.Id,
                OrderNo = order.No,
                Title = order.Title,
                Status = order.Status,
                IndustryName = snapshot.IndustryName,
                CreationTime = order.CreationTime,
                Area = order.City
            })
            .ToPagedListAsync(dto.PageIndex, dto.PageSize);

        return new PagedDto<OrderOutDto>(total, items);
    }

    public async Task<OrderDetailOutDto> GetSnapshotOrderDetailAsync(string id)
    {
        var detail = await _orderSnapshotRepository.Queryable()
            .Where(m => m.Id == id)
            .LeftJoin<Order>((snapshot, order) => snapshot.OrderId == order.Id)
            .Select((snapshot, order) => new OrderDetailOutDto
            {
                Id = snapshot.Id,
                OrderNo = order.No,
                Title = order.Title,
                Status = order.Status,
                IndustryName = snapshot.IndustryName,
                CreationTime = order.CreationTime,
                Area = order.City
            })
            .FirstAsync();

        return detail;
    }

    /// <summary>
    /// 获取当月详细红包列表
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    public async Task<PagedDto<RedPackOutDto>> GetRedPacksAsync(RedPacksInDto dto)
    {
        var openId = _sessionContext.OpenId;
        var (total, items) = await _redPackRecordRepository.Queryable()
            .Where(m => m.WXOpenId == openId)
            .Where(m => m.PickupStatus == dto.Status)
            .Where(m => m.CreationTime.ToString("yyyy-MM") == dto.Time)
            .LeftJoin<Order>((red, order) => red.OrderId == order.Id)
            .Select((red, order) => new RedPackOutDto
            {
                Amount = red.Amount,
                Title = order.Title,
                CreationTime = red.CreationTime
            })
            .ToPagedListAsync(dto.PageIndex, dto.PageSize);

        return new PagedDto<RedPackOutDto>(total, items);
    }

    /// <summary>
    /// 按月统计红包金额
    /// </summary>
    /// <param name="count"></param>
    /// <returns></returns>
    public async Task<IReadOnlyList<RedPackDateOutDto>> GetRedPackDateAsync(RedPackDateInDto dto)
    {
        var openId = _sessionContext.OpenId;
        var item = await _redPackRecordRepository.Queryable()
            .Where(m => m.WXOpenId == openId)
            .Where(m => m.PickupStatus == dto.Status)
            .GroupBy(m => m.CreationTime.ToString("yyyy-MM"))
            .OrderByDescending(m => m.CreationTime)
            .Select(m => new RedPackDateOutDto
            {
                CreationTime = SqlFunc.AggregateMax(m.CreationTime.Date),
                Amount = SqlFunc.AggregateSum(m.Amount)
            })
            .Take(dto.Count)
            .ToListAsync();

        return item;
    }

    public async Task<BulletinOutDto> GetBulletinsDetailAsync(string id)
    {
        var detail = await _bulletinRepository.Queryable()
            .Where(m => m.Id == id)
            .Where(m => m.BulletinState == Share.Enums.Article.EBulletinState.ReviewPass)
            .Select(m => new BulletinOutDto
            {
                Id = m.Id,
                Title = m.Title,
                Content = m.Content
            })
            .FirstAsync();
        return detail;
    }
}