using EVCB_OCPP.Domain.ConnectionFactory;
using EVCB_OCPP.Domain;
using EVCB_OCPP.Domain.Models.MainDb;
using Microsoft.Extensions.Logging;
using EVCB_OCPP.DBAPI.Helper;
using Microsoft.EntityFrameworkCore.Internal;
using Microsoft.EntityFrameworkCore;
using System.Diagnostics.CodeAnalysis;

namespace EVCB_OCPP.DBAPI.Services.DbService;

public interface IMainDbService
{
    Task<string> AddServerMessage(ServerMessage message, CancellationToken token = default);
}

public class MainDbService : IMainDbService
{
    public MainDbService(
        ISqlConnectionFactory<MainDBContext> sqlConnectionFactory,
        IDbContextFactory<MainDBContext> contextFactory,
        ILogger<MainDbService> logger,
        ILoggerFactory loggerFactory)
    {
        this.sqlConnectionFactory = sqlConnectionFactory;
        this.contextFactory = contextFactory;
        this.logger = logger;
        this.loggerFactory = loggerFactory;

        InitAddServerMessageHandler();
    }
    private readonly IDbContextFactory<MainDBContext> contextFactory;
    private readonly ILogger<MainDbService> logger;
    private readonly ILoggerFactory loggerFactory;
    private readonly ISqlConnectionFactory<MainDBContext> sqlConnectionFactory;
    private GroupHandler<ServerMessage, string> addServerMessageHandler;

    public Task<string> AddServerMessage(ServerMessage message, CancellationToken token = default)
    {
        message.Id = 0;
        return addServerMessageHandler.HandleAsync(message, token);
    }

    [MemberNotNull(nameof(addServerMessageHandler))]
    private void InitAddServerMessageHandler()
    {
        if (addServerMessageHandler is not null)
        {
            throw new Exception($"{nameof(InitAddServerMessageHandler)} should only called once");
        }

        addServerMessageHandler = new GroupHandler<ServerMessage, string>(
            handleFunc: BundleAddServerMessage,
            logger: loggerFactory.CreateLogger("AddServerMessageHandler"));
    }

    private async Task BundleAddServerMessage(BundleHandlerData<ServerMessage, string> bundleHandlerData)
    {
        using var db = await contextFactory.CreateDbContextAsync();
        using var trans = await db.Database.BeginTransactionAsync();

        foreach (var message in bundleHandlerData.Datas)
        {
            await db.ServerMessage.AddAsync(message);
        }

        await db.SaveChangesAsync();
        await trans.CommitAsync();

        bundleHandlerData.CompletedDatas.AddRange(bundleHandlerData.Datas.Select(x => new KeyValuePair<ServerMessage, string>(x, x.SerialNo)));
    }
}