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

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using SeaHaven.Services.DTOs;
using SeaHaven.Services.Interfaces;

namespace Api.SeaHavenIndustries.Controllers;

[Authorize]
[ApiController]
[Route("api/team-members")]
public sealed class TeamMemberController : ControllerBase
{
    private readonly ITeamMemberService _teamMemberService;
    private readonly ITeamPermissionService _permissionService;
    private readonly ITeamMemberInviteService _inviteService;

    public TeamMemberController(
        ITeamMemberService teamMemberService,
        ITeamPermissionService permissionService,
        ITeamMemberInviteService inviteService)
    {
        _teamMemberService = teamMemberService;
        _permissionService = permissionService;
        _inviteService = inviteService;
    }

    [HttpGet("me/permissions")]
    public async Task<IActionResult> GetMyPermissions(CancellationToken cancellationToken)
    {
        var result = await _permissionService.GetEffectivePermissionsAsync(User, cancellationToken);
        return result.IsSuccess ? Ok(result.Value) : Unauthorized();
    }

    [HttpPost("{userId}/invite")]
    public async Task<IActionResult> ResendInvite(string userId, CancellationToken cancellationToken)
    {
        var outcome = await _inviteService.ResendAsync(userId, User, cancellationToken);
        if (outcome.Success)
            return Ok(new { message = "Invite sent" });

        return outcome.Error switch
        {
            "Forbidden" => Forbid(),
            "Team member not found." => NotFound(new { message = outcome.Error }),
            _ => BadRequest(new { message = outcome.Error })
        };
    }

    [HttpPost]
    public async Task<IActionResult> Create(
        CreateTeamMemberRequestDTO request,
        CancellationToken cancellationToken)
    {
        var outcome = await _teamMemberService.CreateAsync(request, User, cancellationToken);
        if (!outcome.Success)
        {
            if (string.Equals(outcome.Error, "Forbidden", StringComparison.Ordinal))
                return Forbid();

            return BadRequest(new { message = outcome.Error });
        }

        return Ok(outcome.Member);
    }

    [HttpGet("{userId}")]
    public async Task<IActionResult> Get(string userId, CancellationToken cancellationToken)
    {
        var outcome = await _teamMemberService.GetAsync(userId, User, cancellationToken);
        return ToActionResult(outcome);
    }

    [HttpPut("{userId}")]
    public async Task<IActionResult> Update(
        string userId,
        UpdateTeamMemberRequestDTO request,
        CancellationToken cancellationToken)
    {
        var outcome = await _teamMemberService.UpdateAsync(userId, request, User, cancellationToken);
        return ToActionResult(outcome);
    }

    private IActionResult ToActionResult(TeamMemberOperationOutcomeDTO outcome)
    {
        if (outcome.Success)
            return Ok(outcome.Member);

        if (string.Equals(outcome.Error, "Forbidden", StringComparison.Ordinal))
            return Forbid();

        if (string.Equals(outcome.Error, "Team member not found.", StringComparison.Ordinal))
            return NotFound(new { message = outcome.Error });

        return BadRequest(new { message = outcome.Error });
    }
}