using FrameworkBLL.EIPConversation.EIPHandlers.EIPFlowRepository;
using FrameworkDAL.CustomCode.EIPConversation.EIPRouting;
using FrameworkDAL.DTO.EIPConversation;
using GB5Shared.DTO.Framework.Login;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace FrameworkBLL.EIPConversation.EIPHandlers.EIPConversationEngine.EIPRoutingRepository
{
    public class EIPRoutingRepository : IEIPRoutingRepository
    {
        private readonly IEIPRoutingDAL _routingDAL;
        private readonly ITenantContext _tenantContext;
        private readonly ILogger<EIPRoutingRepository> _logger;

        public EIPRoutingRepository(
            IEIPRoutingDAL routingDAL,
            ITenantContext tenantContext,
            ILogger<EIPRoutingRepository> logger)
        {
            _routingDAL = routingDAL ?? throw new ArgumentNullException(nameof(routingDAL));
            _tenantContext = tenantContext ?? throw new ArgumentNullException(nameof(tenantContext));
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        }

        // =========================================================
        // Validate Tenant
        // =========================================================
        public async Task<bool> ValidateTenantAsync(
            int? tenantId,
            LoginDTO loginDTO,
            CancellationToken cancellationToken)
        {
            if (tenantId is null)
                return false;

            cancellationToken.ThrowIfCancellationRequested();

            try
            {
                _logger.LogInformation(
                    "REPO | ValidateTenant | TenantId={TenantId}",
                    tenantId);

                return await _routingDAL.ValidateTenantAsync(
                    tenantId,
                    loginDTO,
                    cancellationToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "REPO | ValidateTenant | Error | TenantId={TenantId}",
                    tenantId);
                throw;
            }
        }

        // =========================================================
        // Get Active Routing Rules
        // =========================================================
        public async Task<List<EIPRoutingRuleDTO>> GetActiveRoutingRulesAsync(
            int? tenantId,
            string channelType,
            LoginDTO loginDTO,
            CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            var normalizedChannel = channelType.Trim().ToUpperInvariant();

            try
            {
                _logger.LogInformation(
                    "REPO | GetRoutingRules | Tenant={Tenant} | Channel={Channel}",
                    tenantId,
                    normalizedChannel);

                if (!Enum.TryParse<EIPChannelType>(normalizedChannel, true, out var channelTypeEnum))
                {
                    throw new ArgumentException($"Invalid channel type: {normalizedChannel}");
                }

                return await _routingDAL.GetActiveRoutingRulesAsync(
                    tenantId,
                    channelTypeEnum,
                    loginDTO,
                    cancellationToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "REPO | GetRoutingRules | Error | Tenant={Tenant}",
                    tenantId);
                throw;
            }
        }
    }
}