using Collaboration.Application.DTOs.Requests;
using Collaboration.Application.Interfaces;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.Security.Claims;

namespace Collaboration.Api.Controllers;

[Authorize]
[ApiController]
[Route("api/collab")]
[Produces("application/json")]
public class CollabSessionController : ControllerBase
{
    private readonly ICollabSessionService _service;

    private Guid UserId => Guid.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier)!);
    private Guid OrgId  => Guid.Parse(User.FindFirstValue("orgId")!);
    private string DisplayName => User.FindFirstValue("displayName") ?? "Unknown";

    public CollabSessionController(ICollabSessionService service) => _service = service;

    /// <summary>Create a new ad-hoc or scheduled session.</summary>
    [HttpPost("sessions")]
    [ProducesResponseType(typeof(Application.DTOs.Responses.SessionResponse), 201)]
    public async Task<IActionResult> Create([FromBody] CreateSessionRequest request, CancellationToken ct)
    {
        var result = await _service.CreateAsync(request, UserId, OrgId, DisplayName, ct);
        return CreatedAtAction(nameof(GetById), new { id = result.SessionId }, result);
    }

    /// <summary>Get session by ID.</summary>
    [HttpGet("sessions/{id:guid}")]
    public async Task<IActionResult> GetById(Guid id, CancellationToken ct)
    {
        var result = await _service.GetAsync(id, OrgId, ct);
        return result is null ? NotFound() : Ok(result);
    }

    /// <summary>Get all sessions I'm currently active in.</summary>
    [HttpGet("sessions/active")]
    public async Task<IActionResult> GetActive(CancellationToken ct) =>
        Ok(await _service.GetActiveSessionsAsync(UserId, OrgId, ct));

    /// <summary>Get my upcoming scheduled sessions.</summary>
    [HttpGet("sessions/scheduled")]
    public async Task<IActionResult> GetScheduled(CancellationToken ct) =>
        Ok(await _service.GetScheduledSessionsAsync(UserId, OrgId, ct));

    /// <summary>Start, pause, resume, or end a session.</summary>
    [HttpPatch("sessions/{id:guid}/status")]
    public async Task<IActionResult> UpdateStatus(
        Guid id, [FromBody] UpdateSessionStatusRequest request, CancellationToken ct)
    {
        var result = await _service.UpdateStatusAsync(id, request, UserId, OrgId, ct);
        return Ok(result);
    }

    /// <summary>Join a session directly (in-org, by ID).</summary>
    [HttpGet("sessions/{id:guid}/join")]
    public async Task<IActionResult> Join(Guid id, CancellationToken ct)
    {
        var result = await _service.JoinAsync(id, UserId, OrgId, DisplayName, ct);
        return Ok(result);
    }

    /// <summary>Invite specific users to a session.</summary>
    [HttpPost("sessions/{id:guid}/invites/users")]
    public async Task<IActionResult> InviteUsers(
        Guid id, [FromBody] InviteUsersRequest request, CancellationToken ct)
    {
        await _service.SendUserInvitesAsync(id, request, UserId, OrgId, ct);
        return NoContent();
    }

    /// <summary>Create a shareable invite link for a session.</summary>
    [HttpPost("sessions/{id:guid}/invites/link")]
    public async Task<IActionResult> CreateLinkInvite(
        Guid id, [FromBody] CreateLinkInviteRequest request, CancellationToken ct)
    {
        var result = await _service.CreateLinkInviteAsync(id, request, UserId, OrgId, ct);
        return Ok(result);
    }

    /// <summary>Get my pending invites.</summary>
    [HttpGet("invites/pending")]
    public async Task<IActionResult> GetPendingInvites(CancellationToken ct) =>
        Ok(await _service.GetPendingInvitesAsync(UserId, ct));

    /// <summary>Resolve an invite token and join the session.</summary>
    [HttpPost("invites/{token}/join")]
    public async Task<IActionResult> JoinViaToken(string token, CancellationToken ct)
    {
        var result = await _service.JoinViaTokenAsync(token, UserId, OrgId, DisplayName, ct);
        return Ok(result);
    }

    /// <summary>Accept or decline an invite.</summary>
    [HttpPatch("invites/{id:guid}/respond")]
    public async Task<IActionResult> RespondToInvite(
        Guid id, [FromBody] RespondToInviteRequest request, CancellationToken ct)
    {
        await _service.RespondToInviteAsync(id, request, UserId, ct);
        return NoContent();
    }

    /// <summary>Grant control to another participant (Host only).</summary>
    [HttpPost("sessions/{id:guid}/control/grant")]
    public async Task<IActionResult> GrantControl(
        Guid id, [FromBody] GrantControlRequest request, CancellationToken ct)
    {
        await _service.GrantControlAsync(id, request, UserId, OrgId, ct);
        return NoContent();
    }

    /// <summary>Revoke control and return it to host (Host only).</summary>
    [HttpPost("sessions/{id:guid}/control/revoke")]
    public async Task<IActionResult> RevokeControl(Guid id, CancellationToken ct)
    {
        await _service.RevokeControlAsync(id, UserId, OrgId, ct);
        return NoContent();
    }
}


[Authorize]
[ApiController]
[Route("api/collab/config")]
[Produces("application/json")]
public class CollabConfigController : ControllerBase
{
    private readonly ICollabConfigService _service;
    private Guid OrgId => Guid.Parse(User.FindFirstValue("orgId")!);

    public CollabConfigController(ICollabConfigService service) => _service = service;

    /// <summary>Get org collaboration configuration.</summary>
    [HttpGet]
    public async Task<IActionResult> Get(CancellationToken ct) =>
        Ok(await _service.GetAsync(OrgId, ct));

    /// <summary>Update org collaboration configuration (Admin only).</summary>
    [HttpPut]
    [Authorize(Policy = "CollabAdmin")]
    public async Task<IActionResult> Update([FromBody] UpdateCollabConfigRequest request, CancellationToken ct) =>
        Ok(await _service.UpdateAsync(OrgId, request, ct));
}