using AnalyticsDAL.CustomCode.KPIManual;
using AnalyticsDAL.DTO.KPIManual;
using GB5Shared.DaprCache;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.Resource.Response;
using GB5Shared.Telemetry;
using Microsoft.Extensions.Logging;
using static GB5Shared.GB5Constant.Constant;

namespace AnalyticsBLL.KPIManual
{
    public class KPIManualBLL : IKPIManualBLL
    {
        private readonly IKPIManualDAL         _dal;
        private readonly KeyInvalidate         _keyInvalidate;
        private readonly ILogger<KPIManualBLL> _logger;

        public KPIManualBLL(
            IKPIManualDAL dal,
            KeyInvalidate keyInvalidate,
            ILogger<KPIManualBLL> logger)
        {
            _dal           = dal;
            _keyInvalidate = keyInvalidate;
            _logger        = logger;
        }

        public async Task<string> GetKPIManual(int kpiManualId, LoginDTO login, CancellationToken ct)
            => await _dal.GetKPIManual(kpiManualId, login, ct).ConfigureAwait(false);

        public async Task<string> GetListKPIManual(int kpiId, int scenarioId, int periodDetailId, LoginDTO login, CancellationToken ct)
            => await _dal.GetListKPIManual(kpiId, scenarioId, periodDetailId, login, ct).ConfigureAwait(false);

        public async Task<string> SaveKPIManual(KPIManualDTO dto, LoginDTO login, CancellationToken ct)
        {
            try
            {
                GB5Trace.Step("validate-kpimanual", new { dto.KPIManualId });

                if (dto.KPIId <= 0)
                    throw new ArgumentException("KPIId is required.");
                if (dto.KPIManualScenarioId <= 0)
                    throw new ArgumentException("ScenarioId is required.");
                if (dto.GBPeriodDetailId <= 0)
                    throw new ArgumentException("PeriodDetailId is required.");

                if (await _dal.IsDuplicate(dto, login, ct).ConfigureAwait(false))
                    throw new InvalidOperationException(
                        "A manual entry for this KPI / Scenario / Period / Member combination already exists.");

                var isNew = dto.KPIManualId == 0;
                GB5Trace.Step("save-kpimanual", new { dto.KPIManualId, isNew });

                int savedId;
                if (isNew)
                    savedId = await _dal.SaveKPIManual(dto, login, ct).ConfigureAwait(false);
                else
                {
                    savedId = dto.KPIManualId;
                    await _dal.UpdateKPIManual(dto, login, ct).ConfigureAwait(false);
                }

                var cacheKey = new CacheKeyGeneration().KeyGeneration(
                    savedId, EntityConstant.OBJECTANALYSIS, CacheKeyLevel.NOT_REQUIRED, login);
                await _keyInvalidate.AllInvalidateCache(cacheKey).ConfigureAwait(false);

                return isNew
                    ? $"{SuccessResponse.SaveSuccessMessage} {savedId}"
                    : SuccessResponse.UpdateSuccess;
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("save-kpimanual-failed", ex);
                _logger.LogError(ex, "SaveKPIManual failed for KPIId {KPIId}", dto.KPIId);
                throw;
            }
        }

        public async Task<string> DeleteKPIManual(int kpiManualId, LoginDTO login, CancellationToken ct)
        {
            try
            {
                GB5Trace.Step("delete-kpimanual", new { kpiManualId });
                await _dal.DeleteKPIManual(kpiManualId, login, ct).ConfigureAwait(false);
                return SuccessResponse.DeleteSuccessMessage;
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("delete-kpimanual-failed", ex);
                _logger.LogError(ex, "DeleteKPIManual failed for KPIManualId {KPIManualId}", kpiManualId);
                throw;
            }
        }
    }
}