using Tiobon.Core.IServices;
using Tiobon.Core.Model.Models;
using Tiobon.Core.Services.BASE;
using Tiobon.Core.IRepository.Base;
using Tiobon.Core.Common.Caches;
using Microsoft.AspNetCore.Http;
using Tiobon.Core.Common.UserManager;
using Tiobon.Core.Model;
using Tiobon.Core.Common.Helper;
using Tiobon.Core.Common;
using static Tiobon.Core.Model.Consts;

namespace Tiobon.Core.Services;

/// <summary>
/// 培训需求 (服务)
/// </summary>
public class Ghre_RequestServices : BaseServices<Ghre_Request, Ghre_RequestDto, InsertGhre_RequestInput, EditGhre_RequestInput>, IGhre_RequestServices
{
    private readonly IBaseRepository<Ghre_Request> _dal;
    public Ghre_RequestServices(ICaching caching, IBaseRepository<Ghre_Request> dal)
    {
        this._dal = dal;
        base.BaseDal = dal;
        base._caching = caching;
    }


    public override async Task<ServicePageResult<Ghre_RequestDto>> QueryFilterPage(QueryBody filter, string condition, bool? IsEnable = true)
    {

        var sql = "update A set A.CourseName= B.CourseName  FROM Ghre_Request A join Ghre_Course B on A.CourseId = B.Id and A.CourseName != B.CourseName";
        await Db.Ado.ExecuteCommandAsync(sql);

        var result = await base.QueryFilterPage(filter, condition, IsEnable);
        //var courseIds = result.result.DT_TableDataT1.Where(x => x.CourseId != null).Select(x => x.CourseId).Distinct().ToList();
        //var courses = await Db.Queryable<Ghre_Course>().Where(x => courseIds.Contains(x.Id)).ToListAsync();
        var deptIds = result.result.DT_TableDataT1.Where(x => x.DeptId != null).Select(x => x.DeptId).Distinct().ToList();
        var depts = await Db.Queryable<Ghro_Dept>().Where(x => deptIds.Contains(x.DeptID)).ToListAsync();

        var sponsorIds = result.result.DT_TableDataT1.Where(x => x.SponsorId != null).Select(x => x.SponsorId).Distinct().ToList();
        var userIds = result.result.DT_TableDataT1.Where(x => x.RefuseUserId != null).Select(x => x.RefuseUserId).Distinct().ToList();
        userIds.AddRange(result.result.DT_TableDataT1.Where(x => x.AgreeUserId != null).Select(x => x.AgreeUserId).Distinct());
        result.result.DT_TableDataT1.ForEach(x =>
        {
            string trainStaffId = x.TrainStaffId;
            if (!string.IsNullOrWhiteSpace(trainStaffId))
            {
                x.TrainStaffIds = JsonHelper.JsonToObj<List<int>>(trainStaffId);
                var TrainStaffIds = JsonHelper.JsonToObj<List<long?>>(trainStaffId);
                sponsorIds.AddRange(TrainStaffIds);
            }


        });
        sponsorIds = sponsorIds.Distinct().ToList();
        var staffs = await Db.Queryable<Ghra_Staff>().Where(x => sponsorIds.Contains(x.StaffID)).ToListAsync();
        var users = await Db.Queryable<Ghrs_User>().Where(x => userIds.Contains(x.UserId)).ToListAsync();
        result.result.DT_TableDataT1.ForEach(async x =>
        {
            x.CourseSourceLabel = await GetParaLabel("TrainingRequestCourseSource", x.CourseSource);
            x.RequestSourceLabel = await GetParaLabel("TrainingRequestRequestSource", x.RequestSource);
            x.TrainClassLabel = await GetParaLabel("TrainingRequestTrainClass", x.TrainClass);
            x.TrainLevelLabel = await GetParaLabel("TrainingRequestTrainLevel", x.TrainLevel);
            x.InOrOutLabel = await GetParaLabel("CourseInOrOut", x.InOrOut);
            x.TeacherClassLabel = await GetParaLabel("TrainingTeacherType", x.InOrOut);

            //if (x.CourseId != null)
            //    x.CourseName = courses.Where(o => x.CourseId == o.Id).FirstOrDefault()?.CourseName;

            if (x.DeptId != null)
                x.DeptName = depts.Where(o => x.DeptId == o.DeptID).FirstOrDefault()?.DeptName;

            if (x.SponsorId != null)
                x.SponsorName = staffs.Where(o => x.SponsorId == o.StaffID).FirstOrDefault()?.StaffName;
            if (x.TrainStaffIds.IsNotEmptyOrNull())
                x.TrainStaffNames = string.Join("、", staffs.Where(o => x.TrainStaffIds.Contains(o.StaffID)).Select(o => o.StaffName));


            if (x.AgreeUserId != null)
                x.AgreeUserName = users.Where(o => x.AgreeUserId == o.UserId).FirstOrDefault()?.UserName;


            if (x.RefuseUserId != null)
                x.RefuseUserName = users.Where(o => x.RefuseUserId == o.UserId).FirstOrDefault()?.UserName;

            if (x.WorkState.IsNotEmptyOrNull())
            {
                if (x.WorkState == 0) x.WorkStateLabel = "审批中";
                if (x.WorkState == 1) x.WorkStateLabel = "审批通过";
            }
        });
        return result;

    }

