using Dlhis.Basic.BusinessPlace.Response;
using Dlhis.Basic.BusinessShift.Request;
using Dlhis.Basic.BusinessShift.Response;
using Dlhis.Entity.Basic.Entity;
using Dlhis.User.Api;
using Kurisu.AspNetCore.Utils.Extensions;
using Kurisu.Core.CustomClass;
using Kurisu.Core.DataAccess.Dto;
using Kurisu.Core.Result;
using Kurisu.Core.User.Abstractions;
using Kurisu.SqlSugar.Attributes;
using Kurisu.SqlSugar.Extensions;
using Kurisu.SqlSugar.Services;
using Mapster;

namespace Dlhis.Basic.BusinessShift.Services.Implements;

public class BusinessPlaceShiftService : IBusinessPlaceShiftService
{
    private readonly IDbContext _dbContext;
    private readonly ITenantApi _tenantApi;

    public BusinessPlaceShiftService(IDbContext dbContext, ITenantApi tenantApi)
    {
        _dbContext = dbContext;
        _tenantApi = tenantApi;
    }

    public async Task<Pagination<BusinessPlaceShiftResponse>> GetPageAsync(BusinessPlaceShiftPageRequest request)
    {
        var page = await _dbContext.Queryable<CanteenBusinessShiftEntity>()
                .LeftJoin<CanteenBusinessPlaceEntity>((shift, place) => shift.BusinessPlaceCode == place.Code)
                .LeftJoin<BasicTypeEntity>((shift, place,type)=>shift.Code.ToString() == type.Code)
                .WhereIF(request.Search.IsPresent(), (shift, place) => shift.CustomCode.Contains(request.Search) )
                .WhereIF(request.BusinessPlaceCode.HasValue, (shift, place) => shift.BusinessPlaceCode == request.BusinessPlaceCode)
                .Select((shift, place, type) => new BusinessPlaceShiftResponse
                {
                    Id = shift.Id,
                    BusinessPlaceCode = place.Code,
                    BusinessPlaceCustomCode = place.CustomCode,
                    BusinessPlace = place.Name,
                    Code = shift.Code,
                    CustomCode = shift.CustomCode,
                    Name = type.Display,
                    Start = shift.Start,
                    End = shift.End
                })
               .ToPageListAsync(request);

        return page;
    }

    public async Task SaveAsync(BusinessPlaceShiftSaveRequest request)
    {
        await CheckExistsCustomCodeAsync(request);
        await DuplicateTimePeriodAsync(request);
        await CheckPlaceExistsAsync(request.BusinessPlaceCode);


        if (!request.Id.HasValue)
        {
            var entity = request.Adapt<CanteenBusinessShiftEntity>();

            entity.Code = Guid.NewGuid();
            entity.Start = request.TimePeriod.Start.Value;
            entity.End = request.TimePeriod.End.Value;

            await _dbContext.InsertAsync(entity);
        }
        else
        {
            var entity = await _dbContext.Queryable<CanteenBusinessShiftEntity>().FirstAsync(x => x.Id == request.Id);
            entity.Adapt(request);

            await _dbContext.UpdateAsync(entity);
        }
    }

    [IgnoreTenant]
    public async Task<BusinessPlaceWithShiftResponse> GetShiftsByPlaceCustomCodeAsync(string placeCustomCode)
    {
        var place = await _dbContext.Queryable<CanteenBusinessPlaceEntity>().Where(x => x.CustomCode == placeCustomCode).FirstAsync();
        if (place == null)
        {
            return new BusinessPlaceWithShiftResponse()
            {
                Shifts = new List<BusinessPlaceShiftTinyResponse>()
            };
        }

        var shifts = await _dbContext.Queryable<CanteenBusinessShiftEntity>()
            .Where(x => x.BusinessPlaceCode == place.Code)
            .OrderBy(x => x.Sequence) //排序
            .ToListAsync();

        var tenantResult = await _tenantApi.GetTenantByCodeAsync(place.TenantId);
        (tenantResult.Code == ApiStateCode.Success).ThrowIfFalse(tenantResult.Msg);
        var tenantInfo = tenantResult.Data;

        var list = new List<BusinessPlaceShiftTinyResponse>();
        foreach (var shiftinfo in shifts)
        {
            var name = _dbContext.Queryable<BasicTypeEntity>()
                    .Where(x => x.Code == shiftinfo.Code.ToString())
                    .Select(x => x.Display)
                    .First();
            var shift = new BusinessPlaceShiftTinyResponse
            {
                CustomCode = shiftinfo.CustomCode,
                Name = name,
                Start = shiftinfo.Start,
                End = shiftinfo.End
            };
            list.Add(shift);
        }
        return new BusinessPlaceWithShiftResponse
        {
            CustomCode = placeCustomCode,
            Name = place.Name,
            TenantCode = tenantInfo.Code,
            TenantName = tenantInfo.Name,
            Shifts = list
        };
    }

    //*********************************************** help methods ***************************************************//


    private async Task CheckPlaceExistsAsync(Guid code)
    {
        var existsPlace = await _dbContext.Queryable<CanteenBusinessPlaceEntity>().AnyAsync(x => x.Code == code);
        existsPlace.ThrowIfFalse("营业点不存在,请检查.");
    }

    /// <summary>
    /// 时间段重合检查
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    private async Task DuplicateTimePeriodAsync(BusinessPlaceShiftSaveRequest request)
    {
        var periods = await _dbContext.Queryable<CanteenBusinessShiftEntity>()
            .Where(x => x.BusinessPlaceCode == request.BusinessPlaceCode)
              .WhereIF(request.Id.HasValue, x => x.Id != request.Id)
              .Select(x => new TimePeriod
              {
                  Start = x.Start,
                  End = x.End,
              })
              .ToListAsync();

        foreach (var period in periods)
        {
            period.IsDuplicate(request.TimePeriod).ThrowIfTrue($"存在时间段重合[{period.Start}-{period.End}]");
        }
    }


    /// <summary>
    /// 检查重复手工号
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    private async Task CheckExistsCustomCodeAsync(BusinessPlaceShiftSaveRequest request)
    {
        var existsSameCustomCode = await _dbContext.Queryable<CanteenBusinessShiftEntity>()
               .Where(x => x.CustomCode == request.CustomCode)
               .WhereIF(request.Id.HasValue, x => x.Id != request.Id)
               .AnyAsync();

        existsSameCustomCode.ThrowIfTrue($"自定义手工号[{request.CustomCode}]存在重复,请检查.");
    }

}