using GB5Shared.DTO.Framework.Login;
using GB5Shared.QueryExecutor;
using WiDAL.DTOs;
using WiDAL.Query.Wi;

namespace WiDAL.CustomCode.WiExecution;

public class WiExecutionDAL : IWiExecutionDAL
{
    private readonly IQueryExecutor _qe;
    public WiExecutionDAL(IQueryExecutor qe) => _qe = qe;

    public async Task<int> InsertExecution(WiExecutionDTO dto, LoginDTO login, CancellationToken ct)
    {
        return await _qe.ExecuteAsync(login, WiExecutionQB.INSERT_EXECUTION, new
        {
            WiExecutionId        = dto.WiExecutionId,
            WiId                 = dto.WiId,
            WiActivityScheduleId = dto.WiActivityScheduleId,
            WorkOrderId          = dto.WorkOrderId,
            WorkStationId        = dto.WorkStationId,
            EmployeeId           = dto.EmployeeId,
            ActivityType         = (byte)dto.ActivityType,
            TriggerEvent         = (byte)dto.TriggerEvent,
            SerialNo             = dto.SerialNo,
            LotNo                = dto.LotNo,
            AdvanceModeUsed      = (byte)dto.AdvanceModeUsed,
            StdCycleSecs         = dto.StdCycleSecs,
            Status               = dto.Status,
            CreatedById          = dto.CreatedById,
            ModifiedById         = dto.ModifiedById,
            SourceType           = dto.SourceType,
            TenantId             = login.ClientId
        }, cancellationToken: ct);
    }

    public async Task<int> UpdateExecutionStatus(int wiExecutionId, byte execStatus, int totalActualSecs,
        string? flagReason, int modifiedById, LoginDTO login, CancellationToken ct)
    {
        return await _qe.ExecuteAsync(login, WiExecutionQB.UPDATE_EXECUTION_STATUS, new
        {
            WiExecutionId   = wiExecutionId,
            ExecStatus      = execStatus,
            CompletedOn     = DateTime.UtcNow,
            TotalActualSecs = totalActualSecs,
            FlagReason      = flagReason,
            ModifiedById    = modifiedById
        }, cancellationToken: ct);
    }

    public async Task<int> InsertStepExecution(WiStepExecutionDTO dto, LoginDTO login, CancellationToken ct)
    {
        return await _qe.ExecuteAsync(login, WiExecutionQB.INSERT_STEP_EXECUTION, new
        {
            WiStepExecutionId = dto.WiStepExecutionId,
            WiExecutionId     = dto.WiExecutionId,
            WiStepId          = dto.WiStepId,
            SlNo              = dto.SlNo,
            StdDurationSecs   = dto.StdDurationSecs,
            AdvanceTrigger    = (byte)dto.AdvanceTrigger
        }, cancellationToken: ct);
    }

    public async Task<int> UpdateStepStatus(CompleteStepRequestDTO req, LoginDTO login, CancellationToken ct)
    {
        return await _qe.ExecuteAsync(login, WiExecutionQB.UPDATE_STEP_STATUS, new
        {
            WiStepExecutionId  = req.WiStepExecutionId,
            StepStatus         = (byte)req.StepStatus,
            CompletedOn        = DateTime.UtcNow,
            ActualDurationSecs = req.ActualDurationSecs,
            AdvanceTrigger     = (byte)req.AdvanceTrigger,
            BarcodeScanned     = req.BarcodeScanned,
            SkippedReason      = req.SkippedReason,
            Remarks            = req.Remarks
        }, cancellationToken: ct);
    }

    public async Task<IEnumerable<WiStepDTO>> GetActiveStepsForWi(int wiId, LoginDTO login, CancellationToken ct)
    {
        return await _qe.QueryAsync<WiStepDTO>(login, WiExecutionQB.GET_ACTIVE_STEPS_FOR_WI,
            new { WiId = wiId }, cancellationToken: ct);
    }

    public async Task<IEnumerable<WiStepExecutionDTO>> GetStepExecutionsByExecution(int wiExecutionId, LoginDTO login, CancellationToken ct)
    {
        return await _qe.QueryAsync<WiStepExecutionDTO>(login, WiExecutionQB.GET_STEP_EXECUTIONS_BY_EXECUTION,
            new { WiExecutionId = wiExecutionId }, cancellationToken: ct);
    }

