using Azure.Core;
using FlexJobApi.Core;
using Furion;
using Furion.DatabaseAccessor;
using Furion.FriendlyException;
using MediatR;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace FlexJobApi.UserServer.Application
{
    /// <summary>
    /// 电子签回传
    /// </summary>
    public class ElectronSignCallbackCommandHandler(
            IRepository<User> repUser,
            IRepository<EnterpriseEmployeeContract> repEnterpriseEmployeeContract,
            IRepository<EnterpriseEmployee> repEnterpriseEmployee,
            IRepository<TaskInfoUser> repTaskInfoUser
        ) :
        IRequestHandler<ElectronSignCallbackCommand, bool>
    {
        private readonly IRepository<User> repUser = repUser;
        private readonly IRepository<EnterpriseEmployeeContract> repEnterpriseEmployeeContract = repEnterpriseEmployeeContract;
        private readonly IRepository<EnterpriseEmployee> repEnterpriseEmployee = repEnterpriseEmployee;
        private readonly IRepository<TaskInfoUser> repTaskInfoUser = repTaskInfoUser;

        /// <summary>
        /// 电子签回传
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task<bool> Handle(ElectronSignCallbackCommand request, CancellationToken cancellationToken)
        {
            var appId = App.GetConfig<Guid>("ElectronSignServer:AppId");
            if (appId != request.CustomerId)
                throw Oops.Oh(EnumErrorCodeType.s400, "无效的AppId");
            switch (request.Action)
            {
                case "UserSign":
                    await UserFaceReal(request);
                    break;
                case "ContractSign":
                    await ContractSign(request);
                    break;
                default:
                    break;
            }
            return true;
        }

        private async Task ContractSign(ElectronSignCallbackCommand request)
        {
            var data = ((JObject)request.Data).ToObject<ElectronSignCallbackCommandContractSignModel>()!;
            var contractId = data.OutContractId.ToGuid("无效的合同Id")!.Value;
            var contract = await repEnterpriseEmployeeContract.AsQueryable()
                .Include(it=>it.ContractTemplate)
                .Where(it => it.Id == contractId)
                .FirstOrDefaultAsync();
            if (contract == null) throw Oops.Oh(EnumErrorCodeType.s404, "合同");
            var entity = await repEnterpriseEmployee.AsQueryable()
                .Include(it => it.ContractTemplate)
                .Where(it => it.Id == contract.EnterpriseEmployeeId)
                .FirstOrDefaultAsync();
            if (entity == null) throw Oops.Oh(EnumErrorCodeType.s404, "灵工");
            if (entity.ContractTemplateId != contract.ContractTemplateId
                || entity.UserSignContractStatus != contract.UserSignContractStatus
                || entity.UserSignContractTime != contract.UserSignContractTime
                || entity.EnterpriseSignContractStatus != contract.EnterpriseSignContractStatus
                || entity.EnterpriseSignContractTime != contract.EnterpriseSignContractTime)
            {
                throw Oops.Oh(EnumErrorCodeType.s510, "合同已失效");
            }
            if (request.Success)
            {
                if (entity.ContractTemplate.Access == EnumElectronSignAccess.BestSign)
                {
                    if (data.UserType == Core.Models.ElectronSignServer.PersonalUserReals.EnumElectronSignUserType.Personal)
                    {
                        if (data.Status == Core.Models.ElectronSignServer.ContractTemplates.EnumElectronSignContractStatus.Signing)
                        {
                            contract.UserSignContractStatus = EnumTaskUserSignContractStatus.Pass;
                            contract.UserSignContractTime = DateTime.Now;
                            contract.EnterpriseSignContractStatus = EnumTaskUserSignContractStatus.Wait;
                        }
                    }
                    else
                    {
                        if (data.Status == Core.Models.ElectronSignServer.ContractTemplates.EnumElectronSignContractStatus.Signing)
                        {
                            contract.EnterpriseSignContractStatus = EnumTaskUserSignContractStatus.Pass;
                            contract.EnterpriseSignContractTime = DateTime.Now;
                        }
                    }
                }
                if (data.Status == Core.Models.ElectronSignServer.ContractTemplates.EnumElectronSignContractStatus.Completed)
                {
                    contract.UserSignContractStatus = EnumTaskUserSignContractStatus.Pass;
                    if (contract.UserSignContractTime == null)
                    {
                        contract.UserSignContractTime = DateTime.Now;
                    }
                    contract.EnterpriseSignContractStatus = EnumTaskUserSignContractStatus.Pass;
                    if (contract.EnterpriseSignContractTime == null)
                    {
                        contract.EnterpriseSignContractTime = DateTime.Now;
                    }
                    contract.ContractUrl = AliyunOSSUtils.Upload("Contact", data.ContactUrl, $"{contract.ContractTemplate.Name}.pdf").Url;
                }
            }
            else
            {
                if (entity.ContractTemplate.Access == EnumElectronSignAccess.BestSign)
                {
                    if (data.UserType == Core.Models.ElectronSignServer.PersonalUserReals.EnumElectronSignUserType.Personal)
                    {
                        contract.UserSignContractErrorMessage = request.Message;
                    }
                    else
                    {
                        contract.EnterpriseSignContractErrorMessage = request.Message;
                    }
                }
                else
                {
                    contract.UserSignContractErrorMessage = request.Message;
                    contract.EnterpriseSignContractErrorMessage = request.Message;
                }
            }
            await repEnterpriseEmployeeContract.UpdateAsync(contract);

            entity.UserSignContractStatus = contract.UserSignContractStatus;
            entity.UserSignContractTime = contract.UserSignContractTime;
            entity.EnterpriseSignContractStatus = contract.EnterpriseSignContractStatus;
            entity.EnterpriseSignContractTime = contract.EnterpriseSignContractTime;
            entity.ContractUrl = contract.ContractUrl;
            await repEnterpriseEmployee.UpdateAsync(entity);

            if (entity.UserSignContractStatus == EnumTaskUserSignContractStatus.Pass && entity.EnterpriseSignContractStatus == EnumTaskUserSignContractStatus.Pass)
            {
                var taskUsers = await repTaskInfoUser.AsQueryable()
                    .Where(it => it.EnterpriseEmployeeId == entity.Id && it.HireStatus == EnumTaskUserHireStatus.Pass && it.ArrangeStatus == null)
                    .ToListAsync();
                if (taskUsers.IsNotNull())
                {
                    foreach (var taskUser in taskUsers)
                    {
                        taskUser.ArrangeStatus = EnumTaskUserArrangeStatus.Wait;
                    }
                    await repTaskInfoUser.UpdateAsync(taskUsers);
                }
            }
        }

        private async Task UserFaceReal(ElectronSignCallbackCommand request)
        {
            var user = await repUser.AsQueryable()
                .Include(it => it.UserAuth)
                .Where(it => it.UserAuth.ElectronSignUserId == request.RelationId)
                .FirstOrDefaultAsync();
            if (user == null)
                throw Oops.Oh(EnumErrorCodeType.s404, "用户");
            var data = ((JObject)request.Data).ToObject<ElectronSignCallbackCommandUserSignModel>()!;
            if (user.Id != data.OutUserId)
                throw Oops.Oh(EnumErrorCodeType.s404, "用户");
            var enterpriseEmployees = request.Success
                ? await repUser.Change<EnterpriseEmployee>().AsQueryable()
                    .Where(it => it.UserId == user.Id)
                    .ToListAsync()
                : new List<EnterpriseEmployee>();
            PersonalUserRealCommandHandler.PersonalReal(
                request.Success == true
                ? EnumPersonalUserRealStatus.Real
                : EnumPersonalUserRealStatus.Fail,
                EnumUserRealMethod.Face,
                user,
                enterpriseEmployees,
                user.UserAuth.Name,
                user.UserAuth.Identity,
                user.UserAuth.IdentityImg,
                user.UserAuth.IdentityBackImg,
                faceRealUrl: user.UserAuth.FaceRealUrl);
            await repUser.UpdateAsync(user);
        }
    }
}