using Serilog;
using System;
using System.Linq;
using System.Threading.Tasks;
using Taloyhtio.IDP.SPApi.Model;
using webapi.Application.Services;
using webapi.Domain.Events;
using webapi.Domain.SeedWork;
using webapi.Exceptions;
using webapi.Infractructure.Core;
using webapi.Infractructure.Repositories;
using webapi.Infractructure.Services;

namespace webapi.Infractructure.EventHandlers
{
    public class SetApproverForUserFlatMappingEventHandler : BaseEventHandler<SetApproverForUserFlatMappingEvent>
    {
        readonly IUserFlatMappingRepository _repository;
        readonly IUserAuthRepository _userAuthRepository;
        readonly IUsersFlatApprovalRepository _usersFlatApprovalRepository;
        readonly ISPService _spService;
        readonly ISPHandlerService _spHandlerService;
        readonly ILogger _log;

        public SetApproverForUserFlatMappingEventHandler(ILogger log, IUserFlatMappingRepository repository, 
            IUserAuthRepository userAuthRepository, 
            IUsersFlatApprovalRepository usersFlatApprovalRepository,
            ISPService spService, 
            ISPHandlerService spHandlerService) {
            _repository = repository;
            _userAuthRepository = userAuthRepository;
            _usersFlatApprovalRepository = usersFlatApprovalRepository;
            _spService = spService;
            _spHandlerService = spHandlerService;
            _log = log;
        }

        public override async Task Handle(SetApproverForUserFlatMappingEvent request)
        {
            _log.Information($"SetApproverForUserFlatMappingEventHandler start");

            var user = _userAuthRepository.GetUserByTaloyhtioUserId(request.UserId);
            if (user == null) throw new WarningException($"The user with Id: {request.UserId} does not exist");

            var u2fApproval = _usersFlatApprovalRepository.GetApproval(request.UserId, request.FlatId);
            if (u2fApproval == null) throw new WarningException($"The approval request with Id: {request.ApprovalRequestId} does not exist");

            var u2fs = _repository.GetUserFlatsMappings(request.UserId, request.FlatId);

            _log.Information($"Mappings count '{u2fs.Count()}'");
            foreach (var u2f in u2fs)
            {
                _log.Information($"GetUserName {user.TaloyhtioUserId}");
                try
                {
                    var userName = await _spService.GetUserName(user.TaloyhtioUserId);

                    _log.Information($"GetUserName '{userName}'");

                    await _spHandlerService.UserToFlatFoldersAssignment(new UserToFlatFoldersAssignmentRequest()
                    {
                        FlatTitle = request.FlatTitle,
                        TaloyhtioPMCId = request.PMCId,
                        TaloyhtioCondoId = request.CondoId,
                        FBACurrentUserName = userName,
                        Remove = false
                    });
                    _log.Information($"UserToFlatFoldersAssignment call");

                    u2f.ApprovalRequestId = request.ApprovalRequestId;
                    u2f.RequestApprovalDate = request.RequestApprovalDate;
                    u2f.ApprovedBy = request.UserId;
                    u2f.PMSUserName = request.PMSUserName;
                    await _repository.SaveChanges(u2f);
                }
                catch (Exception e)
                {
                    _log.Error($"{e.Message} {e.StackTrace} {e.InnerException}");
                }
            }
            _log.Information($"SetApproverForUserFlatMappingEventHandler finish");
        }
    }
}