using Application.Services.Database.MongoDB;
using Application.Services.Database.PostgreSQL;
using FluentValidation;

namespace Application.Endpoints.Appointments.CreateAppointment;

public class CreateAppointmentValidator : AbstractValidator<AppointmentInformation>
{
    private readonly IAppointmentsMongoDbService _appointmentsMongoDbService;
    private readonly IDoctorRepository _doctorRepository;
    private readonly IPatientRepository _patientRepository;

    public CreateAppointmentValidator(IAppointmentsMongoDbService appointmentsMongoDbService,
        IDoctorRepository doctorRepository, IPatientRepository patientRepository)
    {
        RuleFor(x => x.DoctorId)
            .NotEmpty().WithMessage("Id is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
            .MustAsync(IsDoctorRegistered).WithMessage("Doctor is not registered in system")
            .WithErrorCode(HttpStatusCodes.NotFound.ToString());

        RuleFor(x => x.PatientId)
            .NotEmpty().WithMessage("Id is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
            .MustAsync(IsPatientRegistered).WithMessage("Patient is not registered in system")
            .WithErrorCode(HttpStatusCodes.NotFound.ToString());

        RuleFor(x => x.Appointment)
            .Must(IsAppointmentValidFormat).WithMessage("Appointment is not valid")
            .WithErrorCode(HttpStatusCodes.BadRequest.ToString());

        RuleFor(x => x)
            .MustAsync(IsAppointmentUnique)
            .WithMessage("Appointment already in system.")
            .WithErrorCode(HttpStatusCodes.Conflict.ToString());

        _appointmentsMongoDbService = appointmentsMongoDbService;
        _doctorRepository = doctorRepository;
        _patientRepository = patientRepository;
    }

    private async Task<bool> IsDoctorRegistered(Guid id, CancellationToken token)
    {
        var doctor = await _doctorRepository.GetByIdAsync(id, token);
        return doctor != null;
    }

    private async Task<bool> IsPatientRegistered(Guid id, CancellationToken token)
    {
        var patient = await _patientRepository.GetByIdAsync(id, token);
        return patient != null;
    }

    private bool IsAppointmentValidFormat(DateTime appointment)
    {
        if (appointment == default)
            return false;

        if (appointment.Date < DateTime.UtcNow.Date)
            return false;

        return true;
    }

    private async Task<bool> IsAppointmentUnique(AppointmentInformation request, CancellationToken token)
    {
        return await _appointmentsMongoDbService.IsAppointmentUnique(request, token);
    }
}