shoc-backend/Api.SeaHavenIndustries/Controllers/EmployeeController.cs

using Api.SeaHavenIndustries.DTOs;
using Data.SeaHavenIndustries;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using SeaHaven.Services.Interfaces;
using SeaHaven.Services.DTOs;

[ApiController]
[Route("api/Employee")]
[Route("api/employees")]
public class EmployeeController : Controller
{
    private readonly IEmployeeService _employeeService;

    public EmployeeController(IEmployeeService employeeService)
    {
        _employeeService = employeeService;
    }

    // -----------------------------------
    // POST: api/Employee/AddEmployees
    // -----------------------------------
    [HttpPost("AddEmployees")]
    public async Task<IActionResult> AddEmployees(AddEmployee_DTO dto)
    {
        try
        {
            var createDto = new CreateEmployeeDTO
            {
                FirstName = dto.FirstName,
                LastName = dto.LastName,
                JobTitleId = dto.JobTitleId,
                DepartmentId = null, // Map from PermissionGroupId if needed
                Email = dto.Email,
                Phone = dto.Phone
            };

            var userId = User.Identity?.Name ?? "system";
            await _employeeService.CreateEmployeeAsync(createDto, userId);

            return Ok(new { Message = "Employee added successfully" });
        }
        catch (Exception ex)
        {
            return BadRequest(new { Message = ex.Message });
        }
    }

    // -----------------------------------
    // POST: api/Employee/EditEmployees
    // -----------------------------------
    [HttpPost("EditEmployees")]
    public async Task<IActionResult> EditEmployees(EditEmployee_DTO dto)
    {
        try
        {
            var updateDto = new UpdateEmployeeDTO
            {
                FirstName = dto.FirstName,
                LastName = dto.LastName,
                JobTitleId = dto.JobTitleId
            };

            var userId = User.Identity?.Name ?? "system";
            await _employeeService.UpdateEmployeeAsync(dto.Id, updateDto, userId);

            return Ok(new { Message = "Employee updated successfully" });
        }
        catch (Exception ex)
        {
            return BadRequest(new { Message = ex.Message });
        }
    }

    // -----------------------------------
    // GET: api/Employee/GetEmployeeList
    // -----------------------------------
    [HttpGet("GetEmployeeList")]
    public async Task<IActionResult> GetEmployeeList(string? search = "", int page = 1, int pageSize = 12)
    {
        var pagedResult = await _employeeService.GetEmployeesPagedAsync(page, pageSize, search);

        var data = pagedResult.Items.Select(e => new
        {
            id = e.Id,
            firstName = e.FirstName,
            lastName = e.LastName,
            jobTitle = e.JobTitleName ?? "",
            email = e.Email ?? "",
            phone = e.Phone ?? "",
            department = e.DepartmentName ?? "",
            status = "Active" // Map from employee status if available
        });

        var totalPages = (int)Math.Ceiling(pagedResult.TotalCount / (double)pageSize);

        var viewModel = new Pagination_DTO
        {
            Data = data,
            PageNumber = page,
            PageSize = pageSize,
            TotalCount = pagedResult.TotalCount,
            TotalPages = totalPages
        };

        return Ok(viewModel);
    }
    // -----------------------------------
    // GET: api/Employee/DeleteEmployees?id=5
    // -----------------------------------
    [HttpGet("DeleteEmployees")]
    public async Task<IActionResult> DeleteEmployees(int id)
    {
        try
        {
            var userId = User.Identity?.Name ?? "system";
            await _employeeService.DeleteEmployeeAsync(id, userId);

            return Ok(new DataResponse
            {
                Message = "Employee deleted successfully.",
                Status = "200"
            });
        }
        catch (InvalidOperationException ex)
        {
            return BadRequest(new Response
            {
                Status = "Error",
                Message = ex.Message
            });
        }
        catch (Exception ex)
        {
            return BadRequest(new Response
            {
                Status = "Error",
                Message = ex.Message
            });
        }
    }

}