using FrameworkDAL.CustomCode.EIPConversation.EIPCapabilityActionMapAdmin;
using FrameworkDAL.DTO.EIPConversation;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.Resource.Response;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace FrameworkBLL.EIPConversation.EIPAdmin.EIPCapabilityActionMapAdmin
{
    public class EIPCapabilityActionMapAdminBLL : IEIPCapabilityActionMapAdminBLL
    {
        private readonly IEIPCapabilityActionMapAdminDAL _dal;
        private readonly ILogger<EIPCapabilityActionMapAdminBLL> _logger;

        public EIPCapabilityActionMapAdminBLL(IEIPCapabilityActionMapAdminDAL dal, ILogger<EIPCapabilityActionMapAdminBLL> logger)
        {
            _dal    = dal    ?? throw new ArgumentNullException(nameof(dal));
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        }

        public async Task<IEnumerable<EIPCapabilityActionMapAdminDTO>> GetMapListAsync(
            int capabilityId, LoginDTO login, CancellationToken ct = default)
        {
            try
            {
                _logger.LogInformation("BLL | GetMapList | Tenant={TenantId} | CapabilityId={Id}", login.ClientId, capabilityId);
                return await _dal.GetMapListAsync(capabilityId, login, ct).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "BLL | GetMapList | Error | CapabilityId={Id}", capabilityId);
                throw;
            }
        }

        public async Task<EIPCapabilityActionMapAdminDTO?> GetMapAsync(
            int capabilityActionMapId, LoginDTO login, CancellationToken ct = default)
        {
            try
            {
                _logger.LogInformation("BLL | GetMap | Tenant={TenantId} | Id={Id}", login.ClientId, capabilityActionMapId);
                return await _dal.GetMapAsync(capabilityActionMapId, login, ct).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "BLL | GetMap | Error | Id={Id}", capabilityActionMapId);
                throw;
            }
        }

        public async Task<string> SaveMapAsync(
            EIPCapabilityActionMapAdminDTO dto, LoginDTO login, CancellationToken ct = default)
        {
            try
            {
                _logger.LogInformation(
                    "BLL | SaveMap | Validate | CapabilityId={CapId} | ActionId={ActId}",
                    dto.CapabilityId, dto.ActionId);

                if (dto.CapabilityId == 0)
                    throw new ArgumentException("CapabilityId must reference a valid capability.");
                if (dto.ActionId == 0)
                    throw new ArgumentException("ActionId must reference a valid action.");
                if (dto.IsEnabled != 0 && dto.IsEnabled != 1)
                    throw new ArgumentException("IsEnabled must be 0 or 1.");

                if (!await _dal.CapabilityIdExistsAsync(dto.CapabilityId, login, ct).ConfigureAwait(false))
                    throw new ArgumentException($"CapabilityId {dto.CapabilityId} does not exist.");
                if (!await _dal.ActionIdExistsAsync(dto.ActionId, login, ct).ConfigureAwait(false))
                    throw new ArgumentException($"ActionId {dto.ActionId} does not exist.");

                bool combinationExists = await _dal.CapabilityActionExistsAsync(
                    dto.CapabilityId, dto.ActionId, dto.CapabilityActionMapId, login, ct).ConfigureAwait(false);

                if (combinationExists)
                    throw new InvalidOperationException(
                        $"Action {dto.ActionId} is already wired to Capability {dto.CapabilityId}.");

                var isNew = dto.CapabilityActionMapId == 0;

                _logger.LogInformation(
                    "BLL | SaveMap | Persist | CapabilityId={CapId} | ActionId={ActId} | IsNew={IsNew}",
                    dto.CapabilityId, dto.ActionId, isNew);

                if (isNew)
                {
                    var newId = await _dal.InsertMapAsync(dto, login, ct).ConfigureAwait(false);
                    _logger.LogInformation("BLL | SaveMap | Inserted | NewId={NewId}", newId);
                    return $"{SuccessResponse.SaveSuccessMessage} {newId}";
                }
                else
                {
                    await _dal.UpdateMapAsync(dto, login, ct).ConfigureAwait(false);
                    _logger.LogInformation("BLL | SaveMap | Updated | Id={Id}", dto.CapabilityActionMapId);
                    return SuccessResponse.UpdateSuccess;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "BLL | SaveMap | Error | CapabilityId={CapId} | ActionId={ActId}",
                    dto.CapabilityId, dto.ActionId);
                throw;
            }
        }

        public async Task<string> DeleteMapAsync(
            int capabilityActionMapId, LoginDTO login, CancellationToken ct = default)
        {
            try
            {
                _logger.LogInformation("BLL | DeleteMap | Id={Id}", capabilityActionMapId);

                if (capabilityActionMapId == 0)
                    throw new ArgumentException("CapabilityActionMapId must reference a valid record.");

                await _dal.DeleteMapAsync(capabilityActionMapId, login, ct).ConfigureAwait(false);

                _logger.LogInformation("BLL | DeleteMap | Completed | Id={Id}", capabilityActionMapId);
                return SuccessResponse.DeleteSuccessMessage;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "BLL | DeleteMap | Error | Id={Id}", capabilityActionMapId);
                throw;
            }
        }
    }
}