using AnalyticsDAL.CustomCode.AnalysisMasterFields;
using AnalyticsDAL.DTO.AnalysisMasterFields;
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.AnalysisMasterFields
{
    public class AnalysisMasterFieldsBLL : IAnalysisMasterFieldsBLL
    {
        private readonly IAnalysisMasterFieldsDAL  _dal;
        private readonly KeyInvalidate             _keyInvalidate;
        private readonly ILogger<AnalysisMasterFieldsBLL> _logger;

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

        public async Task<string> GetAnalysisMasterFields(int masterFieldsId, LoginDTO login, CancellationToken ct)
        {
            try
            {
                return await _dal.GetAnalysisMasterFields(masterFieldsId, login, ct).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("get-analysis-master-fields-failed", ex);
                _logger.LogError(ex, "GetAnalysisMasterFields failed for MasterFieldsId {Id}", masterFieldsId);
                throw;
            }
        }

        public async Task<string> GetMasterFieldsByAnalysis(int analysisId, LoginDTO login, CancellationToken ct)
        {
            try
            {
                return await _dal.GetMasterFieldsByAnalysis(analysisId, login, ct).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("get-master-fields-by-analysis-failed", ex);
                _logger.LogError(ex, "GetMasterFieldsByAnalysis failed for AnalysisId {Id}", analysisId);
                throw;
            }
        }

        public async Task<string> GetSelectListMasterFieldsByAnalysis(int analysisId, LoginDTO login, CancellationToken ct)
        {
            try
            {
                return await _dal.GetSelectListMasterFieldsByAnalysis(analysisId, login, ct).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("get-selectlist-master-fields-failed", ex);
                _logger.LogError(ex, "GetSelectListMasterFieldsByAnalysis failed for AnalysisId {Id}", analysisId);
                throw;
            }
        }

        public async Task<string> SaveAnalysisMasterFields(AnalysisMasterFieldsDTO dto, LoginDTO login, CancellationToken ct)
        {
            try
            {
                GB5Trace.Step("validate-analysis-master-fields", new { dto.MasterFieldsId, dto.AnalysisId });

                if (string.IsNullOrWhiteSpace(dto.FieldName))
                    throw new ArgumentException("Field Name is required.");
                if (dto.FieldName.Length > 100)
                    throw new ArgumentException("Field Name must not exceed 100 characters.");
                if (string.IsNullOrWhiteSpace(dto.DisplayName))
                    throw new ArgumentException("Display Name is required.");
                if (string.IsNullOrWhiteSpace(dto.DbFieldName))
                    throw new ArgumentException("DB Field Name is required.");
                if (string.IsNullOrWhiteSpace(dto.FilterCondition))
                    throw new ArgumentException("Filter Condition is required.");
                if (dto.AnalysisId <= 0)
                    throw new ArgumentException("Analysis is required.");

                var isDuplicate = await _dal.IsDuplicateFieldName(
                    dto.AnalysisId, dto.FieldName, dto.MasterFieldsId, login, ct).ConfigureAwait(false);
                if (isDuplicate)
                    throw new ArgumentException($"Field Name '{dto.FieldName}' already exists for this Analysis.");

                var isNew = dto.MasterFieldsId == 0;

                GB5Trace.Step("save-analysis-master-fields", new { dto.MasterFieldsId, isNew });

                int savedId;
                if (isNew)
                {
                    savedId = await _dal.SaveAnalysisMasterFields(dto, login, ct).ConfigureAwait(false);
                }
                else
                {
                    savedId = dto.MasterFieldsId;
                    await _dal.UpdateAnalysisMasterFields(dto, login, ct).ConfigureAwait(false);
                }

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

                return isNew
                    ? $"{SuccessResponse.SaveSuccessMessage} {savedId}"
                    : SuccessResponse.UpdateSuccess;
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("save-analysis-master-fields-failed", ex);
                _logger.LogError(ex, "SaveAnalysisMasterFields failed for AnalysisId {Id}", dto.AnalysisId);
                throw;
            }
        }

        public async Task<string> DeleteAnalysisMasterFields(int masterFieldsId, LoginDTO login, CancellationToken ct)
        {
            try
            {
                GB5Trace.Step("delete-analysis-master-fields", new { masterFieldsId });

                await _dal.DeleteAnalysisMasterFields(masterFieldsId, login, ct).ConfigureAwait(false);

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

                return SuccessResponse.DeleteSuccessMessage;
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("delete-analysis-master-fields-failed", ex);
                _logger.LogError(ex, "DeleteAnalysisMasterFields failed for MasterFieldsId {Id}", masterFieldsId);
                throw;
            }
        }
    }
}