using Aop.Api.Domain;
using Azure;
using Furion;
using Furion.DatabaseAccessor;
using Furion.DistributedIDGenerator;
using Furion.FriendlyException;
using Furion.Schedule;
using Microsoft.EntityFrameworkCore;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using static Microsoft.AspNetCore.Razor.Language.TagHelperMetadata;

namespace FlexJobApi.Core
{
    /// <summary>
    /// 完成任务结算T+1
    /// </summary>
    public class CompleteTaskSettlementT1Job(
            IRepository<TaskInfo> rep,
            IRepository<TaskInfoUser> repTaskInfoUser,
            IRepository<EnterpriseWallet> repEnterpriseWallet,
            IRepository<EnterpriseWalletTransaction> repEnterpriseWalletTransaction,
            IRepository<UserWallet> repUserWallet,
            IRepository<UserWalletTransaction> repUserWalletTransaction,
            AlipayUtils alipayUtils
        ) : IJob
    {
        private readonly IRepository<TaskInfo> rep = rep;
        private readonly IRepository<TaskInfoUser> repTaskInfoUser = repTaskInfoUser;
        private readonly IRepository<EnterpriseWallet> repEnterpriseWallet = repEnterpriseWallet;
        private readonly IRepository<UserWallet> repUserWallet = repUserWallet;
        private readonly IRepository<UserWalletTransaction> repUserWalletTransaction = repUserWalletTransaction;
        private readonly AlipayUtils alipayUtils = alipayUtils;

        [UnitOfWork(false)]
        public async Task ExecuteAsync(JobExecutingContext context, CancellationToken stoppingToken)
        {
            var env = App.GetConfig<string>("Environment");
            if (env != "Local")
            {
                var tasks = await GetTasks(env);
                var enterpriseIds = tasks.DistinctSelect(it => it.EnterpriseId);
                var taskIds = tasks.DistinctSelect(it => it.Id);
                var taskUsers = await GetTaskUsers(taskIds);
                var userIds = taskUsers.DistinctSelect(it => it.EnterpriseEmployee.UserId.Value);
                var userWallets = await GetUserWallets(userIds);
                var enterpriseWallets = await GetEnterpriseWallets(enterpriseIds);
                if (tasks.IsNotNull())
                {
                    foreach (var task in tasks)
                    {
                        var enterpriseWallet = enterpriseWallets.FirstOrDefault(it => it.EnterpriseId == task.EnterpriseId);

                        task.SettlementStatus = EnumTaskSettlementStatus.Completed;
                        task.SettlementTime = DateTime.Now;
                        await rep.UpdateNowAsync(task);

                        var users = taskUsers.Where(it => it.TaskInfoId == task.Id).ToList();
                        foreach (var user in users)
                        {
                            user.SettlementStatus = EnumTaskSettlementStatus.Completed;
                            user.SettlementTime = DateTime.Now;
                            await repTaskInfoUser.UpdateNowAsync(user);

                            var userWallet = await AddUserWalletTransactionIncome(userWallets, task, user);

                            var withdraw = await AddUserWalletTransactionWithdraw(userWallet, task, user);

                            var transfer = await AddEnterpriseWalletTransactionTransfer(enterpriseWallet, task, user);

                            await UpdateUserWalletTransactionWithdraw(userWallet, withdraw, transfer);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 更新用户钱包提现记录
        /// </summary>
        /// <param name="wallet"></param>
        /// <param name="withdraw"></param>
        /// <param name="transfer"></param>
        /// <returns></returns>
        private async Task UpdateUserWalletTransactionWithdraw(UserWallet wallet, UserWalletTransaction withdraw, EnterpriseWalletTransaction transfer)
        {
            withdraw.EnterpriseWalletTransactionId = transfer.Id;
            withdraw.TransactionStatus = transfer.TransactionStatus;
            withdraw.TransDate = transfer.TransDate;
            if (withdraw.TransactionStatus == EnumWalletTransactionStatus.Success)
            {
                withdraw.ActualAmount = withdraw.Amount;
            }
            else
            {
                withdraw.ActualAmount = 0;

                var order = new UserWalletTransaction();
                order.WalletId = wallet.Id;
                order.Type = EnumUserWalletTransactionType.Income;
                order.OperatorUserId = withdraw.OperatorUserId;
                order.OperatorTime = withdraw.OperatorTime;
                order.Title = $"收入-提现失败退款";
                order.Amount = withdraw.Amount;
                order.ActualAmount = order.Amount;
                order.Balance = wallet.Balance;
                order.AfterBalance = wallet.Balance + order.Amount;
                order.TransDate = DateTime.Now;
                order.TransactionStatus = EnumWalletTransactionStatus.Success;
                await SetCode(order);
                await repUserWalletTransaction.InsertNowAsync(order);

                wallet.Balance = order.AfterBalance;
                await repUserWallet.UpdateNowAsync(wallet);
            }
        }

        /// <summary>
        /// 添加用户钱包提现记录
        /// </summary>
        /// <param name="wallet"></param>
        /// <param name="task"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        private async Task<UserWalletTransaction> AddUserWalletTransactionWithdraw(UserWallet wallet, TaskInfo task, TaskInfoUser user)
        {
            wallet.Balance -= user.ActualSettlementAmount ?? 0;
            await repUserWallet.UpdateNowAsync(wallet);

            var order = new UserWalletTransaction();
            order.WalletId = wallet.Id;
            order.Type = EnumUserWalletTransactionType.Withdraw;
            order.OperatorUserId = task.SettlementOperatorUserId;
            order.OperatorTime = task.SettlementStartTime;
            order.Title = $"提现-支付宝提现";
            order.Amount = user.ActualSettlementAmount ?? 0;
            order.Balance = wallet.Balance;
            order.AfterBalance = wallet.Balance - order.Amount;
            order.ReceiveName = user.ReceiveName;
            order.ReceiveAccount = user.ReceiveAccount;
            order.TransDate = DateTime.Now;
            order.TransactionStatus = EnumWalletTransactionStatus.Dealing;
            await SetCode(order);
            await repUserWalletTransaction.InsertNowAsync(order);
            return order;
        }

        /// <summary>
        /// 添加用户钱包收入记录
        /// </summary>
        /// <param name="wallets"></param>
        /// <param name="task"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        private async Task<UserWallet> AddUserWalletTransactionIncome(List<UserWallet> wallets, TaskInfo task, TaskInfoUser user)
        {
            var wallet = wallets.FirstOrDefault(it => it.UserId == user.EnterpriseEmployee.UserId);
            if (wallet == null)
            {
                wallet = new UserWallet();
                wallet.UserId = user.EnterpriseEmployee.UserId.Value;
                await repUserWallet.InsertNowAsync(wallet);
            }
            var order = new UserWalletTransaction();
            order.WalletId = wallet.Id;
            order.Type = EnumUserWalletTransactionType.Income;
            order.TaskUserId = user.Id;
            order.EnterpriseName = task.Enterprise.EnterpriseName;
            order.SettlementTime = user.SettlementTime;
            order.SettlementAmount = user.SettlementAmount;
            order.OperatorUserId = task.SettlementOperatorUserId;
            order.OperatorTime = task.SettlementStartTime;
            order.Title = $"收入-{order.EnterpriseName}";
            order.Amount = user.ActualSettlementAmount ?? 0;
            order.ActualAmount = order.Amount;
            order.Balance = wallet.Balance;
            order.AfterBalance = wallet.Balance + order.Amount;
            order.TransDate = DateTime.Now;
            order.TransactionStatus = EnumWalletTransactionStatus.Success;
            await SetCode(order);
            await repUserWalletTransaction.InsertNowAsync(order);

            wallet.Balance = order.AfterBalance;
            await repUserWallet.UpdateNowAsync(wallet);

            return wallet;
        }

        /// <summary>
        /// 添加企业钱包转账记录
        /// </summary>
        /// <param name="wallet"></param>
        /// <param name="task"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        private async Task<EnterpriseWalletTransaction> AddEnterpriseWalletTransactionTransfer(EnterpriseWallet wallet, TaskInfo task, TaskInfoUser user)
        {
            var order = new EnterpriseWalletTransaction();
            order.Type = EnumEnterpriseWalletTransactionType.Transfer;
            order.WalletId = wallet.Id;
            order.TaskUserId = user.Id;
            order.Amount = user.ActualSettlementAmount ?? 0;
            order.Remark = user.SettlementRemark;
            order.ProductCode = "SINGLE_TRANSFER_NO_PWD";
            order.BizScene = "ENTRUST_TRANSFER";
            order.TransactionStatus = EnumWalletTransactionStatus.WaitSubmit;
            order.Balance = wallet.Balance;
            order.AfterBalance = wallet.Balance - order.Amount;
            order.OperatorUserId = task.SettlementOperatorUserId;
            order.OperatorTime = task.SettlementStartTime;
            order.ReceiveUserId = user.EnterpriseEmployee.UserId;
            order.ReceiveName = user.ReceiveName;
            order.ReceiveAccount = user.ReceiveAccount;
            await SetCode(order);
            await repEnterpriseWalletTransaction.InsertNowAsync(order);

            var response = alipayUtils.FundTransUniTransfer(new AlipayFundTransUniTransferModel
            {
                OutBizNo = order.Code,
                TransAmount = order.Amount.ToString(),
                ProductCode = order.ProductCode,
                BizScene = order.BizScene,
                PayeeInfo = new Participant
                {
                    IdentityType = "ALIPAY_LOGON_ID",
                    Identity = order.ReceiveAccount,
                    Name = order.ReceiveName,
                },
                PayerInfo = new Participant
                {
                    IdentityType = "ACCOUNT_BOOK_ID",
                    Identity = wallet.AccountBookId,
                    ExtInfo = new
                    {
                        agreement_no = wallet.AgreementNo,
                    }.ToJson(),
                },
                OrderTitle = order.Remark,
                Remark = order.Remark,
                BusinessParams = new
                {
                    withdraw_timeliness = "T0"
                }.ToJson()
            }, "/api/user/enterpriseWallet/alipayFundTransOrderChangedNotify");
            if (response.IsError)
            {
                order.ErrorCode = response.Code;
                order.FailReason = response.SubMsg ?? response.Msg;
                await repEnterpriseWalletTransaction.UpdateNowAsync(order);
            }
            else
            {
                order.OrderId = response.OrderId;
                order.PayFundOrderId = response.PayFundOrderId;
                order.SettleSerialNo = response.SettleSerialNo;
                order.TransDate = response.TransDate.ToDateTime();
                order.Link = response.Link;
                order.Status = response.Status;
                order.SubStatus = response.SubStatus;
                order.TransactionStatus = response.Status == "SUCCESS"
                    ? EnumWalletTransactionStatus.Success
                    : response.Status == "DEALING"
                    ? EnumWalletTransactionStatus.Dealing
                    : response.Status == "REFUND"
                    ? EnumWalletTransactionStatus.Refund
                    : EnumWalletTransactionStatus.Fail;
                await repEnterpriseWalletTransaction.UpdateNowAsync(order);
            }
            return order;
        }

        /// <summary>
        /// 查询用户钱包
        /// </summary>
        /// <param name="userIds"></param>
        /// <returns></returns>
        private async Task<List<UserWallet>> GetUserWallets(List<Guid> userIds)
        {
            var wallets = await repUserWallet.AsQueryable().AsNoTracking()
                .Where(it => userIds.Contains(it.UserId))
                .ToListAsync();
            return wallets;
        }

        /// <summary>
        /// 查询企业钱包
        /// </summary>
        /// <param name="enterpriseIds"></param>
        /// <returns></returns>
        private async Task<List<EnterpriseWallet>> GetEnterpriseWallets(List<Guid> enterpriseIds)
        {
            var wallets = await repEnterpriseWallet.AsQueryable()
                .Where(it => enterpriseIds.Contains(it.EnterpriseId) && it.Access == EnumEnterpriseWalletAccess.Alipay)
                .ToListAsync();
            foreach (var wallet in wallets)
            {
                var response = alipayUtils.FundAccountbookQuery(new AlipayFundAccountbookQueryModel
                {
                    AccountBookId = wallet.AccountBookId,
                    SceneCode = "SATF_FUND_BOOK",
                    MerchantUserId = wallet.Code,
                });
                if (response.IsError) throw Oops.Oh(EnumErrorCodeType.s510, response.SubMsg ?? response.Msg);
                wallet.Balance = response.AvailableAmount.ToDecimal() ?? 0;
                await repEnterpriseWallet.UpdateNowAsync(wallet);
            }
            return wallets;
        }

        /// <summary>
        /// 查询任务用户
        /// </summary>
        /// <param name="taskIds"></param>
        /// <returns></returns>
        private async Task<List<TaskInfoUser>> GetTaskUsers(List<Guid> taskIds)
        {
            var taskUsers = await repTaskInfoUser
                .Include(it => it.EnterpriseEmployee)
                .Where(it =>
                    taskIds.Contains(it.TaskInfoId)
                    && it.SettlementStatus == EnumTaskSettlementStatus.InProcess)
                .ToListAsync();
            return taskUsers;
        }

        /// <summary>
        /// 查询任务
        /// </summary>
        /// <param name="env"></param>
        /// <returns></returns>
        private async Task<List<TaskInfo>> GetTasks(string env)
        {
            var now = DateTime.Now;
            var q = rep.AsQueryable()
                .Include(it => it.Enterprise)
                .Where(it => it.SettlementStatus == EnumTaskSettlementStatus.InProcess);
            var minTime = env == "Test"
                ? now.AddMinutes(-5)
                : now.AddDays(-1);
            q = q.Where(it => it.SettlementStartTime.HasValue && it.SettlementStartTime < minTime);
            var tasks = await q.ToListAsync();
            return tasks;
        }

        private async Task SetCode(EnterpriseWalletTransaction entity)
        {
            entity.Code = $"{DateTime.Now:yyyyMMddHHmmss}{new Random(IDGen.NextID().GetHashCode()).Next(1000, 9999)}";
            var exist = await repEnterpriseWalletTransaction.AsQueryable().AsNoTracking()
                .AnyAsync(it => it.Code == entity.Code);
            if (exist)
            {
                await SetCode(entity);
            }
        }

        private async Task SetCode(UserWalletTransaction entity)
        {
            entity.Code = $"{DateTime.Now:yyyyMMddHHmmss}{new Random(IDGen.NextID().GetHashCode()).Next(1000, 9999)}";
            var exist = await repUserWalletTransaction.AsQueryable().AsNoTracking()
                .AnyAsync(it => it.Code == entity.Code);
            if (exist)
            {
                await SetCode(entity);
            }
        }

    }
}