using ComplianceDAL.DTO.GSTEWayBill;
using ComplianceDAL.Query.GSTEWayBill;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.QueryExecutor;
using Microsoft.Extensions.Logging;

namespace ComplianceDAL.CustomCode.GSTEWayBill;

public class GSTEWayBillDAL : IGSTEWayBillDAL
{
    private readonly IQueryExecutor _qe;
    private readonly ILogger<GSTEWayBillDAL> _logger;

    public GSTEWayBillDAL(IQueryExecutor qe, ILogger<GSTEWayBillDAL> logger)
    {
        _qe     = qe;
        _logger = logger;
    }

    public async Task<GSTEWayBillDTO?> GetEWayBillAsync(int eWayBillId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.QuerySingleAsync<GSTEWayBillDTO>(login, GSTEWayBillQB.GET_EWAYBILL,
                new { EWayBillId = eWayBillId, login.ClientId, login.DatabaseName }).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "E-Way Bill DAL: GetEWayBillAsync failed for EWayBillId {EWayBillId}", eWayBillId);
            throw;
        }
    }

    public async Task<GSTEWayBillDTO?> GetEWayBillByDocumentAsync(int documentId, string documentType, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.QuerySingleAsync<GSTEWayBillDTO>(login, GSTEWayBillQB.GET_EWAYBILL_BY_DOCUMENT,
                new { DocumentId = documentId, DocumentType = documentType, login.ClientId, login.DatabaseName }).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "E-Way Bill DAL: GetEWayBillByDocumentAsync failed for DocumentId {DocumentId}", documentId);
            throw;
        }
    }

    public async Task<int> SaveEWayBillAsync(GSTEWayBillDTO dto, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.ExecuteIdentityAsync(login, GSTEWayBillQB.SAVE_EWAYBILL,
                new
                {
                    dto.ArtifactId, dto.DocumentId, dto.DocumentType, dto.DocumentNumber, dto.DocumentDate,
                    dto.EWBNumber, dto.GSTIN,
                    dto.FromGSTIN, dto.FromName, dto.FromAddress, dto.FromPincode, dto.FromStateCode,
                    dto.ToGSTIN, dto.ToName, dto.ToAddress, dto.ToPincode, dto.ToStateCode,
                    dto.TransporterGSTIN, dto.TransporterName, dto.TransportDocNumber, dto.TransportDocDate,
                    dto.VehicleNumber, dto.VehicleType, dto.TransportMode, dto.Distance,
                    dto.TotalValue, dto.TaxableValue, dto.IGSTAmount, dto.CGSTAmount, dto.SGSTAmount, dto.CessAmount,
                    dto.ValidUpto, dto.SubmissionMode, dto.BatchId,
                    login.ClientId, login.DatabaseName,
                    CreatedById = login.UserId
                }).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "E-Way Bill DAL: SaveEWayBillAsync failed for DocumentId {DocumentId}, ArtifactId {ArtifactId}", dto.DocumentId, dto.ArtifactId);
            throw;
        }
    }

    public async Task<int> CancelEWayBillAsync(int eWayBillId, string cancellationReason, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.ExecuteAsync(login, GSTEWayBillQB.CANCEL_EWAYBILL,
                new
                {
                    EWayBillId = eWayBillId,
                    CancellationReason = cancellationReason,
                    ModifiedById = login.UserId,
                    login.ClientId, login.DatabaseName
                },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "E-Way Bill DAL: CancelEWayBillAsync failed for EWayBillId {EWayBillId}", eWayBillId);
            throw;
        }
    }

    public async Task<int> UpdateVehicleAsync(int eWayBillId, UpdateVehicleRequestDTO req, int modifiedById, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.ExecuteAsync(login, GSTEWayBillQB.UPDATE_VEHICLE,
                new
                {
                    EWayBillId = eWayBillId,
                    req.VehicleNumber, req.VehicleType, req.TransportMode,
                    req.TransportDocNumber, req.TransportDocDate,
                    ModifiedById = modifiedById,
                    login.ClientId, login.DatabaseName
                },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "E-Way Bill DAL: UpdateVehicleAsync failed for EWayBillId {EWayBillId}", eWayBillId);
            throw;
        }
    }

    public async Task<IEnumerable<GSTEWayBillDTO>> GetExpiringEWBsAsync(int hoursAhead, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.QueryAsync<GSTEWayBillDTO>(login, GSTEWayBillQB.GET_EXPIRING_EWBS,
                new { HoursAhead = hoursAhead, login.ClientId, login.DatabaseName },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "E-Way Bill DAL: GetExpiringEWBsAsync failed for HoursAhead {HoursAhead}", hoursAhead);
            throw;
        }
    }

    public async Task<IEnumerable<EWayBillCoverageDTO>> GetCoverageListAsync(string gstin, string returnPeriod, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.QueryAsync<EWayBillCoverageDTO>(login, GSTEWayBillQB.GET_EWAYBILL_COVERAGE_LIST,
                new { GSTIN = gstin, ReturnPeriod = returnPeriod, login.ClientId, login.DatabaseName },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "E-Way Bill DAL: GetCoverageListAsync failed for GSTIN {GSTIN}, ReturnPeriod {ReturnPeriod}", gstin, returnPeriod);
            throw;
        }
    }

    public async Task UpdateTMMHeadEWayByDocumentIdAsync(int documentId, string ebNumber, string ewayDate, string distance, string validUpto, LoginDTO login, CancellationToken ct)
    {
        try
        {
            await _qe.ExecuteAsync(login, GSTEWayBillQB.UPDATE_TMMHEAD_EWAY_BY_DOCUMENTID,
                new { DocumentId = documentId, EBNumber = ebNumber, EwayDate = ewayDate, Distance = distance, ValidUpto = validUpto },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "E-Way Bill DAL: UpdateTMMHeadEWayByDocumentIdAsync failed for DocumentId {DocumentId}", documentId);
            throw;
        }
    }

    public async Task ClearTMMHeadEBNumberAsync(string ebNumber, LoginDTO login, CancellationToken ct)
    {
        try
        {
            await _qe.ExecuteAsync(login, GSTEWayBillQB.CLEAR_TMMHEAD_EBNUMBER_BY_EBNUMBER,
                new { EBNumber = ebNumber },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "E-Way Bill DAL: ClearTMMHeadEBNumberAsync failed for EBNumber {EBNumber}", ebNumber);
            throw;
        }
    }

    public async Task<string?> GetTMMHeadIRNByDocumentIdAsync(int documentId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.ExecuteScalarAsync<string?>(login, GSTEWayBillQB.GET_TMMHEAD_IRN_BY_DOCUMENTID,
                new { DocumentId = documentId },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "E-Way Bill DAL: GetTMMHeadIRNByDocumentIdAsync failed for DocumentId {DocumentId}", documentId);
            throw;
        }
    }

    public async Task<string?> GetEwayGstinBasedOnOuAsync(string ebNumber, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.ExecuteScalarAsync<string?>(login, GSTEWayBillQB.GET_EWAY_GSTIN_BASED_ON_OU,
                new { EBNumber = ebNumber },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "E-Way Bill DAL: GetEwayGstinBasedOnOuAsync failed for EBNumber {EBNumber}", ebNumber);
            throw;
        }
    }

    public async Task<string?> GetEwayGstinBasedOnStoreAsync(string ebNumber, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.ExecuteScalarAsync<string?>(login, GSTEWayBillQB.GET_EWAY_GSTIN_BASED_ON_STORE,
                new { EBNumber = ebNumber },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "E-Way Bill DAL: GetEwayGstinBasedOnStoreAsync failed for EBNumber {EBNumber}", ebNumber);
            throw;
        }
    }
}