using LifePayment.Application.Contracts;
using LifePayment.Domain.LifePay;
using LifePayment.Domain.Models;
using LifePayment.Domain.Shared;
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 Microsoft.EntityFrameworkCore;
using ZeroD.Util;
using LifePayment.Domain;
using static LifePayment.Domain.Shared.LifePaymentConstant;
using Newtonsoft.Json;

namespace LifePayment.Application.LifePay
{
    public class LifePayOrderService : ApplicationService, ILifePayOrderService
    {
        private readonly IRepository<LifePayRechargeReceipts, Guid> _lifePayRechargeReceiptsRepository;
        private readonly IRepository<LifePayExpensesReceipts, Guid> _lifePayExpensesReceiptsRepository;
        private readonly IRepository<LifePayOrder, Guid> _lifePayOrderRepository;
        private readonly IAliPayApi _aliPayApi;
        private readonly IWxPayApi _wxPayApi;

        public LifePayOrderService(
                              IRepository<LifePayRechargeReceipts, Guid> lifePayRechargeReceiptsRepository,
                              IRepository<LifePayExpensesReceipts, Guid> lifePayExpensesReceiptsRepository,
                              IRepository<LifePayOrder, Guid> lifePayOrderRepository,
                              IAliPayApi aliPayApi,
                              IWxPayApi wxPayApi)
        {
            _lifePayRechargeReceiptsRepository = lifePayRechargeReceiptsRepository;
            _lifePayExpensesReceiptsRepository = lifePayExpensesReceiptsRepository;
            _lifePayOrderRepository = lifePayOrderRepository;
            _aliPayApi = aliPayApi;
            _wxPayApi = wxPayApi;
        }

        /// <summary>
        /// 获取充值流水
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<LifePayRechargeReceiptsPageOutput<LifePayRechargeReceiptsListOutput>> GetLifePayRechargeReceiptsPage(LifePayRechargeReceiptsPageInput input)
        {
            var list = await _lifePayRechargeReceiptsRepository.Where(x => x.IsDeleted == false)
                .WhereIf(input.KeyWord.IsNotNullOrEmpty(), x => x.OrderNo.Contains(input.KeyWord))
                .WhereIf(input.CreationTimeBegin.HasValue, x => x.CreationTime >= input.CreationTimeBegin)
                .WhereIf(input.CreationTimeEnd.HasValue, x => x.CreationTime <= input.CreationTimeEnd)
                .Select(x => new LifePayRechargeReceiptsListOutput()
                {
                    Id = x.Id,
                    OrderNo = x.OrderNo,
                    RechargeAmount = x.RechargeAmount,
                    Remark = x.Remark,
                    Voucher = x.Voucher.GetOssPath(),
                    CreationTime = x.CreationTime,
                })
                .GetPageResult(input.PageModel);

            var total = await _lifePayRechargeReceiptsRepository.Where(x => x.IsDeleted == false).SumAsync(x => x.RechargeAmount);
            LifePayRechargeReceiptsPageOutput<LifePayRechargeReceiptsListOutput> result = new LifePayRechargeReceiptsPageOutput<LifePayRechargeReceiptsListOutput>();
            result.Data = list.Data;
            result.TotalRechargeAmount = total;
            return result;
        }



        /// <summary>
        /// 编辑充值流水
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task AddUpdatePayRechargeReceipts(AddUpdatePayRechargeReceiptsInput input)
        {
            CheckExtensions.IfTrueThrowUserFriendlyException(input.OrderNo == null, "请输入业务订单号");
            CheckExtensions.IfTrueThrowUserFriendlyException(input.RechargeAmount <= 0, "充值金额应大于0");
            CheckExtensions.IfTrueThrowUserFriendlyException(input.Voucher == null, "请提交充值凭证");
            var repeat = await _lifePayRechargeReceiptsRepository.Where(x => x.IsDeleted == false && x.OrderNo == input.OrderNo).FirstOrDefaultAsync();
            CheckExtensions.IfTrueThrowUserFriendlyException(repeat != null && repeat.Id != input.Id, "业务订单号重复");
            if (input.Id.HasValue)
            {
                var payRechargeReceipts = await _lifePayRechargeReceiptsRepository.Where(x => x.IsDeleted == false && x.Id == input.Id.Value).FirstOrDefaultAsync();
                payRechargeReceipts.OrderNo = input.OrderNo;
                payRechargeReceipts.RechargeAmount = input.RechargeAmount;
                payRechargeReceipts.Remark = input.Remark;
                payRechargeReceipts.Voucher = input.Voucher;
            }
            else
            {
                LifePayRechargeReceipts payRechargeReceipts = new LifePayRechargeReceipts()
                {
                    Id = Guid.NewGuid(),
                    OrderNo = input.OrderNo,
                    RechargeAmount = input.RechargeAmount,
                    Remark = input.Remark,
                    Voucher = input.Voucher,
                };
                await _lifePayRechargeReceiptsRepository.InsertAsync(payRechargeReceipts);
            }
        }

