using FrameworkDAL.CustomCode.EIPConversation.EIPMessageTemplateAdmin;
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.EIPMessageTemplateAdmin
{
    public class EIPMessageTemplateAdminBLL : IEIPMessageTemplateAdminBLL
    {
        private readonly IEIPMessageTemplateAdminDAL _dal;
        private readonly ILogger<EIPMessageTemplateAdminBLL> _logger;

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

        public async Task<IEnumerable<EIPMessageTemplateAdminDTO>> GetTemplateListAsync(
            string? search,
            LoginDTO login,
            CancellationToken ct = default)
        {
            try
            {
                _logger.LogInformation(
                    "BLL | GetTemplateList | Tenant={TenantId} | Search={Search}",
                    login.ClientId, search);

                return await _dal.GetTemplateListAsync(search, login, ct).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "BLL | GetTemplateList | Error | Tenant={TenantId}", login.ClientId);
                throw;
            }
        }

        public async Task<EIPMessageTemplateAdminDTO?> GetTemplateAsync(
            int messageId,
            LoginDTO login,
            CancellationToken ct = default)
        {
            try
            {
                _logger.LogInformation(
                    "BLL | GetTemplate | Tenant={TenantId} | MessageId={MessageId}",
                    login.ClientId, messageId);

                return await _dal.GetTemplateAsync(messageId, login, ct).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "BLL | GetTemplate | Error | MessageId={MessageId}", messageId);
                throw;
            }
        }

        public async Task<string> SaveTemplateAsync(
            EIPMessageTemplateAdminDTO dto,
            LoginDTO login,
            CancellationToken ct = default)
        {
            try
            {
                _logger.LogInformation(
                    "BLL | SaveTemplate | Validate | Tenant={TenantId} | MessageKey={MessageKey}",
                    login.ClientId, dto.MessageKey);

                if (string.IsNullOrWhiteSpace(dto.MessageKey))
                    throw new ArgumentException("MessageKey is required.");

                if (string.IsNullOrWhiteSpace(dto.LanguageCode))
                    throw new ArgumentException("LanguageCode is required.");

                if (string.IsNullOrWhiteSpace(dto.TemplateContent))
                    throw new ArgumentException("TemplateContent is required.");

                if (dto.ChannelType > 8)
                    throw new ArgumentException("ChannelType must be one of the known EIP channel values (0-8).");

                dto.TenantId = login.ClientId;

                // Matches UK_MEIPMESSAGETEMPLATE_KEY_LANG_CHANNEL (TenantId, MessageKey, LanguageCode, ChannelType, TemplateVersion).
                bool keyExists = await _dal.TemplateKeyExistsAsync(dto, login, ct).ConfigureAwait(false);

                if (keyExists)
                    throw new InvalidOperationException(
                        $"A template already exists for MessageKey '{dto.MessageKey}', Language '{dto.LanguageCode}', ChannelType {dto.ChannelType}, Version {dto.TemplateVersion}.");

                var isNew = dto.MessageId == 0;

                _logger.LogInformation(
                    "BLL | SaveTemplate | Persist | Tenant={TenantId} | MessageKey={MessageKey} | IsNew={IsNew}",
                    login.ClientId, dto.MessageKey, isNew);

                if (isNew)
                {
                    var newId = await _dal.InsertTemplateAsync(dto, login, ct).ConfigureAwait(false);
                    _logger.LogInformation("BLL | SaveTemplate | Inserted | NewId={NewId}", newId);
                    return $"{SuccessResponse.SaveSuccessMessage} {newId}";
                }
                else
                {
                    await _dal.UpdateTemplateAsync(dto, login, ct).ConfigureAwait(false);
                    _logger.LogInformation(
                        "BLL | SaveTemplate | Updated | MessageId={Id}", dto.MessageId);
                    return SuccessResponse.UpdateSuccess;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "BLL | SaveTemplate | Error | Tenant={TenantId} | MessageKey={MessageKey}",
                    login.ClientId, dto.MessageKey);
                throw;
            }
        }

        public async Task<string> DeleteTemplateAsync(
            int messageId,
            LoginDTO login,
            CancellationToken ct = default)
        {
            try
            {
                _logger.LogInformation(
                    "BLL | DeleteTemplate | Tenant={TenantId} | MessageId={MessageId}",
                    login.ClientId, messageId);

                if (messageId == 0)
                    throw new ArgumentException("MessageId must be a positive integer.");

                await _dal.DeleteTemplateAsync(messageId, login, ct).ConfigureAwait(false);

                _logger.LogInformation(
                    "BLL | DeleteTemplate | Completed | MessageId={MessageId}", messageId);

                return SuccessResponse.DeleteSuccessMessage;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "BLL | DeleteTemplate | Error | MessageId={MessageId}", messageId);
                throw;
            }
        }
    }
}