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

namespace ComplianceDAL.CustomCode.GSTOutward;

public class GSTOutwardDAL : IGSTOutwardDAL
{
    private readonly IQueryExecutor _qe;
    private readonly ILogger<GSTOutwardDAL> _logger;

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

    public async Task<GSTOutwardDTO?> GetGSTOutwardAsync(int outwardId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.QuerySingleAsync<GSTOutwardDTO>(login, GSTOutwardQB.GET_GSTOUTWARD,
                new { OutwardId = outwardId, login.ClientId, login.DatabaseName }).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GST Outward DAL: GetGSTOutwardAsync failed for OutwardId {OutwardId}", outwardId);
            throw;
        }
    }

    public async Task<IEnumerable<GSTOutwardDTO>> GetGSTOutwardListAsync(GSTOutwardFilterDTO filter, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.QueryAsync<GSTOutwardDTO>(login, GSTOutwardQB.GET_GSTOUTWARD_LIST,
                new
                {
                    filter.GSTIN,
                    filter.ReturnPeriod,
                    filter.InvoiceType,
                    filter.FilingStatus,
                    filter.Page,
                    filter.PageSize,
                    login.ClientId,
                    login.DatabaseName
                },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GST Outward DAL: GetGSTOutwardListAsync failed for GSTIN {GSTIN}, ReturnPeriod {ReturnPeriod}", filter.GSTIN, filter.ReturnPeriod);
            throw;
        }
    }

    public async Task<int> SaveGSTOutwardAsync(GSTOutwardDTO dto, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.ExecuteIdentityAsync(login, GSTOutwardQB.SAVE_GSTOUTWARD,
                new
                {
                    dto.ArtifactId,
                    dto.GSTIN,
                    dto.ReturnPeriod,
                    dto.SourceDocumentId,
                    dto.InvoiceNumber,
                    dto.InvoiceDate,
                    dto.InvoiceValue,
                    dto.ReceiverGSTIN,
                    dto.ReceiverName,
                    dto.POS,
                    dto.SupplyType,
                    dto.InvoiceType,
                    dto.HSNCode,
                    dto.UOM,
                    dto.Quantity,
                    dto.TaxableValue,
                    dto.IGSTRate,
                    dto.IGSTAmount,
                    dto.CGSTRate,
                    dto.CGSTAmount,
                    dto.SGSTRate,
                    dto.SGSTAmount,
                    dto.CessRate,
                    dto.CessAmount,
                    dto.OriginalOutwardId,
                    dto.ClientId,
                    dto.DatabaseName,
                    dto.CreatedById
                }).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GST Outward DAL: SaveGSTOutwardAsync failed for GSTIN {GSTIN}, SourceDocumentId {SourceDocumentId}", dto.GSTIN, dto.SourceDocumentId);
            throw;
        }
    }

    public async Task<int> UpsertGSTOutwardAsync(GSTOutwardDTO dto, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.ExecuteIdentityAsync(login, GSTOutwardQB.UPSERT_GSTOUTWARD,
                new
                {
                    dto.ArtifactId,
                    dto.GSTIN,
                    dto.ReturnPeriod,
                    dto.SourceDocumentId,
                    dto.InvoiceNumber,
                    dto.InvoiceDate,
                    dto.InvoiceValue,
                    dto.ReceiverGSTIN,
                    dto.ReceiverName,
                    dto.POS,
                    dto.SupplyType,
                    dto.InvoiceType,
                    dto.HSNCode,
                    dto.UOM,
                    dto.Quantity,
                    dto.TaxableValue,
                    dto.IGSTRate,
                    dto.IGSTAmount,
                    dto.CGSTRate,
                    dto.CGSTAmount,
                    dto.SGSTRate,
                    dto.SGSTAmount,
                    dto.CessRate,
                    dto.CessAmount,
                    dto.OriginalOutwardId,
                    dto.ClientId,
                    dto.DatabaseName,
                    dto.CreatedById
                }).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GST Outward DAL: UpsertGSTOutwardAsync failed for GSTIN {GSTIN}, SourceDocumentId {SourceDocumentId}", dto.GSTIN, dto.SourceDocumentId);
            throw;
        }
    }

    public async Task<int> UpdateFilingStatusAsync(string gstin, string returnPeriod, int filingStatus, string ackReferenceNumber, int modifiedById, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.ExecuteAsync(login, GSTOutwardQB.UPDATE_FILING_STATUS,
                new { GSTIN = gstin, ReturnPeriod = returnPeriod, FilingStatus = filingStatus, AckReferenceNumber = ackReferenceNumber, ModifiedById = modifiedById, login.ClientId, login.DatabaseName },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GST Outward DAL: UpdateFilingStatusAsync failed for GSTIN {GSTIN}, ReturnPeriod {ReturnPeriod}", gstin, returnPeriod);
            throw;
        }
    }

    public async Task<int> DeleteOutwardByPeriodAsync(string gstin, string returnPeriod, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.ExecuteAsync(login, GSTOutwardQB.DELETE_OUTWARD_BY_PERIOD,
                new { GSTIN = gstin, ReturnPeriod = returnPeriod, login.ClientId, login.DatabaseName },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GST Outward DAL: DeleteOutwardByPeriodAsync failed for GSTIN {GSTIN}, ReturnPeriod {ReturnPeriod}", gstin, returnPeriod);
            throw;
        }
    }

    public async Task<IEnumerable<GSTOutwardDTO>> GetB2BInvoicesAsync(string gstin, string returnPeriod, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.QueryAsync<GSTOutwardDTO>(login, GSTOutwardQB.GET_GSTR1_B2B_INVOICES,
                new { GSTIN = gstin, ReturnPeriod = returnPeriod, login.ClientId, login.DatabaseName },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GST Outward DAL: GetB2BInvoicesAsync failed for GSTIN {GSTIN}, ReturnPeriod {ReturnPeriod}", gstin, returnPeriod);
            throw;
        }
    }

    public async Task<IEnumerable<GSTOutwardDTO>> GetB2CLInvoicesAsync(string gstin, string returnPeriod, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.QueryAsync<GSTOutwardDTO>(login, GSTOutwardQB.GET_GSTR1_B2CL_INVOICES,
                new { GSTIN = gstin, ReturnPeriod = returnPeriod, login.ClientId, login.DatabaseName },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GST Outward DAL: GetB2CLInvoicesAsync failed for GSTIN {GSTIN}, ReturnPeriod {ReturnPeriod}", gstin, returnPeriod);
            throw;
        }
    }

    public async Task<IEnumerable<GSTR1B2CSDTO>> GetB2CSAggregateAsync(string gstin, string returnPeriod, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.QueryAsync<GSTR1B2CSDTO>(login, GSTOutwardQB.GET_GSTR1_B2CS_AGGREGATE,
                new { GSTIN = gstin, ReturnPeriod = returnPeriod, login.ClientId, login.DatabaseName },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GST Outward DAL: GetB2CSAggregateAsync failed for GSTIN {GSTIN}, ReturnPeriod {ReturnPeriod}", gstin, returnPeriod);
            throw;
        }
    }

    public async Task<IEnumerable<GSTOutwardDTO>> GetEXPInvoicesAsync(string gstin, string returnPeriod, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.QueryAsync<GSTOutwardDTO>(login, GSTOutwardQB.GET_GSTR1_EXP_INVOICES,
                new { GSTIN = gstin, ReturnPeriod = returnPeriod, login.ClientId, login.DatabaseName },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GST Outward DAL: GetEXPInvoicesAsync failed for GSTIN {GSTIN}, ReturnPeriod {ReturnPeriod}", gstin, returnPeriod);
            throw;
        }
    }

    public async Task<IEnumerable<GSTOutwardDTO>> GetCDNRNotesAsync(string gstin, string returnPeriod, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.QueryAsync<GSTOutwardDTO>(login, GSTOutwardQB.GET_GSTR1_CDNR_NOTES,
                new { GSTIN = gstin, ReturnPeriod = returnPeriod, login.ClientId, login.DatabaseName },
                cancellationToken: ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GST Outward DAL: GetCDNRNotesAsync failed for GSTIN {GSTIN}, ReturnPeriod {ReturnPeriod}", gstin, returnPeriod);
            throw;
        }
    }

    public async Task<GSTR1NilDTO> GetNilSummaryAsync(string gstin, string returnPeriod, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.QuerySingleAsync<GSTR1NilDTO>(login, GSTOutwardQB.GET_GSTR1_NIL_SUMMARY,
                new { GSTIN = gstin, ReturnPeriod = returnPeriod, login.ClientId, login.DatabaseName }).ConfigureAwait(false)
                   ?? new GSTR1NilDTO();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GST Outward DAL: GetNilSummaryAsync failed for GSTIN {GSTIN}, ReturnPeriod {ReturnPeriod}", gstin, returnPeriod);
            throw;
        }
    }

    public async Task<GSTR1SummaryDTO> GetOutwardSummaryAsync(string gstin, string returnPeriod, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _qe.QuerySingleAsync<GSTR1SummaryDTO>(login, GSTOutwardQB.GET_OUTWARD_SUMMARY,
                new { GSTIN = gstin, ReturnPeriod = returnPeriod, login.ClientId, login.DatabaseName }).ConfigureAwait(false)
                   ?? new GSTR1SummaryDTO();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GST Outward DAL: GetOutwardSummaryAsync failed for GSTIN {GSTIN}, ReturnPeriod {ReturnPeriod}", gstin, returnPeriod);
            throw;
        }
    }
}