        /// <summary>
        /// 获取收支流水
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<LifePayExpensesReceiptsPageOutput<LifePayExpensesReceiptsListOutput>> GetLifePayExpensesReceiptsPage(LifePayExpensesReceiptsPageInput input)
        {
            var list = await _lifePayExpensesReceiptsRepository.Where(x => x.IsDeleted == false)
                .WhereIf(input.KeyWord.IsNotNullOrEmpty(), x => x.OrderNo.Contains(input.KeyWord) || x.OutOrderNo.Contains(input.KeyWord))
                .WhereIf(input.LifePayType.HasValue, x => x.LifePayType == input.LifePayType)
                .WhereIf(input.ExpensesReceiptsType.HasValue, x => x.ExpensesReceiptsType == input.ExpensesReceiptsType)
                .WhereIf(input.TimeBegin.HasValue, x => x.FinishTime >= input.TimeBegin)
                .WhereIf(input.TimeEnd.HasValue, x => x.FinishTime <= input.TimeEnd)

                .Select(x => new LifePayExpensesReceiptsListOutput()
                {
                    Id = x.Id,
                    OrderNo = x.OrderNo,
                    OutOrderNo = x.OutOrderNo,
                    LifePayType = x.LifePayType,
                    ExpensesReceiptsType = x.ExpensesReceiptsType.Value,
                    Amount = x.Amount,
                    FinishTime = x.FinishTime
                })
                .GetPageResult(input.PageModel);

            var totalIncome = await _lifePayExpensesReceiptsRepository.Where(x => x.IsDeleted == false && x.ExpensesReceiptsType == ExpensesReceiptsTypeEnum.Expenses).SumAsync(x => x.Amount);
            var totalRefund = await _lifePayExpensesReceiptsRepository.Where(x => x.IsDeleted == false && x.ExpensesReceiptsType == ExpensesReceiptsTypeEnum.Receipts).SumAsync(x => x.Amount);

            LifePayExpensesReceiptsPageOutput<LifePayExpensesReceiptsListOutput> result = new LifePayExpensesReceiptsPageOutput<LifePayExpensesReceiptsListOutput>();
            result.Data = list.Data;
            result.TotalIncome = totalIncome;
            result.TotalRefund = totalRefund;
            result.RealIncome = totalIncome - totalRefund;
            return result;
        }

