using FLSDAL.CustomCode.Instance;
using FLSDAL.DTO.Instance;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.Resource.Response;
using GB5Shared.Telemetry;
using Microsoft.Extensions.Logging;

namespace FLSBLL.Instance;

public class FlsStepSequenceBLL : IFlsStepSequenceBLL
{
    private readonly IFlsStepSequenceDAL _dal;
    private readonly AutoNumber          _autoNumber;
    private readonly ILogger<FlsStepSequenceBLL> _logger;

    public FlsStepSequenceBLL(IFlsStepSequenceDAL dal, AutoNumber autoNumber, ILogger<FlsStepSequenceBLL> logger)
    {
        _dal        = dal;
        _autoNumber = autoNumber;
        _logger     = logger;
    }

    public async Task<string> SaveStepSequenceAsync(SaveFlsStepSequenceRequest req, LoginDTO login, CancellationToken ct)
    {
        try
        {
            // PK convention: StepSequenceId == 0 → insert (new AutoNumber); non-zero → update existing row.
            if (req.StepSequenceId == 0)
            {
                GB5Trace.Step("save-step-sequence", new { req.FlsInstanceId, req.GroupId, req.StepNo });
                var autoNum = await _autoNumber.GetNumberAsync(1, "FLSSTEPSEQUENCE", login).ConfigureAwait(false);
                int stepSequenceId = autoNum.StartNumber;

                await _dal.InsertStepSequenceAsync(stepSequenceId, req, login, ct).ConfigureAwait(false);
                return $"{SuccessResponse.SaveSuccessMessage} {stepSequenceId}";
            }
            else
            {
                GB5Trace.Step("update-step-sequence", new { req.StepSequenceId });
                bool updated = await _dal.UpdateStepSequenceAsync(req, login, ct).ConfigureAwait(false);
                if (!updated)
                    return $"Step sequence {req.StepSequenceId} not found.";

                return $"{SuccessResponse.UpdateSuccess} {req.StepSequenceId}";
            }
        }
        catch (Exception ex)
        {
            GB5Trace.MarkFailed("save-step-sequence-failed", ex);
            _logger.LogError(ex, "SaveStepSequence failed for id {Id}", req.StepSequenceId);
            throw;
        }
    }

    public async Task<string> DeleteStepSequenceAsync(int stepSequenceId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            GB5Trace.Step("delete-step-sequence", new { stepSequenceId });
            bool deleted = await _dal.DeleteStepSequenceAsync(stepSequenceId, login, ct).ConfigureAwait(false);
            return deleted ? SuccessResponse.DeleteSuccessMessage : $"Step sequence {stepSequenceId} not found.";
        }
        catch (Exception ex)
        {
            GB5Trace.MarkFailed("delete-step-sequence-failed", ex);
            _logger.LogError(ex, "DeleteStepSequence failed for id {Id}", stepSequenceId);
            throw;
        }
    }

    public async Task<FlsStepSequenceRow?> GetStepSequenceAsync(int stepSequenceId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _dal.GetStepSequenceByIdAsync(stepSequenceId, login, ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            GB5Trace.MarkFailed("get-step-sequence-failed", ex);
            _logger.LogError(ex, "GetStepSequence failed for id {Id}", stepSequenceId);
            throw;
        }
    }

    // Pass flsInstanceId>0 to filter by instance, or groupId>0 to filter by group (group takes precedence).
    public async Task<IEnumerable<FlsStepSequenceRow>> GetStepSequenceListAsync(
        int flsInstanceId, int groupId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            if (groupId > 0)
                return await _dal.GetStepSequencesByGroupAsync(groupId, login, ct).ConfigureAwait(false);

            return await _dal.GetStepSequencesByInstanceAsync(flsInstanceId, login, ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            GB5Trace.MarkFailed("get-step-sequence-list-failed", ex);
            _logger.LogError(ex, "GetStepSequenceList failed for instance {InstId} group {GroupId}", flsInstanceId, groupId);
            throw;
        }
    }

    public async Task<IEnumerable<FlsStepSequencePicklistDTO>> GetSelectListFlsStepSequence(
        int firstNumber, int maxResult, CriteriaDTO criteriaDTO, LoginDTO login)
    {
        try
        {
            if (firstNumber <= 0 && maxResult <= 0)
            {
                firstNumber = -1;
                maxResult   = -1;
            }

            return await _dal.GetSelectListFlsStepSequence(firstNumber, maxResult, criteriaDTO, login).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            GB5Trace.MarkFailed("get-selectlist-stepsequence-failed", ex);
            _logger.LogError(ex, "GetSelectListFlsStepSequence failed");
            throw;
        }
    }
}