using AnalyticsDAL.CustomCode.ReportConfig;
using AnalyticsDAL.DTO.ReportConfig;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.Resource.Response;
using GB5Shared.Telemetry;
using Microsoft.Extensions.Logging;

namespace AnalyticsBLL.ReportConfig
{
    public class ReportDataSourceRuleBLL : IReportDataSourceRuleBLL
    {
        private readonly IReportDataSourceRuleDAL           _dal;
        private readonly ILogger<ReportDataSourceRuleBLL>   _logger;

        public ReportDataSourceRuleBLL(
            IReportDataSourceRuleDAL dal,
            ILogger<ReportDataSourceRuleBLL> logger)
        {
            _dal    = dal;
            _logger = logger;
        }

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

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

        public async Task<string> SaveRule(ReportDataSourceRuleDTO dto, LoginDTO login, CancellationToken ct)
        {
            try
            {
                GB5Trace.Step("validate-datasourcerule", new { dto.DataSourceRuleId, dto.ReportId });

                if (dto.ReportId <= 0)
                    throw new ArgumentException("ReportId is required.");
                if (dto.RuleType > 3)
                    throw new ArgumentException("RuleType must be 0–3.");
                if (dto.TargetDataSource > 2)
                    throw new ArgumentException("TargetDataSource must be 0–2.");

                var isNew = dto.DataSourceRuleId == 0;

                GB5Trace.Step("save-datasourcerule", new { dto.DataSourceRuleId, isNew });

                if (isNew)
                {
                    var savedId = await _dal.SaveRule(dto, login, ct).ConfigureAwait(false);
                    return $"{SuccessResponse.SaveSuccessMessage} {savedId}";
                }
                else
                {
                    await _dal.UpdateRule(dto, login, ct).ConfigureAwait(false);
                    return SuccessResponse.UpdateSuccess;
                }
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("save-datasourcerule-failed", ex);
                _logger.LogError(ex, "SaveRule failed for ReportId {Id}", dto.ReportId);
                throw;
            }
        }

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

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