FACULTATE-HEALTHCARE_MANAGER/backend/API/Controllers/PatientsController.cs

using Application.Endpoints;
using Application.Endpoints.Patients.Login;
using Application.Endpoints.Patients.Profile;
using Application.Endpoints.Patients.Registration;
using Application.Endpoints.Patients.ResetPassword;
using Application.Services.Database.PostgreSQL;
using Application.Services.HashingAlgorithms;
using Application.Services.Email;
using Application.Services.Jwt;
using Core.Entities;
using Microsoft.AspNetCore.Mvc;

namespace API.Controllers;

[ApiController]
[Route("api/[controller]")]
public class PatientsController : ControllerBase
{
    private readonly IHashingAlgorithms _hashingAlgorithms;
    private readonly IJwtService _jwtService;
    private readonly IMedicalHistoryRepository _medicalHistory;
    private readonly IPatientRepository _patientRepository;
    private readonly IEmailService _emailService;

    public PatientsController(IPatientRepository patientRepository, IHashingAlgorithms hashingAlgorithms,
        IJwtService jwtService, IMedicalHistoryRepository medicalHistory, IEmailService emailService)
    {
        _patientRepository = patientRepository;
        _hashingAlgorithms = hashingAlgorithms;
        _jwtService = jwtService;
        _medicalHistory = medicalHistory;
        _emailService = emailService;
    }

    [HttpGet]
    public async Task<ActionResult<BaseResponse>> GetAllPatients()
    {
        var handler = new PatientProfileHandler(_patientRepository, _hashingAlgorithms);
        var response = await handler.HandleGetAll();
        return StatusCode(response.StatusCode, response);
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<BaseResponse>> GetPatient(Guid id)
    {
        var handler = new PatientProfileHandler(_patientRepository, _hashingAlgorithms);
        var response = await handler.HandleGet(id);
        return StatusCode(response.StatusCode, response);
    }

    [HttpPost("login")]
    public async Task<ActionResult<BaseResponse>> Login(PatientLoginDto patientLoginDto)
    {
        var handler = new PatientLoginHandler(_patientRepository);
        var response = await handler.Handle(patientLoginDto).ConfigureAwait(false);
        /*
        if (response.Data != null)
        {
            Patient patient = (Patient)response.Data;
            var authToken = _jwtService.GenerateJwtToken(patient.Email);

            HttpContext.Response.Headers.Add("Authorization", $"Bearer {authToken}");
        }
        */
        return StatusCode(response.StatusCode, response);
    }

    [HttpPost("refresh_token")]
    public async Task<ActionResult<BaseResponse>> RefreshToken()
    {
        var authorizationHeader = Request.Headers["Authorization"].FirstOrDefault();
        if (string.IsNullOrEmpty(authorizationHeader) || !authorizationHeader.StartsWith("Bearer "))
            return StatusCode(HttpStatusCodes.BadRequest, new BaseResponse
            {
                StatusCode = HttpStatusCodes.BadRequest,
                Message = "Invalid request header format.",
                Data = null
            });

        var oldToken = authorizationHeader.Substring("Bearer ".Length).Trim();

        if (!_jwtService.ValidateJwtToken(oldToken))
            return StatusCode(HttpStatusCodes.Unauthorized, new BaseResponse
            {
                StatusCode = HttpStatusCodes.Unauthorized,
                Message = "Invalid JWT token.",
                Data = null
            });

        var newToken = _jwtService.RefreshToken(oldToken);
        return StatusCode(HttpStatusCodes.OK, new BaseResponse
        {
            StatusCode = HttpStatusCodes.OK,
            Message = "Token refreshed successfully.",
            Data = new { Token = newToken }
        });
    }

    [HttpPost("register")]
    public async Task<ActionResult<BaseResponse>> Register(PatientRegistrationDto patientRegistrationDto)
    {
        var handler = new PatientRegistrationHandler(_patientRepository, _hashingAlgorithms);
        var response = await handler.Handle(patientRegistrationDto).ConfigureAwait(false);

        if (response.StatusCode < HttpStatusCodes.BadRequest)
        {
            var body = _emailService.GenerateCredentialsEmailBody(
                patientRegistrationDto.Email, patientRegistrationDto.Password);
            await _emailService.SendEmailAsync(patientRegistrationDto.Email, "Successful registration!", body);
        }
        
        return StatusCode(response.StatusCode, response);
    }

    [HttpPost("reset_password")]
    public async Task<ActionResult<BaseResponse>> ResetPassword(PatientResetPasswordDto patientResetPasswordDto)
    {
        var handler = new PatientResetPasswordHandler(_patientRepository, _hashingAlgorithms);
        var response = await handler.Handle(patientResetPasswordDto).ConfigureAwait(false);
        return StatusCode(response.StatusCode, response);
    }

    [HttpPut]
    public async Task<ActionResult<BaseResponse>> UpdatePatientProfile(PatientProfileDto patientDto)
    {
        var handler = new PatientProfileHandler(_patientRepository, _hashingAlgorithms);
        var response = await handler.HandleUpdate(patientDto).ConfigureAwait(false);
        return StatusCode(response.StatusCode, response);
    }

    [HttpDelete("{id}")]
    public async Task<ActionResult<BaseResponse>> DeletePatientProfile(Guid id)
    {
        var handler = new PatientProfileHandler(_patientRepository, _hashingAlgorithms);
        var response = await handler.HandleDelete(id).ConfigureAwait(false);

        if (response.StatusCode < HttpStatusCodes.BadRequest) DeleteMedicalHistory(id);

        return StatusCode(response.StatusCode, response);
    }

    private async void DeleteMedicalHistory(Guid patientId)
    {
        var medicalHistoryList = await _medicalHistory.GetAllAsync();
        foreach (var med in medicalHistoryList)
            if (med.UserId == patientId)
            {
                await _medicalHistory.DeleteAsync(med);
                return;
            }
    }
}