using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using vendorApproverBackend.Requests;
using vendorApproverBackend.Entities;
using vendorApproverBackend.Services;
using vendorApproverBackend.Enums;
using vendorApproverBackend.Responses;
using vendorApproverBackend.Interfaces;

namespace vendorApproverBackend.Controllers;

[ApiController]
[Route("api/[controller]")]
public class AdminEmployeesController : ControllerBase
{
    private readonly UserService _userService;
    private readonly IEmailService _emailService;

    public AdminEmployeesController(UserService userService, IEmailService emailService)
    {
        _userService = userService;
        _emailService = emailService;
    }

    [HttpPost("add_employee")]
    [Authorize(Roles = "ADMIN")]
    public async Task<ActionResult<User>> AddEmployee([FromBody] EmployeeRequest request)
    {
        // 1. Validation Logic
        if (string.IsNullOrEmpty(request.Email))
        {
            return StatusCode(StatusCodes.Status406NotAcceptable, "Email  can't be null or empty.");
        }

        if (await _userService.ExistByEmailAsync(request.Email.ToLower()))
        {
            return StatusCode(StatusCodes.Status406NotAcceptable, "Email already exists.");
        }

        if (!string.IsNullOrEmpty(request.PhoneNumber) && await _userService.ExistByPhoneNumberAsync(request.PhoneNumber))
        {
            return StatusCode(StatusCodes.Status406NotAcceptable, "Phone number already exists.");
        }
        String password = _userService.GenerateNewPassword();
        try
        {
            var userCount = await _userService.GetUserCountAsync();
            var Username = _userService.GenerateUsername(request.Name, userCount);

            var newUser = new User
            {
                Name = request.Name,
                Email = request.Email,
                Username = Username,
                PhoneNumber = request.PhoneNumber,
                City = request.City,
                JobTitle = request.JobTitle,
                Departement = request.Departement,
                Country = request.Country,
                Active = true,
                Status = request.Status,
                Role = RoleEnum.ROLE_EMPLOYEE,
                StartDate = request.StartDate.ToUniversalTime(),
                Type = request.Type,
            };

             newUser.Password = BCrypt.Net.BCrypt.HashPassword(password);

           var result = await _userService.SaveUserAsync(newUser, request.AppCategoriesIds);

           try
        {
            await _emailService.SendEmployeeEmailAsync(request.Email, result, password);
        }
        catch
        {
            // log error if needed
        }
            return Ok(result);
        }
        catch (Exception e)
        {
            return StatusCode(StatusCodes.Status500InternalServerError, $"An error occurred while saving: {e.Message}");
        }
    }

    [HttpPatch("update_employee/{id}")]
    [Authorize(Roles = "ADMIN")]
    public async Task<ActionResult<User>> UpdateEmployee(long id, [FromBody] UpdateEmployeeRequest request)
    {
        try
        {
            var userToUpdate = await _userService.FindByIdAsync(id);
            if (userToUpdate == null)
            {
                return NotFound($"User with ID {id} not found.");
            }
            if (request.Email != null && userToUpdate.Email.ToLower() != request.Email.ToLower())
            {
                if (await _userService.DoesUsernameExistAsync(request.Email.ToLower()))
                {
                    return StatusCode(StatusCodes.Status406NotAcceptable, $"Email '{request.Email}' already exists.");
                }
                userToUpdate.Email = request.Email;
            }
            if (request.Name != null) userToUpdate.Name = request.Name;

            if (request.City != null) userToUpdate.City = request.City;
            if (request.Departement != null) userToUpdate.Departement = request.Departement;
            if (request.JobTitle != null) userToUpdate.JobTitle = request.JobTitle;
            if (request.Country != null) userToUpdate.Country = request.Country;
            if (request.PhoneNumber != null) userToUpdate.PhoneNumber = request.PhoneNumber;
            if (request.Active.HasValue) userToUpdate.Active = request.Active.Value;
            if (request.Status.HasValue) userToUpdate.Status = request.Status.Value;
            if (request.Deleted.HasValue) userToUpdate.Deleted = request.Deleted.Value;
            if (request.StartDate.HasValue) userToUpdate.StartDate = request.StartDate.Value.ToUniversalTime();
            if (request.Type.HasValue) userToUpdate.Type = request.Type.Value;
           
            //var updatedUser = await _userService.UpdateUserAsync(userToUpdate);
            var updatedUser = await _userService.UpdateUserAsync(userToUpdate, request.AppCategoriesIds);

            return Ok(updatedUser);
        }
        catch (Exception e)
        {
            return StatusCode(StatusCodes.Status500InternalServerError, $"An error occurred while updating: {e.Message}");
        }
    }

    /* [HttpGet("get_all_employees_paginator")]
    [Authorize(Roles = "ADMIN")]
    public async Task<ActionResult<object>> GetAllEmployeesPaginator(
       [FromQuery] int page = 0,
       [FromQuery] int size = 5,
       [FromQuery] string? search = null,
       [FromQuery] string? categoryName = null,
       [FromQuery] EmployeeTypeEnum? type = null,
       [FromQuery] bool? active = null,
       [FromQuery] bool? status = null,
       [FromQuery] bool? freeEvaluator = null,
       [FromQuery] bool? freeInspector = null)
    {
        try
        {
            const RoleEnum employeeRole = RoleEnum.ROLE_EMPLOYEE;
            const bool notDeleted = false;

            if (size > 0)
            {
                var pagedResult = await _userService.FindUsersByCriteriaAsync(
                    page,
                    size,
                    search,
                    employeeRole,
                    type,
                    categoryName,
                    active,
                    status,
                    notDeleted,
                    freeEvaluator,
                    freeInspector);

                return Ok(pagedResult);
            }
            else
            {
                var fullList = await _userService.FindUserByCriteriaList(
                    search,
                    employeeRole,
                    type,
                    categoryName,
                    active,
                    status,
                    notDeleted,
                    freeEvaluator,
                    freeInspector);

                return Ok(fullList);
            }
        }
        catch (Exception e)
        {
            return StatusCode(StatusCodes.Status409Conflict, $"An error occurred during search: {e.Message}");
        }
    } */


