using System.Net.Http.Headers;
using System.Reflection;
using System.Text;
using Dlhis.Middle.Entities;
using Dlhis.Middle.Response;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
using Kurisu.AspNetCore.UnifyResultAndValidation;
using Kurisu.AspNetCore.Utils.Extensions;
using Microsoft.AspNetCore.WebUtilities;
using Microsoft.Extensions.Caching.Memory;
using Newtonsoft.Json;
using SqlSugar;

namespace Dlhis.Middle.Services.Implements;

public class DataDownloadService : IDataDownloadService
{
    private readonly IHttpClientFactory _httpClientFactory;
    private readonly IMemoryCache _memoryCache;
    private readonly IDbContext _dbContext;
    private readonly string _hostName;

    public DataDownloadService(IHttpClientFactory httpClientFactory, IMemoryCache memoryCache, IConfiguration configuration, IDbContext dbContext)
    {
        _httpClientFactory = httpClientFactory;
        _memoryCache = memoryCache;
        _dbContext = dbContext;
        _hostName = configuration.GetSection("HostName").Value;
    }

    public async Task InitAsync(string factory)
    {
        var factories = factory.Split(',');

        await TruncateAsync();

        foreach (var item in factories)
        {
            if (!await _dbContext.Queryable<LocalDepartmentEntity>().AnyAsync())
            {
                await DownloadAsync<LocalDepartmentEntity>(item);
            }

            await DownloadAsync<LocalDeviceEntity>(item);
            await DownloadAsync<LocalDeviceRegistryEntity>(item);

            await DownloadAsync<LocalBusinessPlaceEntity>(item);
            await DownloadAsync<LocalBusinessShiftEntity>(item);
            await DownloadAsync<LocalBusinessPlaceShiftRelationshipEntity>(item);

            await DownloadAsync<LocalBusinessShiftMealRelationshipEntity>(item);

            if (!await _dbContext.Queryable<LocalGainfoEntity>().Where(x => x.Factory == item).AnyAsync())
            {
                await DownloadAsync<LocalGainfoEntity>(item);
            }

            if (!await _dbContext.Queryable<LocalGainfoMealEntity>().AnyAsync())
            {
                foreach (var currentItem in factories)
                {
                    await DownloadAsync<LocalGainfoMealEntity>(currentItem);
                }
            }
        }
    }

    public async Task DownloadAsync<T>(string factory) where T : class, new()
    {
        var token = await AuthAsync();

        var httpClient = _httpClientFactory.CreateClient("face");
        httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

        var url = $"https://{_hostName}/api/common/SysData/download";

        var requestUrl = QueryHelpers.AddQueryString(url, new Dictionary<string, string>
        {
            ["factory"] = factory,
            ["tableName"] = typeof(T).GetCustomAttribute<SugarTable>()!.TableName
        });

        var response = await httpClient.GetStringAsync(requestUrl);
        var pack = response.ToObject<DefaultApiResult<List<T>>>();

        await _dbContext.InsertAsync(pack.Data);
    }

    /// <inheritdoc />
    public async Task TruncateAsync()
    {
        await _dbContext.Client.Deleteable<LocalDepartmentEntity>().ExecuteCommandAsync();
        await _dbContext.Client.Deleteable<LocalDeviceEntity>().ExecuteCommandAsync();
        await _dbContext.Client.Deleteable<LocalDeviceRegistryEntity>().ExecuteCommandAsync();
        await _dbContext.Client.Deleteable<LocalBusinessPlaceEntity>().ExecuteCommandAsync();
        await _dbContext.Client.Deleteable<LocalBusinessShiftEntity>().ExecuteCommandAsync();
        await _dbContext.Client.Deleteable<LocalBusinessPlaceShiftRelationshipEntity>().ExecuteCommandAsync();
        await _dbContext.Client.Deleteable<LocalBusinessShiftMealRelationshipEntity>().ExecuteCommandAsync();

        //await _dbContext.Client.Deleteable<LocalGainfoEntity>().ExecuteCommandAsync();
        //await _dbContext.Client.Deleteable<LocalGainfoMealEntity>().ExecuteCommandAsync();
    }

    /// <inheritdoc />
    public async Task DownloadGainfosAsync(string factory)
    {
        await _dbContext.Client.Ado.BeginTranAsync();
        try
        {
            await _dbContext.Client.Deleteable<LocalGainfoEntity>().ExecuteCommandAsync();
            await _dbContext.Client.Deleteable<LocalGainfoMealEntity>().ExecuteCommandAsync();

            await DownloadAsync<LocalGainfoEntity>(factory);
            await DownloadAsync<LocalGainfoMealEntity>(factory);
            
            
            await DownloadAsync<LocalDeviceEntity>(factory);
            await DownloadAsync<LocalDeviceRegistryEntity>(factory);

            await DownloadAsync<LocalBusinessPlaceEntity>(factory);
            await DownloadAsync<LocalBusinessShiftEntity>(factory);
            await DownloadAsync<LocalBusinessPlaceShiftRelationshipEntity>(factory);

            await DownloadAsync<LocalBusinessShiftMealRelationshipEntity>(factory);

            await _dbContext.Client.Ado.CommitTranAsync();
        }
        catch (Exception)
        {
            await _dbContext.Client.Ado.RollbackTranAsync();
        }
    }

    private async Task<string> AuthAsync()
    {
        var httpClient = _httpClientFactory.CreateClient("face");

        if (_memoryCache.TryGetValue("token", out string token)) return token;

        var tokenResponse = await httpClient.PostAsync($"https://{_hostName}/api/User/OAuth2/clientgrant", new StringContent(JsonConvert.SerializeObject(new
        {
            ClientId = "e509c2aaa98e300c",
            ClientSecret = "6184d8979fc48105"
        }), Encoding.UTF8, "application/json"));

        var tokenJson = await tokenResponse.Content.ReadAsStringAsync();
        var tokenInfo = JsonConvert.DeserializeObject<DefaultApiResult<TokenResponse>>(tokenJson);

        token = tokenInfo.Data.AccessToken;

        _memoryCache.Set("token", token, TimeSpan.FromSeconds(tokenInfo.Data.Expires));

        return token;
    }
}