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

using System.Security.Claims;
using Api.SeaHavenIndustries.DTOs;
using Data.SeaHavenIndustries;
using FluentValidation;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using SeaHaven.Services.Interfaces;
using SeaHaven.Services.DTOs;
using SeaHaven.DataServices.Interfaces;

[ApiController]
[Authorize]
[Route("api/FollowUp")]
[Route("api/followups")]
public class FollowUpController : ControllerBase
{
    private readonly IFollowUpService _followUpService;
    private readonly IFollowUpDataService _followUpDataService; // Keep for direct entity operations
    private readonly ApplicationDbContext _db; // Keep for User lookups
    private readonly UserManager<ApplicationUser> _users;

    public FollowUpController(IFollowUpService followUpService, IFollowUpDataService followUpDataService, ApplicationDbContext db, UserManager<ApplicationUser> users)
    {
        _followUpService = followUpService;
        _followUpDataService = followUpDataService;
        _db = db;
        _users = users;
    }

    [HttpGet("GetFollowUpList")]
    public async Task<IActionResult> GetFollowUps(
        string? search = "",
        string? status = "Open",
        int page = 1,
        int pageSize = 12)
    {
        status = string.IsNullOrWhiteSpace(status) ? "Open" : status;

        var pagedResult = await _followUpService.GetFollowUpsPagedAsync(page, pageSize, search, status);
        var items = pagedResult.Items;

        var rows = items.Select(x => new
        {
            Id = x.Id,
            Reason = x.Reason,
            ScheduleDate = x.ScheduleDate,
            ScheduleStartTime = x.ScheduleStartTime,
            EmployeeId = x.EmployeeId,
            WorkOrderId = x.WorkOrderId,
            AccountId = x.AccountId,
            LocationId = x.LocationId,
            AccountName = x.AccountName ?? "",
            AssignedTo = x.EmployeeName ?? "",
            LocationName = x.LocationName ?? "",
            WorkOrderNumber = "",
            InternalWONumber = "",
            Status = x.Status,
            CreatedDate = x.CreatedDate,
            CreatedById = (string?)null
        }).ToList();

        var creatorIds = rows
            .Select(r => r.CreatedById)
            .Where(id => !string.IsNullOrEmpty(id))
            .Distinct()
            .ToList();

        var creators = await _db.Users
            .Where(u => creatorIds.Contains(u.Id))
            .Select(u => new { u.Id, u.FirstName, u.LastName, u.UserName })
            .ToDictionaryAsync(u => u.Id, u => u);

        string NameFor(string? userId)
        {
            if (string.IsNullOrEmpty(userId) || !creators.TryGetValue(userId, out var u)) return "";
            var full = ((u.FirstName ?? "") + " " + (u.LastName ?? "")).Trim();
            return string.IsNullOrWhiteSpace(full) ? (u.UserName ?? "") : full;
        }

        var data = rows.Select(r => new
        {
            r.Id,
            r.Reason,
            r.ScheduleDate,
            r.ScheduleStartTime,
            r.EmployeeId,
            r.WorkOrderId,
            r.AccountId,
            r.LocationId,
            r.AccountName,
            r.AssignedTo,
            r.LocationName,
            r.WorkOrderNumber,
            r.InternalWONumber,
            r.Status,
            r.CreatedDate,
            r.CreatedById,
            CreatedByName = NameFor(r.CreatedById)
        }).ToList();

        return Ok(new Pagination_DTO
        {
            Data = data,
            PageNumber = page,
            PageSize = pageSize,
            TotalCount = pagedResult.TotalCount,
            TotalPages = (int)Math.Ceiling(pagedResult.TotalCount / (double)pageSize)
        });
    }

    [HttpGet("GetById")]
    public async Task<IActionResult> GetById(int id)
    {
        var model = await _followUpDataService.GetByIdWithDetailsAsync(id);

        if (model == null) return NotFound();

        string createdByName = "";
        if (!string.IsNullOrEmpty(model.createdby))
        {
            var u = await _db.Users
                .Where(x => x.Id == model.createdby)
                .Select(x => new { x.FirstName, x.LastName, x.UserName })
                .FirstOrDefaultAsync();
            if (u != null)
            {
                var n = ((u.FirstName ?? "") + " " + (u.LastName ?? "")).Trim();
                createdByName = string.IsNullOrWhiteSpace(n) ? (u.UserName ?? "") : n;
            }
        }

        return Ok(new
        {
            model.Id,
            model.Reason,
            model.ScheduleDate,
            model.ScheduleStartTime,
            model.EmployeeId,
            model.WorkOrderId,
            model.AccountId,
            model.LocationId,
            AccountName = model.Account?.Name ?? "",
            AssignedTo = model.Employee != null
                ? (model.Employee.FirstName + " " + model.Employee.LastName)
                : "",
            LocationName = model.Location?.Name ?? "",
            WorkOrderNumber = model.WorkOrder?.WorkerOrderNumber ?? "",
            InternalWONumber = model.WorkOrder?.InternalWONumber ?? "",
            model.Status,
            model.CreatedDate,
            CreatedById = model.createdby,
            CreatedByName = createdByName
        });
    }

