using ApiDenuncias.Services;
using GestionaDenuncias.Shared.Models;
using ApiDenuncias.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace ApiDenuncias.Controllers;

[ApiController]
[Authorize]
[Route("api/denuncias")]
public sealed class DenunciasController : ControllerBase
{
    private readonly IDenunciaStore _denunciaStore;
    private readonly UserComplaintAccessService _accessService;

    public DenunciasController(IDenunciaStore denunciaStore, UserComplaintAccessService accessService)
    {
        _denunciaStore = denunciaStore;
        _accessService = accessService;
    }

    [HttpPost("schema/ensure")]
    public async Task<IActionResult> EnsureSchema(CancellationToken cancellationToken)
    {
        await _denunciaStore.EnsureSchemaAsync(cancellationToken);
        return Ok(new { ok = true });
    }

    [HttpGet]
    public async Task<ActionResult<List<DenunciasGestiona>>> GetAll(CancellationToken cancellationToken)
    {
        var allowedIds = await GetAllowedIdsAsync(cancellationToken);
        var denuncias = await _denunciaStore.GetAllDenunciasAsync(cancellationToken);
        return Ok(denuncias.Where(d => allowedIds.Contains(d.Id_Denuncia)).ToList());
    }

    [HttpGet("{denunciaId:int}")]
    public async Task<ActionResult<DenunciasGestiona?>> GetById(int denunciaId, CancellationToken cancellationToken)
    {
        if (!await CanAccessAsync(denunciaId, cancellationToken))
        {
            return NotFound();
        }

        return Ok(await _denunciaStore.GetDenunciaByIdAsync(denunciaId, cancellationToken));
    }

    [HttpPost]
    public async Task<IActionResult> Upsert(DenunciasGestiona denuncia, CancellationToken cancellationToken)
    {
        if (!await CanAccessAsync(denuncia.Id_Denuncia, cancellationToken))
        {
            return Forbid();
        }

        await _denunciaStore.UpsertDenunciaAsync(denuncia, cancellationToken);
        return Ok(new { ok = true });
    }

    [HttpGet("ficheros")]
    public async Task<ActionResult<List<FicherosDenuncias>>> GetAllFicheros(CancellationToken cancellationToken)
    {
        var allowedIds = await GetAllowedIdsAsync(cancellationToken);
        var ficheros = await _denunciaStore.GetAllFicherosAsync(cancellationToken);
        return Ok(ficheros.Where(f => allowedIds.Contains(f.Id_Denuncia)).ToList());
    }

    [HttpGet("{denunciaId:int}/ficheros")]
    public async Task<ActionResult<List<FicherosDenuncias>>> GetFicherosByDenuncia(int denunciaId, CancellationToken cancellationToken)
    {
        if (!await CanAccessAsync(denunciaId, cancellationToken))
        {
            return NotFound();
        }

        return Ok(await _denunciaStore.GetFicherosByDenunciaAsync(denunciaId, cancellationToken));
    }

    [HttpPost("ficheros")]
    public async Task<IActionResult> UpsertFicheros(UpsertFicherosRequest request, CancellationToken cancellationToken)
    {
        var ficheros = request.Ficheros ?? [];
        foreach (var denunciaId in ficheros.Select(f => f.Id_Denuncia).Distinct())
        {
            if (!await CanAccessAsync(denunciaId, cancellationToken))
            {
                return Forbid();
            }
        }

        await _denunciaStore.UpsertFicherosAsync(ficheros, cancellationToken);
        return Ok(new { ok = true });
    }

    [HttpPost("{denunciaId:int}/ficheros/mark-uploaded")]
    public async Task<IActionResult> MarkFicherosAsUploaded(
        int denunciaId,
        MarkFicherosUploadedRequest request,
        CancellationToken cancellationToken)
    {
        if (!await CanAccessAsync(denunciaId, cancellationToken))
        {
            return Forbid();
        }

        await _denunciaStore.MarkFicherosAsUploadedAsync(
            denunciaId,
            request.FileNames,
            request.UploadedAtUtc,
            cancellationToken);

        return Ok(new { ok = true });
    }

    private async Task<HashSet<int>> GetAllowedIdsAsync(CancellationToken cancellationToken)
    {
        await _denunciaStore.EnsureSchemaAsync(cancellationToken);
        return await _accessService.GetAllowedComplaintIdsAsync(GetUsername(), cancellationToken);
    }

    private async Task<bool> CanAccessAsync(int denunciaId, CancellationToken cancellationToken)
    {
        if (denunciaId <= 0)
        {
            return false;
        }

        await _denunciaStore.EnsureSchemaAsync(cancellationToken);
        return await _accessService.CanAccessComplaintAsync(GetUsername(), denunciaId, cancellationToken);
    }

    private string GetUsername()
        => User.Identity?.Name ?? throw new InvalidOperationException("No hay usuario autenticado.");
}
