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

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

namespace Api.SeaHavenIndustries.Controllers
{
    [Authorize]
    [ApiController]
    [Route("api/[controller]")]
    [Route("api/uplifts")]
    public class UpliftController : Controller
    {
        private readonly IUpliftService _upliftService;

        public UpliftController(IUpliftService upliftService)
        {
            _upliftService = upliftService;
        }

        [HttpGet]
        public async Task<IActionResult> List([FromQuery] string? status = "Pending", [FromQuery] int? tier = null, [FromQuery] int page = 1, [FromQuery] int pageSize = 25, CancellationToken cancellationToken = default)
        {
            var result = await _upliftService.ListAsync(User, status, tier, page, pageSize, cancellationToken);
            return Ok(new DataResponse { Status = "Success", Data = result });
        }

        [HttpGet("dispatch/{dispatchId:int}")]
        public async Task<IActionResult> ListForDispatch(int dispatchId, CancellationToken cancellationToken = default)
        {
            var items = await _upliftService.ListForDispatchAsync(User, dispatchId, cancellationToken);
            return Ok(new DataResponse { Status = "Success", Data = items });
        }

        [HttpPost("{id:int}/approve")]
        public async Task<IActionResult> Approve(int id, [FromBody] DecisionRequest? body, CancellationToken cancellationToken = default)
        {
            try
            {
                var result = await _upliftService.ApproveAsync(User, id, body?.Note, cancellationToken);
                return Ok(new DataResponse { Status = "Success", Data = result });
            }
            catch (KeyNotFoundException ex)
            {
                return NotFound(new Response { Status = "Error", Message = ex.Message });
            }
            catch (UpliftForbiddenException ex)
            {
                return StatusCode(403, new Response { Status = "Error", Message = ex.Message });
            }
            catch (InvalidOperationException ex)
            {
                return BadRequest(new Response { Status = "Error", Message = ex.Message });
            }
        }

        [HttpPost("{id:int}/deny")]
        public async Task<IActionResult> Deny(int id, [FromBody] DecisionRequest? body, CancellationToken cancellationToken = default)
        {
            try
            {
                var result = await _upliftService.DenyAsync(User, id, body?.Note, cancellationToken);
                return Ok(new DataResponse { Status = "Success", Data = result });
            }
            catch (KeyNotFoundException ex)
            {
                return NotFound(new Response { Status = "Error", Message = ex.Message });
            }
            catch (UpliftForbiddenException ex)
            {
                return StatusCode(403, new Response { Status = "Error", Message = ex.Message });
            }
            catch (InvalidOperationException ex)
            {
                return BadRequest(new Response { Status = "Error", Message = ex.Message });
            }
        }

        [HttpGet("can-approve")]
        public IActionResult CanApprove([FromQuery] int tier)
        {
            return Ok(new DataResponse { Status = "Success", Data = new { canApprove = _upliftService.CanApprove(User, tier) } });
        }

        public class DecisionRequest
        {
            public string? Note { get; set; }
        }
    }
}