using GB5Shared.DTO.Framework.Login;
using GB5Shared.QueryExecutor;
using GB5Shared.ResponseStandard;
using MMDAL.DTO.Scheduling;
using MMDAL.Query.Scheduling;
using System.Data.Common;
using static GB5Shared.DTO.GOP.GBGatewayDTO;

namespace MMDAL.CustomCode.Scheduling
{
    public class BatchRuleDAL : IBatchRuleDAL
    {
        private readonly IQueryExecutor _QueryExecutor;

        public BatchRuleDAL(IQueryExecutor queryExecutor)
        {
            _QueryExecutor = queryExecutor;
        }

        public async Task<BatchRuleDTO?> GetBatchRule(
            int batchRuleId, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                return await _QueryExecutor.QuerySingleAsync<BatchRuleDTO>(
                    loginDTO, BatchRuleQB.GET_BATCHRULE,
                    new { BatchRuleId = batchRuleId },
                    cancellationToken: ct).ConfigureAwait(false);
            }
            catch (Exception) { throw; }
        }

        public async Task<IEnumerable<BatchRuleDTO>> GetBatchRuleList(
            int workCenterId, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                return await _QueryExecutor.QueryAsync<BatchRuleDTO>(
                    loginDTO, BatchRuleQB.GET_BATCHRULE_LIST,
                    new { WorkCenterId = workCenterId },
                    cancellationToken: ct).ConfigureAwait(false);
            }
            catch (Exception) { throw; }
        }

        public async Task<BatchRuleDTO?> GetBatchRuleForProcess(
            int workCenterId, int processId, LoginDTO loginDTO, CancellationToken ct = default)
        {
            try
            {
                return await _QueryExecutor.QuerySingleAsync<BatchRuleDTO>(
                    loginDTO, BatchRuleQB.GET_BATCHRULE_FOR_PROCESS,
                    new { WorkCenterId = workCenterId, ProcessId = processId, TenantId= loginDTO.ClientId },
                    cancellationToken: ct).ConfigureAwait(false);
            }
            catch (Exception) { throw; }
        }

        public async Task<Result<string>> SaveBatchRule(
            BatchRuleDTO dto, LoginDTO loginDTO, DbTransaction tx)
        {
            try
            {
                dto.CreatedById  = loginDTO.UserId;
                dto.CreatedOn    = DateTime.UtcNow;
                dto.ModifiedById = loginDTO.UserId;
                dto.ModifiedOn   = DateTime.UtcNow;
                dto.TenantId     = loginDTO.ClientId;

                int rows = await _QueryExecutor.ExecuteAsync(
                    loginDTO, BatchRuleQB.SAVE_BATCHRULE, dto, tx).ConfigureAwait(false);

                return rows > 0
                    ? Result<string>.Success("Batch rule saved.")
                    : Result<string>.Failure("Failed to save batch rule.");
            }
            catch (Exception) { throw; }
        }

        public async Task<Result<string>> UpdateBatchRule(
            BatchRuleDTO dto, LoginDTO loginDTO, DbTransaction tx)
        {
            try
            {
                dto.ModifiedById = loginDTO.UserId;
                dto.ModifiedOn   = DateTime.UtcNow;

                int rows = await _QueryExecutor.ExecuteAsync(
                    loginDTO, BatchRuleQB.UPDATE_BATCHRULE, dto, tx).ConfigureAwait(false);

                return rows > 0
                    ? Result<string>.Success("Batch rule updated.")
                    : Result<string>.Failure("Batch rule not found.");
            }
            catch (Exception) { throw; }
        }

        public async Task<Result<string>> DeleteBatchRule(
            int batchRuleId, LoginDTO loginDTO, DbTransaction tx)
        {
            try
            {
                int rows = await _QueryExecutor.ExecuteAsync(
                    loginDTO, BatchRuleQB.DELETE_BATCHRULE,
                    new { BatchRuleId = batchRuleId }, tx).ConfigureAwait(false);

                return rows > 0
                    ? Result<string>.Success("Batch rule deleted.")
                    : Result<string>.Failure("Batch rule not found or already deleted.");
            }
            catch (Exception) { throw; }
        }
    }
}