using Dlhis.Basic.Places.Request;
using Dlhis.Basic.BusinessShift.Request;
using Dlhis.Basic.BusinessShift.Response;
using Dlhis.Basic.Places.Response;
using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Device.Entities;
using Dlhis.Sys.Api;
using Kurisu.AspNetCore.CustomClass;
using Kurisu.AspNetCore.DataAccess.Dto;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Extensions;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
using Kurisu.AspNetCore.Utils.Extensions;
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<BusinessShiftEntity>()
            .WhereIF(request.Search.IsPresent(), shift => shift.CustomCode.Contains(request.Search) || shift.Name.Contains(request.Search))
            .Select<BusinessPlaceShiftResponse>()
            .ToPageListAsync(request);

        var shiftCodes = page.Data.Select(x => x.Code).ToList();

        //下级就餐时间段
        var mealShifts = await _dbContext.Queryable<BusinessShiftMealRelationshipEntity>()
            .Where(x => shiftCodes.Contains(x.ShiftCode))
            .Select((x) => new MealShiftResponse
            {
                Id = x.Id,
                ShiftCode = x.ShiftCode,
                ShiftType = x.ShiftType,
                Start = x.Start,
                End = x.End,
            })
            .ToListAsync();

        page.Data.ForEach(x => { x.MealShifts = mealShifts.Where(item => item.ShiftCode == x.Code).ToList(); });

        return page;
    }

    public async Task<List<BusinessPlaceShiftResponse>> GetListAsync()
    {
        var result = await _dbContext.Queryable<BusinessShiftEntity>()
            .Select<BusinessPlaceShiftResponse>()
            .ToListAsync();

        return result;
    }

    public async Task<Guid> SaveAsync(BusinessPlaceShiftSaveRequest request)
    {
        await CheckExistsAsync(request);

        if (!request.Id.HasValue)
        {
            var entity = request.Adapt<BusinessShiftEntity>();
            entity.CustomCode = request.CustomCode;
            entity.Code = Guid.NewGuid();
            await _dbContext.InsertAsync(entity);

            return entity.Code;
        }
        else
        {
            var entity = await _dbContext.Queryable<BusinessShiftEntity>().FirstAsync(x => x.Id == request.Id);
            entity.ThrowIfNull("餐别不存在");

            request.Adapt(entity);
            await _dbContext.UpdateAsync(entity);

            return entity.Code;
        }
    }

    public async Task SaveMealShiftsAsync(List<BusinessPlaceShiftSaveMealShiftRequest> requests)
    {
        var shiftCode = requests[0].ShiftCode;
        var shift = await CheckExistsShiftAsync(shiftCode);

        await _dbContext.Deleteable<BusinessShiftMealRelationshipEntity>().Where(x => x.ShiftCode == shiftCode).ExecuteCommandAsync();
        
        foreach (var request in requests)
        {
            request.Id = null;
            
            await CheckExistsMealShiftAsync(request);
            await DuplicateTimePeriodAsync(request);

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

                entity.ShiftCode = shift.Code;
                entity.ShiftCustomCode = shift.CustomCode;
                entity.Start = request.TimePeriod.Start;
                entity.End = request.TimePeriod.End;

                await _dbContext.InsertAsync(entity);
            }
            else
            {
                var entity = await _dbContext.Queryable<BusinessShiftMealRelationshipEntity>()
                    .Where(x => x.ShiftCode == shiftCode)
                    .SingleAsync(x => x.Id == request.Id);

                entity.ThrowIfNull("餐次段不存在");

                entity.Start = request.TimePeriod.Start;
                entity.End = request.TimePeriod.End;

                request.Adapt(entity);
                await _dbContext.UpdateAsync(entity);
            }
        }
    }


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

        var tenantResult = await _tenantApi.GetTenantByCodeAsync(place.TenantId);
        var tenantInfo = tenantResult.EnsureSuccessStatusCode();

        var relationship = await _dbContext.Queryable<BusinessPlaceShiftRelationshipEntity>().Where(x => x.PlaceCode == place.Code).FirstAsync();
        if (relationship == null)
        {
            return new BusinessPlaceWithShiftResponse()
            {
                CustomCode = placeCustomCode,
                Name = place.Name,
                TenantCode = tenantInfo.Code,
                TenantName = tenantInfo.Name,
                Shifts = new List<BusinessPlaceShiftTinyResponse>()
            };
        }

        var shifts = await _dbContext.Queryable<BusinessShiftMealRelationshipEntity>()
            .Where(x => x.ShiftCode == relationship.ShiftCode)
            .OrderBy(x => x.Sequence) //排序
            .ToListAsync();

        var list = new List<BusinessPlaceShiftTinyResponse>();

        foreach (BusinessShiftMealRelationshipEntity shiftinfo in shifts)
        {
            var shift = new BusinessPlaceShiftTinyResponse
            {
                CustomCode = shiftinfo.Id.ToString(),
                Name = shiftinfo.ShiftType.GetDescription(),
                Start = shiftinfo.Start,
                End = shiftinfo.End,
                Sequence = shiftinfo.Sequence
            };

            list.Add(shift);
        }

        return new BusinessPlaceWithShiftResponse
        {
            CustomCode = placeCustomCode,
            Name = place.Name,
            TenantCode = tenantInfo.Code,
            TenantName = tenantInfo.Name,
            Shifts = list.OrderBy(x => x.Sequence).ToList()
        };
    }

    public async Task<List<DeviceCodeNameDetail>> GetAssignmentsAsync(Guid code)
    {
        return await _dbContext.Queryable<DeviceRegistryEntity>()
            .LeftJoin<DeviceEntity>((x, d) => x.DeviceUniqueNo == d.UniqueNo)
            .Where(x => x.BusinessPlaceCode == code)
            .Select((x, d) => new DeviceCodeNameDetail
            {
                UniqueNo = x.DeviceUniqueNo,
                UniqueName = d.DeployPlace
            })
            .ToListAsync();
    }


    public async Task AssignAsync(DispositionDeviceRequest request)
    {
        var place = await _dbContext.Queryable<BusinessPlaceEntity>().Where(x => x.Code == request.PlaceCode).SingleAsync();
        place.ThrowIfNull("营业点不存在");

        var registries = await _dbContext.Queryable<DeviceRegistryEntity>()
            .Where(x => x.BusinessPlaceCode == request.PlaceCode || request.UniqueNos.Contains(x.DeviceUniqueNo))
            .ToListAsync();

        registries.ForEach(item => { item.BusinessPlaceCode = request.UniqueNos.Contains(item.DeviceUniqueNo) ? request.PlaceCode : null; });

        await _dbContext.UpdateAsync(registries);
    }

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

    /// <summary>
    /// 时间段重合检查
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    private async Task DuplicateTimePeriodAsync(BusinessPlaceShiftSaveMealShiftRequest request)
    {
        var periods = await _dbContext.Queryable<BusinessShiftMealRelationshipEntity>()
            .Where(x => x.ShiftCode == request.ShiftCode)
            .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 CheckExistsAsync(BusinessPlaceShiftSaveRequest request)
    {
        var existsSameCustomCode = await _dbContext.Queryable<BusinessShiftEntity>()
            .Where(x => x.CustomCode == request.CustomCode || x.Name == request.Name)
            .WhereIF(request.Id.HasValue, x => x.Id != request.Id)
            .AnyAsync();

        existsSameCustomCode.ThrowIfTrue($"自定义手工号或者名称存在重复,请检查.");
    }

    private async Task<BusinessShiftEntity> CheckExistsShiftAsync(Guid shiftCode)
    {
        var shift = await _dbContext.Queryable<BusinessShiftEntity>().Where(x => x.Code == shiftCode).SingleAsync();
        shift.ThrowIfNull("餐次不存在");

        return shift;
    }

    private async Task CheckExistsMealShiftAsync(BusinessPlaceShiftSaveMealShiftRequest request)
    {
        var exists = await _dbContext.Queryable<BusinessShiftMealRelationshipEntity>()
            .Where(x => x.ShiftCode == request.ShiftCode)
            .Where(x => x.ShiftType == request.ShiftType)
            .WhereIF(request.Id.HasValue, x => x.Id != request.Id)
            .AnyAsync();

        exists.ThrowIfTrue("重复设置!");
    }
}