using Microsoft.Extensions.Logging;
using DD.Persistence.Client.Clients.Base;
using DD.Persistence.Client.Clients.Interfaces;
using DD.Persistence.Client.Clients.Interfaces.Refit;
using DD.Persistence.Models;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Globalization;

namespace DD.Persistence.Client.Clients;

public class SetpointClient : BaseClient, ISetpointClient
{
	private readonly IRefitSetpointClient refitSetpointClient;
    private readonly ISetpointConfigStorage setpointConfigStorage;

    public SetpointClient(
        IRefitClientFactory<IRefitSetpointClient> refitSetpointClientFactory, 
        ISetpointConfigStorage setpointConfigStorage, 
        ILogger<SetpointClient> logger) : base(logger)
	{
		this.refitSetpointClient = refitSetpointClientFactory.Create();
        this.setpointConfigStorage = setpointConfigStorage;
    }

	public async Task<IEnumerable<SetpointValueDto>> GetCurrent(IEnumerable<Guid> setpointKeys, CancellationToken token)
	{
		var result = await ExecuteGetResponse(
			async () => await refitSetpointClient.GetCurrent(setpointKeys, token), token);

        return result!.Select(x => new SetpointValueDto {
            Key = x.Key,
            Value = DeserializeValue(x.Key, x.Value)
        });
	}

    private object DeserializeValue(Guid key, JsonElement value)
    {
        if (setpointConfigStorage.TryGetType(key, out var type))
            return value.Deserialize(type)!;

        return value;
    }

    public async Task<Dictionary<Guid, object>> GetCurrentDictionary(IEnumerable<Guid> setpointConfigs, CancellationToken token)
    {
        var result = await ExecuteGetResponse(
            async () => await refitSetpointClient.GetCurrent(setpointConfigs, token), token);
        

        return result!.ToDictionary(x => x.Key,x => DeserializeValue(x.Key,x.Value));
    }


    //private Dictionary<Guid, object?> DeserializeResultToDict(IEnumerable<SetpointValueDto> data)
    //{
    //    var dict = new Dictionary<Guid, object?>();
        

    //    foreach (var valueDto in data)
    //    {
    //        if (valueDto.Value is not null &&
    //            valueDto.Value is JsonElement element &&
    //            setpointConfigStorage.TryGetType(valueDto.Key, out var type) &&
    //            type is not null)

    //            dict[valueDto.Key] = element.Deserialize(type) ?? valueDto.Value;
    //        else
    //            dict[valueDto.Key] = valueDto.Value;
    //    }

    //    return dict;
    //}

    public async Task<IEnumerable<SetpointValueDto>> GetHistory(IEnumerable<Guid> setpointKeys, DateTimeOffset historyMoment, CancellationToken token)
	{
		var result = await ExecuteGetResponse(
			async () => await refitSetpointClient.GetHistory(setpointKeys, historyMoment, token), token);

		return result!;
	}

	public async Task<Dictionary<Guid, IEnumerable<SetpointLogDto>>> GetLog(IEnumerable<Guid> setpointKeys, CancellationToken token)
	{
		var result = await ExecuteGetResponse(
			async () => await refitSetpointClient.GetLog(setpointKeys, token), token);

		return result!;
	}

	public async Task<DatesRangeDto> GetDatesRangeAsync(CancellationToken token)
	{
		var result = await ExecuteGetResponse(
			async () => await refitSetpointClient.GetDatesRangeAsync(token), token);

		return result!;
	}

	public async Task<IEnumerable<SetpointLogDto>> GetPart(DateTimeOffset dateBegin, int take, CancellationToken token)
	{
		var result = await ExecuteGetResponse(
			async () => await refitSetpointClient.GetPart(dateBegin, take, token), token);

		return result!;
	}

	public async Task Add(Guid setpointKey, object newValue, CancellationToken token)
	{
		await ExecutePostResponse(
			async () => await refitSetpointClient.Add(setpointKey, newValue, token), token);
	}

	public void Dispose()
	{
		refitSetpointClient.Dispose();

        GC.SuppressFinalize(this);
    }

    
}