using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.DTO.Qualifier;
using GB5Shared.QueryExecutor;

namespace GB5Shared.GOP.Qualifier
{
    public class QualifierBulkRunDAL : IQualifierBulkRunDAL
    {
        private readonly IQueryExecutor _qe;

        public QualifierBulkRunDAL(IQueryExecutor qe) => _qe = qe;

        public async Task<int> InsertRunAsync(QualifierBulkRunDTO dto, LoginDTO login, CancellationToken ct = default)
        {
            return await _qe.ExecuteIdentityAsync(login, QualifierBulkRunQB.INSERT_RUN, new
            {
                dto.QualifierId,
                dto.EntityCode,
                dto.Stage,
                dto.Scope,
                dto.TotalRecords,
                TenantId = login.ClientId,
                dto.CreatedById
            }).ConfigureAwait(false);
        }

        public async Task MarkRunningAsync(int qualifierBulkRunId, LoginDTO login, CancellationToken ct = default)
        {
            await _qe.ExecuteAsync(login, QualifierBulkRunQB.MARK_RUNNING,
                new { QualifierBulkRunId = qualifierBulkRunId, TenantId = login.ClientId },
                cancellationToken: ct).ConfigureAwait(false);
        }

        public async Task UpdateProgressAsync(int qualifierBulkRunId, int processedRecords, int errorCount, int warningCount, LoginDTO login, CancellationToken ct = default)
        {
            await _qe.ExecuteAsync(login, QualifierBulkRunQB.UPDATE_PROGRESS, new
            {
                QualifierBulkRunId = qualifierBulkRunId,
                ProcessedRecords = processedRecords,
                ErrorCount = errorCount,
                WarningCount = warningCount,
                TenantId = login.ClientId
            }, cancellationToken: ct).ConfigureAwait(false);
        }

        public async Task CompleteRunAsync(int qualifierBulkRunId, byte runStatus, int processedRecords, int errorCount, int warningCount, string? errorMessage, LoginDTO login, CancellationToken ct = default)
        {
            await _qe.ExecuteAsync(login, QualifierBulkRunQB.COMPLETE_RUN, new
            {
                QualifierBulkRunId = qualifierBulkRunId,
                RunStatus = runStatus,
                ProcessedRecords = processedRecords,
                ErrorCount = errorCount,
                WarningCount = warningCount,
                ErrorMessage = errorMessage,
                TenantId = login.ClientId
            }, cancellationToken: ct).ConfigureAwait(false);
        }

        public async Task<PagedResult<QualifierBulkRunDTO>> GetHistoryAsync(string entityCode, int offset, int pageSize, LoginDTO login, CancellationToken ct = default)
        {
            var param = new { EntityCode = entityCode, TenantId = login.ClientId, Offset = offset, PageSize = pageSize };
            var items = await _qe.QueryAsync<QualifierBulkRunDTO>(
                login, QualifierBulkRunQB.GET_HISTORY_PAGE, param, cancellationToken: ct).ConfigureAwait(false);
            var total = await _qe.ExecuteScalarAsync<int>(
                login, QualifierBulkRunQB.GET_HISTORY_COUNT, param, cancellationToken: ct).ConfigureAwait(false);
            return new PagedResult<QualifierBulkRunDTO> { Items = items.ToList(), TotalCount = total };
        }

        public async Task<QualifierBulkRunDTO?> GetByIdAsync(int qualifierBulkRunId, LoginDTO login, CancellationToken ct = default)
        {
            return await _qe.QuerySingleAsync<QualifierBulkRunDTO>(
                login, QualifierBulkRunQB.GET_BY_ID,
                new { QualifierBulkRunId = qualifierBulkRunId, TenantId = login.ClientId },
                cancellationToken: ct).ConfigureAwait(false);
        }

        public async Task BulkInsertFindingsAsync(IEnumerable<QualifierBulkFindingDTO> findings, LoginDTO login, CancellationToken ct = default)
        {
            var list = findings.ToList();
            if (list.Count == 0) return;
            await _qe.BulkInsertAsync(login, QualifierBulkRunQB.BULK_INSERT_FINDINGS,
                list.Select(f => new
                {
                    QualifierBulkRunId = f.QualifierBulkRunId,
                    QualifierId = f.QualifierId,
                    QualifierCode = f.QualifierCode,
                    RecordKey = f.RecordKey,
                    Severity = f.Severity,
                    FindingCode = f.FindingCode,
                    FindingMessage = f.FindingMessage,
                    DocumentPath = f.DocumentPath,
                    TenantId = login.ClientId
                })).ConfigureAwait(false);
        }

        public async Task<PagedResult<QualifierBulkFindingDTO>> GetFindingsAsync(int qualifierBulkRunId, byte? severity, int offset, int pageSize, LoginDTO login, CancellationToken ct = default)
        {
            var param = new { QualifierBulkRunId = qualifierBulkRunId, Severity = severity, TenantId = login.ClientId, Offset = offset, PageSize = pageSize };
            var items = await _qe.QueryAsync<QualifierBulkFindingDTO>(
                login, QualifierBulkRunQB.GET_FINDINGS_PAGE, param, cancellationToken: ct).ConfigureAwait(false);
            var total = await _qe.ExecuteScalarAsync<int>(
                login, QualifierBulkRunQB.GET_FINDINGS_COUNT, param, cancellationToken: ct).ConfigureAwait(false);
            return new PagedResult<QualifierBulkFindingDTO> { Items = items.ToList(), TotalCount = total };
        }
    }
}