using System.Reflection;
using Dlhis.Basic.Organization.Request;
using Dlhis.Basic.Organization.Response;
using Dlhis.Entity.Basic.Dto;
using Dlhis.Entity.Basic.Enums;
using Dlhis.Entity.Sys.Entities;
using Dlhis.Sys.Api;
using Dlhis.Sys.Api.Response;
using Kurisu.AspNetCore.Authentication.Abstractions;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
using Kurisu.AspNetCore.Utils.Extensions;
using Mapster;
using SqlSugar;

namespace Dlhis.Basic.Organization.Services.Implements;

public class FactorySettingService : IFactorySettingService
{
    private readonly IDbContext _dbContext;
    private readonly ITenantApi _tenantApi;
    private readonly ICurrentUser _currentUser;

    public FactorySettingService(IDbContext dbContext, ITenantApi tenantApi, ICurrentUser currentUser)
    {
        _dbContext = dbContext;
        _tenantApi = tenantApi;
        _currentUser = currentUser;
    }

    public async Task<List<FactorySettingResponse>> GetListAsync(bool usePermission)
    {
        return await GetFactorySettingsAsync(null, usePermission);
    }

    public async Task SaveAsync(FactorySettingSaveRequest request)
    {
        var setting = await _dbContext.Queryable<FactorySettingEntity>().Where(x => request.Factory == x.TenantId).SingleAsync();
        if (setting == null)
        {
            setting = request.Adapt<FactorySettingEntity>();
            setting.EnableUseBirthdayVoucherFactories = request.EnableUseBirthdayVoucherFactories.ToJson();
            setting.TenantId = request.Factory;

            await _dbContext.InsertAsync(setting);
        }
        else
        {
            request.Adapt(setting);
            setting.EnableUseBirthdayVoucherFactories = request.EnableUseBirthdayVoucherFactories.ToJson();
            setting.TenantId = request.Factory;

            await _dbContext.UpdateAsync(setting);
        }
    }

    public async Task<bool> IsEnableBirthdayVoucherAsync(string factory, bool usePermission)
    {
        var setting = await GetFactorySettingAsync(factory, usePermission);
        return setting.EnableBirthdayVoucher;
    }


    public async Task<FactorySettingResponse> GetFactorySettingAsync(string factory, bool usePermission)
    {
        var settings = await GetFactorySettingsAsync(factory, usePermission);
        var setting = settings.FirstOrDefault() ?? new FactorySettingResponse();

        setting.UserQrCodeExpiration ??= 60;
        setting.FaceImageDetection ??= new FaceImageDetectionDto
        {
            Enable = true,
            Detections = typeof(FaceQualityTypeEnumType).GetFields(BindingFlags.Public | BindingFlags.Static).Select(x => new FaceImageDetection
            {
                Type = Enum.Parse<FaceQualityTypeEnumType>(x!.GetValue(null)!.ToString()!),
                Level = FaceQualityLevelEnumType.Medium
            }).ToList()
        };

        return setting;
    }

    /// <inheritdoc />
    public async Task<TimeOnly> GetWorkGridSetLimitAsync()
    {
        var factory = _currentUser.GetStringTenantId();
        var v = new TimeOnly(20, 30, 0);

        var vv = await _dbContext.Queryable<FactorySettingEntity>()
            .Where(x => x.TenantId == factory)
            .Select(x => SqlFunc.IsNull(x.WorkGridSetLimit, v))
            .SingleAsync();

        return vv!.Value;
    }

    /// <inheritdoc />
    public async Task CheckWorkGridSetLimitAsync(DateOnly date)
    {
        var result = await IsWorkGridSetLimitAsync(date);
        result.ThrowIfTrue("当前时间不可编辑");
    }

    /// <inheritdoc />
    public async Task<bool> IsWorkGridSetLimitAsync(DateOnly date)
    {
        var now = DateTime.Now;
        var time = await GetWorkGridSetLimitAsync();
        var setting = date.ToDateTime(time);

        return now >= setting;
    }


    public async Task<List<string>> GetEnableBirthdayVoucherFactoriesAsync()
    {
        var settings = await GetListAsync(false);
        return settings.Where(x => x.EnableBirthdayVoucher).Select(x => x.Factory).ToList();
    }

    public async Task<List<string>> GetEnableUseBirthdayVoucherFactoriesAsync(string currentFactory)
    {
        var settings = await GetFactorySettingsAsync(currentFactory, false);
        var setting = settings.Where(x => x.EnableBirthdayVoucher).FirstOrDefault();
        return setting.EnableUseBirthdayVoucherFactories;
    }

    //************************************************************************************************************************************************************

    private async Task<List<FactorySettingResponse>> GetFactorySettingsAsync(string factory, bool usePermission)
    {
        List<TenantResponse> factories;


        if (factory.IsPresent())
        {
            factories = new List<TenantResponse> { new() { Code = factory } };
        }
        else
        {
            if (usePermission)
            {
                factories = await _tenantApi.GetMyTenantsAsync();
            }
            else
            {
                factories = await _tenantApi.GetTenantsInternalAsync();
            }
        }

        var factoryCodes = factories.Select(x => x.Code).ToList();
        var settings = await _dbContext.Queryable<FactorySettingEntity>()
            .Where(x => factoryCodes.Contains(x.TenantId))
            .ToListAsync();

        return factories.Select(item =>
        {
            var currentFactory = factories.FirstOrDefault(x => x.Code == item.Code);
            var currentSetting = settings.FirstOrDefault(x => x.TenantId == item.Code);
            return new FactorySettingResponse
            {
                Factory = currentFactory?.Code,
                FactoryName = currentFactory?.Name,
                EnableOutsourceDown = currentSetting?.EnableOutsourceDown ?? false,
                UserQrCodeExpiration = currentSetting?.UserQrCodeExpiration,
                FaceImageDetection = currentSetting?.FaceImageDetection ?? new FaceImageDetectionDto
                {
                    Enable = true,
                    Detections = typeof(FaceQualityTypeEnumType).GetFields(BindingFlags.Public | BindingFlags.Static).Select(x => new FaceImageDetection
                    {
                        Type = Enum.Parse<FaceQualityTypeEnumType>(x!.GetValue(null)!.ToString()!),
                        Level = FaceQualityLevelEnumType.Medium
                    }).ToList()
                },
                NoRecordAutoResignOutsourceDays = currentSetting?.NoRecordAutoResignOutsourceDays ?? 30,
                NoRecordAutoResignExternalDays = currentSetting?.NoRecordAutoResignExternalDays ?? 0,
                EnableBirthdayVoucher = currentSetting?.EnableBirthdayVoucher ?? false,
                EnableUseBirthdayVoucherFactories = (currentSetting?.EnableUseBirthdayVoucherFactories ?? "[]").ToObject<List<string>>()
            };
        }).ToList();
    }

}