    [HttpGet("get_all_employees_paginator")]
    [Authorize(Roles = "ADMIN")]
    public async Task<ActionResult<object>> GetAllEmployeesPaginator(
       [FromQuery] int page = 0,
       [FromQuery] int size = 5,
       [FromQuery] string? search = null,
       [FromQuery] string? categoryName = null,
       [FromQuery] EmployeeTypeEnum? type = null,
       [FromQuery] bool? active = null,
       [FromQuery] bool? status = null,
       [FromQuery] bool? freeEvaluator = null,
       [FromQuery] bool? freeInspector = null)
    {
        try
        {
            const RoleEnum employeeRole = RoleEnum.ROLE_EMPLOYEE;
            const bool notDeleted = false;

            if (size > 0)
            {
                // Calls the updated service method which returns PagedResult<EnrichedUser>
                var pagedResult = await _userService.FindEnrichedUserByCriteriaAsync(
                    page,
                    size,
                    search,
                    employeeRole,
                    type,
                    categoryName,
                    active,
                    status,
                    notDeleted,
                    freeEvaluator,
                    freeInspector);

                return Ok(pagedResult);
            }
            else
            {
                // Calls the updated service method which returns List<EnrichedUser>
                var fullList = await _userService.FindeEnrichedUserByCriteriaList(
                    search,
                    employeeRole,
                    type,
                    categoryName,
                    active,
                    status,
                    notDeleted,
                    freeEvaluator,
                    freeInspector);

                return Ok(fullList);
            }
        }
        catch (Exception e)
        {
            return StatusCode(StatusCodes.Status409Conflict, $"An error occurred during search: {e.Message}");
        }
    }

    [HttpGet("get_all_employees_List")]
    [Authorize(Roles = "ADMIN")]
    public async Task<ActionResult<object>> GetAllEmployeesList(
       [FromQuery] string? search = null,
       [FromQuery] string? categoryName = null,
       [FromQuery] EmployeeTypeEnum? type = null,
       [FromQuery] bool? active = null,
       [FromQuery] bool? status = null,
       [FromQuery] bool? freeEvaluator = null,
       [FromQuery] bool? freeInspector = null)
    {
        try
        {
            const RoleEnum employeeRole = RoleEnum.ROLE_EMPLOYEE;
            const bool notDeleted = false;
                var fullList = await _userService.FindeEnrichedUserByCriteriaList(
                    search,
                    employeeRole,
                    type,
                    categoryName,
                    active,
                    status,
                    notDeleted,
                    freeEvaluator,
                    freeInspector);

                return Ok(fullList);
            
        }
        catch (Exception e)
        {
            return StatusCode(StatusCodes.Status409Conflict, $"An error occurred during search: {e.Message}");
        }
    }


    [HttpGet("employee_by_id/{id}")]
    [Authorize(Roles = "ADMIN")]
    public async Task<ActionResult<User>> ArchiveEmployee(long id)
    {
        try
        {

            var userToUpdate = await _userService.FindByIdAsync(id);
            if (userToUpdate == null)
            {
                return NotFound($"User with ID {id} not found.");
            }
            userToUpdate.Deleted = false;
            var updatedUser = await _userService.UpdateUserAsync(userToUpdate);
            return Ok(updatedUser);
        }
        catch (Exception e)
        {
            return StatusCode(StatusCodes.Status409Conflict, $"An error occurred during search: {e.Message}");
        }
    }


    [HttpPatch("archive_employee/{id}")]
    [Authorize(Roles = "ADMIN")]
    public async Task<ActionResult<User>> EmployeeDetails(long id)
    {
        try
        {
            var userToUpdate = await _userService.FindByIdAsync(id);
            if (userToUpdate == null)
            {
                return NotFound($"User with ID {id} not found.");
            }
            userToUpdate.Deleted = true;
            userToUpdate.Active = false;
            userToUpdate.Email = $"{userToUpdate.Email}.archived.{userToUpdate.Id}";
            userToUpdate.Username = $"{userToUpdate.Username}.archived.{userToUpdate.Id}";
            var updatedUser = await _userService.UpdateUserAsync(userToUpdate);
            return Ok(updatedUser);
        }
        catch (Exception e)
        {
            return StatusCode(StatusCodes.Status409Conflict, $"An error occurred during search: {e.Message}");
        }
    }

    [HttpGet("performance-evaluators-list")]
public async Task<IActionResult> GetPerformanceEvaluators()
{
    try
    {
        var users = await _userService.GetPerformanceEvaluatorsAsync();
        return Ok(users);
    }
    catch (Exception e)
    {
        // Log the exception details here
        return StatusCode(StatusCodes.Status409Conflict, $"An error occurred during search: {e.Message}");
    }
}
}