using Application.Endpoints;
using Application.Endpoints.Doctors.Login;
using Application.Endpoints.Doctors.Profile;
using Application.Endpoints.Doctors.Registration;
using Application.Endpoints.Doctors.ResetPassword;
using Application.Services.Database;
using Application.Services.Database.MongoDB;
using Application.Services.HashingAlgorithms;
using Application.Services.Jwt;
using Core.Entities;
using Microsoft.AspNetCore.Mvc;

namespace API.Controllers;

[ApiController]
[Route("api/[controller]")]
public class DoctorsController : ControllerBase
{
    private readonly IDoctorRepository _database;
    private readonly IHashingAlgorithms _hashingAlgorithms;
    private readonly IJwtService _jwtService;
    private readonly IAppointmentsMongoDbService _appointmentsMongoDbService;

    public DoctorsController(IDoctorRepository database, IHashingAlgorithms hashingAlgorithms,
        IJwtService jwtService, IAppointmentsMongoDbService appointmentsMongoDbService)
    {
        _database = database;
        _hashingAlgorithms = hashingAlgorithms;
        _jwtService = jwtService;
        _appointmentsMongoDbService = appointmentsMongoDbService;
    }

    [HttpPost("register")]
    public async Task<ActionResult<BaseResponse>> Register(DoctorRegistrationDto doctorRegistrationDto)
    {
        var handler = new DoctorRegistrationHandler(_database, _hashingAlgorithms);
        var response = await handler.Handle(doctorRegistrationDto).ConfigureAwait(false);
        return StatusCode(response.StatusCode, response);
    }

    [HttpPost("login")]
    public async Task<ActionResult<BaseResponse>> Login(DoctorLoginDto doctorLoginDto)
    {
        var handler = new DoctorLoginHandler(_database, _hashingAlgorithms);
        var response = await handler.Handle(doctorLoginDto).ConfigureAwait(false);
        /*
        if (response.Data != null)
        {
            Doctor doctor = (Doctor)response.Data;
            var authToken = _jwtService.GenerateJwtToken(doctor.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
            });
        }
        else
        {
            var newToken = _jwtService.RefreshToken(oldToken);
            return StatusCode(HttpStatusCodes.OK, new BaseResponse
            {
                StatusCode = HttpStatusCodes.OK, 
                Message = "Token refreshed successfully.", 
                Data = new { Token = newToken }
            });
        }
    }

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

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

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

    [HttpPut]
    public async Task<ActionResult<BaseResponse>> UpdateDoctorProfile(DoctorProfileUpdateDto doctorUpdateDto)
    {
        var handler = new DoctorProfileHandler(_database, _hashingAlgorithms);
        var response = await handler.HandleUpdate(doctorUpdateDto).ConfigureAwait(false);
        return StatusCode(response.StatusCode, response);
    }

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

        if (response.StatusCode < HttpStatusCodes.BadRequest)
        {
            DeleteDoctorAppointments(id);
        }
        
        return StatusCode(response.StatusCode, response);
    }

    private async void DeleteDoctorAppointments(Guid doctorId)
    {
        var criteria = new List<(string FieldName, string Value)>
        {
            ("DoctorId", doctorId.ToString())
        };
        var appointments = await _appointmentsMongoDbService.FindAsync<Appointment>(criteria);
        if (!appointments.Any())
        {
            return;
        }
        await _appointmentsMongoDbService.DeleteByIdAsync<Appointment>(appointments[0].Id);
    }
}