using GB5Shared.DaprCache;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.EntityHandler;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.Resource.Response;
using GB5Shared.Telemetry;
using Microsoft.Extensions.Logging;
using MMDAL.CustomCode.Production;
using MMDAL.DTO.Production;
using Newtonsoft.Json;
using static GB5Shared.GB5Constant.Constant;

namespace MMBLL.Production
{
    public class ResourcePunchBLL : IResourcePunchBLL
    {
        private readonly IResourcePunchDAL                              _dal;
        private readonly AutoNumber                                     _autoNumber;
        private readonly BaseEntityAppService<ResourcePunchSaveDTO>     _entityApp;
        private readonly ILogger<ResourcePunchBLL>                      _logger;

        public ResourcePunchBLL(
            IResourcePunchDAL dal,
            AutoNumber autoNumber,
            BaseEntityAppService<ResourcePunchSaveDTO> entityApp,
            ILogger<ResourcePunchBLL> logger)
        {
            _dal        = dal;
            _autoNumber = autoNumber;
            _entityApp  = entityApp;
            _logger     = logger;
        }

        public async Task<string> GetActivePunchesForEmployee(int employeeId, LoginDTO login, CancellationToken ct)
        {
            var punches = await _dal.GetActivePunchesForEmployee(employeeId, login, ct).ConfigureAwait(false);
            return JsonConvert.SerializeObject(punches);
        }

        public async Task<string> GetResourcePunchesByWO(int indentDetailId, LoginDTO login, CancellationToken ct)
        {
            var punches = await _dal.GetResourcePunchesByWO(indentDetailId, login, ct).ConfigureAwait(false);
            return JsonConvert.SerializeObject(punches);
        }

        public async Task<string> SaveResourcePunch(ResourcePunchSaveDTO dto, LoginDTO login, CancellationToken ct)
        {
            try
            {
                GB5Trace.Step("validate-resource-punch", new { dto.EmployeeId, dto.PunchStatus });

                if (dto.PunchStatus == 0)
                {
                    var active = await _dal.GetActivePunchesForEmployee(dto.EmployeeId, login, ct).ConfigureAwait(false);
                    if (active.Any())
                        throw new InvalidOperationException("Employee already has an active punch-in. Punch out first.");
                }

                bool isNew = dto.ResourcePunchId == 0;

                dto.TenantId = login.ClientId;

                GB5Trace.Step("save-resource-punch", new { dto.ResourcePunchId, isNew });

                await _entityApp.ExecuteSaveAsync(
                    EntityConstant.OBJECTRESOURCEPUNCH,
                    EventTypeConstant.SAVERESOURCEPUNCHEVENTTYPEID,
                    dto,
                    login,
                    async tx =>
                    {
                        await _dal.SaveResourcePunch(dto, login, tx, ct).ConfigureAwait(false);
                        return dto.ResourcePunchId;
                    }).ConfigureAwait(false);

                GB5Trace.Step("event-publish", new { EventTypeId = EventTypeConstant.SAVERESOURCEPUNCHEVENTTYPEID });

                return isNew
                    ? $"{SuccessResponse.SaveSuccessMessage} {dto.ResourcePunchId}"
                    : SuccessResponse.UpdateSuccessMessage;
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("save-resource-punch-failed", ex);
                _logger.LogError(ex, "SaveResourcePunch failed for EmployeeId {EmployeeId}", dto.EmployeeId);
                throw;
            }
        }
    }
}