using GB5Shared.DaprCache;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using GB5Shared.Telemetry;
using MaintenanceDAL.CustomCode.ActivityMaterial;
using MaintenanceDAL.DTO.ActivityMaterial;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using static GB5Shared.GB5Constant.Constant;

namespace MaintenanceBLL.ActivityMaterial
{
    public class ActivityMaterialBLL : IActivityMaterialBLL
    {
        private readonly IActivityMaterialDAL _dal;
        private readonly IQueryExecutor _queryExecutor;
        private readonly AutoNumber _autoNumber;
        private readonly KeyInvalidate _keyInvalidate;
        private readonly ILogger<ActivityMaterialBLL> _logger;

        public ActivityMaterialBLL(
            IActivityMaterialDAL dal,
            IQueryExecutor queryExecutor,
            AutoNumber autoNumber,
            KeyInvalidate keyInvalidate,
            ILogger<ActivityMaterialBLL> logger)
        {
            _dal = dal;
            _queryExecutor = queryExecutor;
            _autoNumber = autoNumber;
            _keyInvalidate = keyInvalidate;
            _logger = logger;
        }

        public async Task<ActivityMaterialDTO?> GetActivityMaterial(int activityMaterialId, LoginDTO login, CancellationToken ct)
            => await _dal.GetActivityMaterial(activityMaterialId, login, ct).ConfigureAwait(false);

        public async Task<IEnumerable<ActivityMaterialDTO>> GetActivityMaterialListByActivity(int activityId, LoginDTO login, CancellationToken ct)
            => await _dal.GetActivityMaterialListByActivity(activityId, login, ct).ConfigureAwait(false);

        public async Task<string> SaveActivityMaterialList(List<ActivityMaterialDTO> activityMaterialDTOs, LoginDTO login, CancellationToken ct)
        {
            if (activityMaterialDTOs == null || activityMaterialDTOs.Count == 0)
                throw new ArgumentException("At least one ActivityMaterial row is required.");

            try
            {
                GB5Trace.Step("validate-activitymaterial", new { Count = activityMaterialDTOs.Count });

                var newRowCount = activityMaterialDTOs.Count(d => d.ActivityMaterialId == 0);
                int nextId = 0;
                if (newRowCount > 0)
                {
                    var auto = await _autoNumber.GetNumberAsync(newRowCount, AUTONUMBERCONSTANT.ACTIVITYMATERIAL, login).ConfigureAwait(false);
                    nextId = auto.StartNumber;
                }

                GB5Trace.Step("save-activitymaterial", new { Count = activityMaterialDTOs.Count, newRowCount });

                await using var tx = await _queryExecutor.BeginTransactionAsync(login).ConfigureAwait(false);
                try
                {
                    foreach (var dto in activityMaterialDTOs)
                    {
                        if (dto.ActivityMaterialId == 0)
                        {
                            dto.ActivityMaterialId = nextId++;
                            await _dal.SaveActivityMaterial(dto, login, tx, ct).ConfigureAwait(false);
                        }
                        else
                        {
                            await _dal.UpdateActivityMaterial(dto, login, tx, ct).ConfigureAwait(false);
                        }
                    }
                    await tx.CommitAsync(ct).ConfigureAwait(false);
                }
                catch
                {
                    await tx.RollbackAsync(ct).ConfigureAwait(false);
                    throw;
                }

                foreach (var dto in activityMaterialDTOs)
                {
                    var cacheKey = new CacheKeyGeneration().KeyGeneration(dto.ActivityMaterialId, EntityConstant.OBJECTACTIVITYMATERIAL, CacheKeyLevel.CLIENT_LEVEL, login);
                    await _keyInvalidate.AllInvalidateCache(cacheKey).ConfigureAwait(false);
                }

                return SuccessResponse.SaveSuccess;
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("save-activitymaterial-failed", ex);
                _logger.LogError(ex, "SaveActivityMaterialList failed");
                throw;
            }
        }

        public async Task<string> DeleteActivityMaterial(int activityMaterialId, LoginDTO login, CancellationToken ct)
        {
            try
            {
                GB5Trace.Step("delete-activitymaterial", new { activityMaterialId });

                await using var tx = await _queryExecutor.BeginTransactionAsync(login).ConfigureAwait(false);
                try
                {
                    await _dal.DeleteActivityMaterial(activityMaterialId, login, tx, ct).ConfigureAwait(false);
                    await tx.CommitAsync(ct).ConfigureAwait(false);
                }
                catch
                {
                    await tx.RollbackAsync(ct).ConfigureAwait(false);
                    throw;
                }

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

                return SuccessResponse.DeleteSuccessMessage;
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("delete-activitymaterial-failed", ex);
                _logger.LogError(ex, "DeleteActivityMaterial failed for ActivityMaterialId {Id}", activityMaterialId);
                throw;
            }
        }
    }
}