    public override async Task<long> Add(InsertGhre_RequestInput entity)
    {
        entity.SponsorId = GetStaffId();
        if (entity.TrainStaffIds.IsNotEmptyOrNull())
            entity.TrainStaffId = JsonHelper.ObjToJson(entity.TrainStaffIds);
        entity.RequestNo = await GenerateContinuousSequence("Ghre_Request", "RequestNo", "R");

        var id = await base.Add(entity);

        var sql = $"SELECT MAX(id)+1 FROM Ghre_Request WHERE Id !='{id}'";
        var id1 = await Db.Ado.GetLongAsync(sql);
        sql = $"UPDATE Ghre_Request SET Id={id1} WHERE  Id ='{id}'";
        await Db.Ado.ExecuteCommandAsync(sql);
        return id1;
    }

    public override async Task<bool> Update(long Id, EditGhre_RequestInput entity)
    {
        if (entity.TrainStaffIds.IsNotEmptyOrNull())
            entity.TrainStaffId = JsonHelper.ObjToJson(entity.TrainStaffIds);
        else entity.TrainStaffId = null;
        return await base.Update(Id, entity, null, ["Status"]);
    }
    public async Task<ServiceResult<long>> InsertByStatus(InsertGhre_RequestInput insertModel, string status)
    {
        var data = ServiceResult<long>.OprateSuccess("新增成功", 0);
        insertModel.Status = status;
        var id = await Add(insertModel);

        data.Success = id > 0;
        if (data.Success)
            data.Data = id;
        else
            return ServiceResult<long>.OprateFailed("发布成功！");

        return data;
    }

    public override async Task<ServiceFormResult<Ghre_RequestDto>> QueryForm(QueryForm body)
    {
        var result = await base.QueryForm(body);
        string trainStaffId = result.result.DT_TableDataT1[0].TrainStaffId;
        if (!string.IsNullOrWhiteSpace(trainStaffId))
            result.result.DT_TableDataT1[0].TrainStaffIds = JsonHelper.JsonToObj<List<int>>(trainStaffId);
        else result.result.DT_TableDataT1[0].TrainStaffIds = new List<int>();
        return result;

    }

    public async Task<ServiceResult> UpdateStatus(InsertGhre_RequestInput input, string status)
    {

        HttpRequest request = UserContext.Context.Request;
        var api = request.Path.ObjToString().TrimEnd('/').ToLower();
        var ip = GetUserIp(UserContext.Context);

        var entities = new List<Ghre_Request>();
        foreach (var id in input.Ids)
        {
            if (!BaseDal.Any(id))
                continue;

            var entity = await BaseDal.QueryById(id);


            switch (status)
            {
                case DIC_REQUEST_STATUS.Active:
                    entity.AgreeReason = input.Reason;
                    entity.AgreeTime = DateTime.Now;
                    entity.AgreeUserId = App.User.ID;
                    break;
                case DIC_REQUEST_STATUS.Temporary:
                    entity.RefuseReason = input.Reason;
                    entity.RefuseTime = DateTime.Now;
                    entity.RefuseUserId = App.User.ID;
                    break;
            }

            entity.UpdateIP = ip;
            entity.UpdateProg = api;
            entity.Status = status;
            entities.Add(entity);
        }

        var result = await BaseDal.Update(entities);
        return ServiceResult.OprateSuccess("执行成功！");
        //if (status == Consts.DIC_COURSE_STATUS.RELEASED)
        //    return ServiceResult.OprateSuccess("发布成功！");
        //else if (status == Consts.DIC_COURSE_STATUS.DRAFT)
        //    return ServiceResult.OprateSuccess("已启用成功，请进入草稿箱查看！");
        //else
        //    return ServiceResult.OprateSuccess("停用成功！");

    }
}