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

namespace FlexJobApi.FlexJobServer.Application
{
    /// <summary>
    /// 报名任务
    /// </summary>
    public class ApplyTaskCommandHandler(
            IRepository<TaskInfoUser> repTaskInfoUser,
            IRepository<User> repUser,
            IRepository<TaskInfo> repTaskInfo,
            IRepository<EnterpriseEmployee> repEnterpriseEmployee
        ) :
        IRequestHandler<ApplyTaskCommand, int>

    {
        private readonly IRepository<TaskInfoUser> repTaskInfoUser = repTaskInfoUser;
        private readonly IRepository<User> repUser = repUser;
        private readonly IRepository<TaskInfo> repTaskInfo = repTaskInfo;
        private readonly IRepository<EnterpriseEmployee> repEnterpriseEmployee = repEnterpriseEmployee;

        /// <summary>
        /// 报名任务
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task<int> Handle(ApplyTaskCommand request, CancellationToken cancellationToken)
        {
            var logier = JwtUtils.GetCurrentLogier();
            var applyTaskIds = await repTaskInfoUser.AsQueryable().AsNoTracking()
                .Include(it => it.TaskInfo)
                .Where(it => request.Ids.Contains(it.TaskInfoId) && it.EnterpriseEmployee.UserId == logier.Id)
                .Select(it => it.TaskInfoId)
                .ToListAsync(cancellationToken);
            var taskIds = request.Ids.Where(it => !applyTaskIds.Contains(it)).ToList();
            if (taskIds.IsNotNull())
            {
                var user = await repUser.AsQueryable().AsNoTracking()
                    .Include(it => it.UserAuth)
                    .Where(it => it.Id == logier.Id)
                    .Select(it => new
                    {
                        it.Name,
                        it.Identity,
                        it.ContactPhoneNumber,
                        it.Gender,
                        it.Age,
                        it.UserAuth.IdentityImg,
                        it.UserAuth.IdentityBackImg,
                        it.IsReal
                    })
                    .FirstOrDefaultAsync(cancellationToken);
                if (user == null) throw Oops.Oh(EnumErrorCodeType.s404, "账号");
                if (!user.IsReal) throw Oops.Oh(EnumErrorCodeType.s510, "请先实名");
                var tasks = await repTaskInfo.AsQueryable().AsNoTracking()
                    .Where(it => taskIds.Contains(it.Id))
                    .Select(it => new
                    {
                        it.Id,
                        it.EnterpriseId,
                        it.ReleaseStatus
                    })
                    .ToListAsync(cancellationToken);
                var enterpriseIds = tasks.DistinctSelect(it => it.EnterpriseId);
                var employees = await repEnterpriseEmployee.AsQueryable()
                    .Where(it =>
                        enterpriseIds.Contains(it.EnterpriseId)
                        && (it.UserId == logier.Id
                        || it.Name == user.Name
                        && it.Identity == user.Identity))
                    .ToListAsync();
                foreach (var taskId in taskIds)
                {
                    var task = tasks.FirstOrDefault(it => it.Id == taskId);
                    if (task == null) throw Oops.Oh(EnumErrorCodeType.s404, "任务");
                    if (task.ReleaseStatus == EnumTaskReleaseStatus.Stopped)
                        throw Oops.Oh(EnumErrorCodeType.s510, "任务已停止");
                    var employee = employees.FirstOrDefault(it => it.EnterpriseId == task.EnterpriseId && it.UserId == logier.Id);
                    if (employee == null)
                    {
                        employee = employees.FirstOrDefault(it => it.EnterpriseId == task.EnterpriseId && it.Name == user.Name && it.Identity == user.Name);
                    }
                    if (employee == null)
                    {
                        employee = new EnterpriseEmployee
                        {
                            EnterpriseId = task.EnterpriseId,
                            UserId = logier.Id,
                            Name = user.Name,
                            Identity = user.Identity,
                            ContactPhoneNumber = user.ContactPhoneNumber,
                            Gender = user.Gender,
                            Age = user.Age,
                            IdentityImg = user.IdentityImg,
                            IdentityBackImg = user.IdentityBackImg,
                        };
                        await repEnterpriseEmployee.InsertAsync(employee);
                    }
                    else
                    {
                        employee.UserId = logier.Id;
                        await repEnterpriseEmployee.UpdateAsync(employee);
                    }
                    var entity = new TaskInfoUser
                    {
                        TaskInfoId = taskId,
                        EnterpriseEmployeeId = employee.Id,
                        HireStatus = EnumTaskUserHireStatus.Wait
                    };
                    await repTaskInfoUser.InsertAsync(entity);
                }
            }
            return taskIds.Count;
        }
    }
}