    public async Task<WiAcknowledgementDTO?> CheckAcknowledgement(int wiId, int employeeId, int workOrderId,
        LoginDTO login, CancellationToken ct)
    {
        return await _qe.QuerySingleAsync<WiAcknowledgementDTO>(login, WiExecutionQB.CHECK_ACKNOWLEDGEMENT,
            new { WiId = wiId, EmployeeId = employeeId, WorkOrderId = workOrderId, TenantId = login.ClientId });
    }

    public async Task<int> InvalidateAcksForWi(int wiId, int modifiedById, LoginDTO login, CancellationToken ct)
    {
        return await _qe.ExecuteAsync(login, WiExecutionQB.INVALIDATE_ACK_FOR_WI,
            new { WiId = wiId, ModifiedById = modifiedById, TenantId = login.ClientId }, cancellationToken: ct);
    }

    public async Task<int> InsertAcknowledgement(WiAcknowledgementDTO dto, LoginDTO login, CancellationToken ct)
    {
        return await _qe.ExecuteAsync(login, WiExecutionQB.INSERT_ACKNOWLEDGEMENT, new
        {
            WiAcknowledgementId = dto.AcknowledgementId,
            WiId                = dto.WiId,
            EmployeeId          = dto.EmployeeId,
            WorkOrderId         = dto.WorkOrderId,
            WorkStationId       = dto.WorkStationId,
            WiVersion           = dto.WiVersion,
            DeviceContext       = dto.DeviceContext,
            Status              = dto.Status,
            CreatedById         = dto.CreatedById,
            ModifiedById        = dto.ModifiedById,
            SourceType          = dto.SourceType,
            TenantId            = login.ClientId
        }, cancellationToken: ct);
    }

    public async Task<IEnumerable<WiSkillRequirementDTO>> GetSkillRequirements(int wiId, LoginDTO login, CancellationToken ct)
    {
        return await _qe.QueryAsync<WiSkillRequirementDTO>(login, WiExecutionQB.GET_SKILL_REQS_FOR_WI,
            new { WiId = wiId }, cancellationToken: ct);
    }

    public async Task<IEnumerable<WiCompetencyRequirementDTO>> GetCompetencyRequirements(int wiId, LoginDTO login, CancellationToken ct)
    {
        return await _qe.QueryAsync<WiCompetencyRequirementDTO>(login, WiExecutionQB.GET_COMPETENCY_REQS_FOR_WI,
            new { WiId = wiId }, cancellationToken: ct);
    }

    public async Task<IEnumerable<WiEmployeeSkillLevelDTO>> GetEmployeeSkillLevels(int employeeId, LoginDTO login, CancellationToken ct)
    {
        return await _qe.QueryAsync<WiEmployeeSkillLevelDTO>(login, WiExecutionQB.GET_EMPLOYEE_SKILL_LEVELS,
            new { EmployeeId = employeeId, TenantId = login.ClientId }, cancellationToken: ct);
    }

    public async Task<WiCurrentAssignmentDTO?> GetCurrentAssignmentForEmployee(int employeeId, DateTime rosterDate, LoginDTO login, CancellationToken ct)
    {
        var rows = await _qe.QueryAsync<WiCurrentAssignmentDTO>(login, WiExecutionQB.GET_CURRENT_ASSIGNMENT_FOR_EMPLOYEE,
            new { EmployeeId = employeeId, RosterDate = rosterDate.Date, TenantId = login.ClientId }, cancellationToken: ct);
        return rows.FirstOrDefault();
    }

    public async Task<IEnumerable<WiActiveExecutionDTO>> GetActiveExecutionsForWorkstations(
        IEnumerable<int> workStationIds, LoginDTO login, CancellationToken ct)
    {
        var ids = workStationIds.ToList();
        if (ids.Count == 0) return [];

        return await _qe.QueryAsync<WiActiveExecutionDTO>(login, WiExecutionQB.GET_ACTIVE_EXECUTIONS_FOR_WORKSTATIONS,
            new { WorkStationIds = ids, TenantId = login.ClientId }, cancellationToken: ct);
    }

    public async Task<int?> GetWorkStationIdForExecution(int wiExecutionId, LoginDTO login, CancellationToken ct)
    {
        var rows = await _qe.QueryAsync<int>(login, WiExecutionQB.GET_WORKSTATIONID_FOR_EXECUTION,
            new { WiExecutionId = wiExecutionId, TenantId = login.ClientId }, cancellationToken: ct);
        var list = rows.ToList();
        return list.Count > 0 ? list[0] : null;
    }
}