    [HttpPost("Create")]
    public async Task<IActionResult> Create(FollowUp_DTO dto)
    {
        try
        {
            var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
            if (userId == null)
                return Unauthorized(new Response { Status = "Error", Message = "User not authenticated" });

            var model = new FollowUps
            {
                Reason = dto.Reason,
                ScheduleDate = dto.ScheduleDate,
                ScheduleStartTime = dto.ScheduleStartTime,
                EmployeeId = dto.EmployeeId,
                WorkOrderId = dto.WorkOrderId,
                AccountId = dto.AccountId,
                LocationId = dto.LocationId,
                Status = "Open",
                CreatedDate = DateTime.UtcNow,
                createdby = userId
            };

            await _followUpDataService.AddAsync(model);

            return Ok(new DataResponse { Status = "200", Message = "Follow Up created", Data = model.Id });
        }
        catch (ValidationException vex)
        {
            var errors = string.Join(", ", vex.Errors.Select(e => e.ErrorMessage));
            return BadRequest(new Response { Status = "Validation Error", Message = errors });
        }
        catch (Exception ex)
        {
            return StatusCode(500, new Response { Status = "Error", Message = ex.Message });
        }
    }

    [HttpPost("Update")]
    public async Task<IActionResult> Update(FollowUp_DTO dto)
    {
        try
        {
            var model = await _followUpDataService.GetByIdAsync(dto.Id);
            if (model == null)
                return NotFound(new Response { Status = "Error", Message = "Follow Up not found" });

            model.Reason = dto.Reason;
            model.ScheduleDate = dto.ScheduleDate;
            model.ScheduleStartTime = dto.ScheduleStartTime;
            model.EmployeeId = dto.EmployeeId;
            model.WorkOrderId = dto.WorkOrderId;
            model.AccountId = dto.AccountId;
            model.LocationId = dto.LocationId;
            model.LastModificationTime = DateTime.UtcNow;

            await _followUpDataService.UpdateAsync(model);
            return Ok(new DataResponse { Status = "200", Message = "Follow Up updated" });
        }
        catch (ValidationException vex)
        {
            var errors = string.Join(", ", vex.Errors.Select(e => e.ErrorMessage));
            return BadRequest(new Response { Status = "Validation Error", Message = errors });
        }
        catch (KeyNotFoundException)
        {
            return NotFound(new Response { Status = "Error", Message = "Follow Up not found" });
        }
        catch (Exception ex)
        {
            return StatusCode(500, new Response { Status = "Error", Message = ex.Message });
        }
    }

    [HttpPost("Complete")]
    public async Task<IActionResult> Complete(int id)
    {
        var model = await _followUpDataService.GetByIdAsync(id);
        if (model == null) return NotFound();

        model.Status = "Completed";
        model.LastModificationTime = DateTime.UtcNow;
        await _followUpDataService.UpdateAsync(model);

        return Ok();
    }

    [HttpPost("Cancel")]
    public async Task<IActionResult> Cancel(int id)
    {
        var model = await _followUpDataService.GetByIdAsync(id);
        if (model == null) return NotFound();

        model.Status = "Cancelled";
        model.LastModificationTime = DateTime.UtcNow;
        await _followUpDataService.UpdateAsync(model);

        return Ok();
    }

    [HttpPost("Delete")]
    public async Task<IActionResult> Delete(int id)
    {
        try
        {
            var model = await _followUpDataService.GetByIdAsync(id);
            if (model == null)
                return NotFound(new Response { Status = "Error", Message = "Follow Up not found" });

            await _followUpDataService.DeleteAsync(id);

            return Ok(new DataResponse { Status = "200", Message = "Follow Up deleted" });
        }
        catch (KeyNotFoundException)
        {
            return NotFound(new Response { Status = "Error", Message = "Follow Up not found" });
        }
        catch (Exception ex)
        {
            return StatusCode(500, new Response { Status = "Error", Message = ex.Message });
        }
    }
}