        /// <summary>
        /// 插入收支流水
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task AddLifePayExpensesReceipts(AddLifePayExpensesReceiptsInput input)
        {
            var repeat = await _lifePayExpensesReceiptsRepository.Where(x => x.ExpensesReceiptsType == input.ExpensesReceiptsType
            && x.OrderNo == input.OrderNo).FirstOrDefaultAsync();
            if (repeat == null)
            {
                var data = new LifePayExpensesReceipts()
                {
                    Id = Guid.NewGuid(),
                    OrderNo = input.OrderNo,
                    OutOrderNo = input.OutOrderNo,
                    LifePayType = input.LifePayType,
                    ExpensesReceiptsType = input.ExpensesReceiptsType,
                    Amount = input.Amount,
                };

                switch (input.LifePayType)
                {
                    case LifePayTypeEnum.AliPay:
                        if (input.ExpensesReceiptsType == ExpensesReceiptsTypeEnum.Expenses)
                        {
                            var query = await _aliPayApi.OrderInQuiry(new OrderInQuiryInput() { OutTradeNo = input.OrderNo });
                            if (query.Code == AlipayResultCode.Success && (query.TradeStatus == AlipayStatus.TRADESUCCESS 
                                || query.TradeStatus == AlipayStatus.TRADECLOSED))
                            {
                                data.ExtraProperties = JsonConvert.SerializeObject(query);
                                data.FinishTime = Convert.ToDateTime(query.SendPayDate);
                                await _lifePayExpensesReceiptsRepository.InsertAsync(data);
                            }
                        }
                        else
                        {
                            var query = await _aliPayApi.QueryAlipayTradeRefund(new OrderInQuiryInput() { OutTradeNo = input.OrderNo });
                            if (query.Code == AlipayResultCode.Success && query.RefundStatus == AlipayRefundStatus.Success)
                            {
                                data.ExtraProperties = JsonConvert.SerializeObject(query);
                                //data.FinishTime = Convert.ToDateTime(query.SendPayDate);
                                await _lifePayExpensesReceiptsRepository.InsertAsync(data);
                            }
                        }
                        break;
                    case LifePayTypeEnum.WxPay:
                        if (input.ExpensesReceiptsType == ExpensesReceiptsTypeEnum.Expenses)
                        {
                            var query = await _wxPayApi.WxPayTradeQuery(input.OrderNo);
                            if (query.TradeState == WxPayStatus.支付成功 || query.TradeState == WxPayStatus.转入退款)
                            {
                                data.ExtraProperties = JsonConvert.SerializeObject(query);
                                data.FinishTime = Convert.ToDateTime(query.SuccessTime);
                                await _lifePayExpensesReceiptsRepository.InsertAsync(data);
                            }
                        }
                        else
                        {
                            var query = await _wxPayApi.WxPayDomesticRefundsQuery(input.OrderNo);
                            if (query.Status == WxPayRefundStatus.退款成功)
                            {
                                data.ExtraProperties = JsonConvert.SerializeObject(query);
                                data.FinishTime = Convert.ToDateTime(query.SuccessTime);
                                await _lifePayExpensesReceiptsRepository.InsertAsync(data);
                            }
                        }
                        break;
                    default: break;
                }
            }
        }

        public async Task GetAllLifePayExpensesReceipts()
        {
            var orderlist = await (from a in _lifePayOrderRepository.Where(x => x.PayStatus >= LifePayStatusEnum.已支付)
                                   join b in _lifePayExpensesReceiptsRepository on a.OrderNo equals b.OrderNo into temp
                                   from b in temp.DefaultIfEmpty()
                                   select new LifePayExpensesReceiptsTemp()
                                   {
                                       OrderNo = a.OrderNo,
                                       OutOrderNo = a.OutOrderNo,
                                       RefundOrderNo = a.RefundOrderNo,
                                       LifePayType = a.LifePayType.Value,
                                       Amount = a.PayAmount.Value,
                                       ExpensesReceiptsType = b.ExpensesReceiptsType
                                   }).ToListAsync();
            foreach (var item in orderlist)
            {
                if (!item.ExpensesReceiptsType.HasValue)
                {
                    /// 入账
                    AddLifePayExpensesReceiptsInput input = new AddLifePayExpensesReceiptsInput()
                    {
                        OrderNo = item.OrderNo,
                        OutOrderNo = item.OutOrderNo,
                        LifePayType = item.LifePayType,
                        Amount = item.Amount,
                        ExpensesReceiptsType = ExpensesReceiptsTypeEnum.Expenses
                    };

                    await AddLifePayExpensesReceipts(input);

                    /// 出账
                    if (item.RefundOrderNo.IsNotNullOrEmpty())
                    {
                        if (input.LifePayType == LifePayTypeEnum.WxPay)
                        {
                            input.OrderNo = item.RefundOrderNo;
                        }

                        input.ExpensesReceiptsType = ExpensesReceiptsTypeEnum.Receipts;
                        await AddLifePayExpensesReceipts(input);
                    }
                    
                   
                }
            }
           
        }
    }
}