using System.Globalization;
using System.Text;
using ApiDenuncias.Services;
using GestionaDenuncias.Shared.Models;
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 IFilteredDenunciaStore _filteredDenunciaStore;
    private readonly UserComplaintAccessService _accessService;
    private readonly IInboxTrackingService _trackingService;
    private readonly ILogger<DenunciasController> _logger;

    public DenunciasController(
        IDenunciaStore denunciaStore,
        IFilteredDenunciaStore filteredDenunciaStore,
        UserComplaintAccessService accessService,
        IInboxTrackingService trackingService,
        ILogger<DenunciasController> logger)
    {
        _denunciaStore = denunciaStore;
        _filteredDenunciaStore = filteredDenunciaStore;
        _accessService = accessService;
        _trackingService = trackingService;
        _logger = logger;
    }

    [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(
        [FromQuery] DenunciaListScope scope,
        CancellationToken cancellationToken)
    {
        var allowedIds = await GetAllowedIdsAsync(cancellationToken);
        if (allowedIds.Count == 0)
        {
            return Ok(new List<DenunciasGestiona>());
        }

        return Ok(await _filteredDenunciaStore.GetDenunciasByIdsAsync(allowedIds, scope, cancellationToken));
    }

    [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));
    }

    [HttpGet("{denunciaId:int}/gestiona-fields")]
    public async Task<ActionResult<GestionaComplaintFieldsResponse>> GetGestionaFields(
        int denunciaId,
        CancellationToken cancellationToken)
    {
        if (denunciaId <= 0)
        {
            return BadRequest(new ApiError("Debes indicar un numero de denuncia valido."));
        }

        var denuncia = await _denunciaStore.GetDenunciaByIdAsync(denunciaId, cancellationToken);
        if (denuncia is null)
        {
            return NotFound(new ApiError("No se ha encontrado la denuncia solicitada."));
        }

        return Ok(ToGestionaComplaintFields(denuncia));
    }

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

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

    [HttpGet("ficheros")]
    public async Task<ActionResult<List<FicherosDenuncias>>> GetAllFicheros(CancellationToken cancellationToken)
    {
        var allowedIds = await GetAllowedIdsAsync(cancellationToken);
        if (allowedIds.Count == 0)
        {
            return Ok(new List<FicherosDenuncias>());
        }

        return Ok(await _filteredDenunciaStore.GetFicherosByDenunciaIdsAsync(allowedIds, cancellationToken));
    }

    [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));
    }

    [HttpGet("gestiona-history")]
    public async Task<ActionResult<List<GestionaUploadHistoryEntry>>> GetGestionaHistory(CancellationToken cancellationToken)
    {
        await _denunciaStore.EnsureSchemaAsync(cancellationToken);
        return Ok(await _denunciaStore.GetGestionaUploadHistoryAsync(cancellationToken));
    }

    [HttpPost("gestiona-history")]
    public async Task<IActionResult> AddGestionaHistory(
        GestionaUploadHistoryCreateRequest request,
        CancellationToken cancellationToken)
    {
        if (!await CanAccessAsync(request.DenunciaId, cancellationToken))
        {
            return Forbid();
        }

        await _denunciaStore.AddGestionaUploadHistoryAsync(request, GetUsername(), cancellationToken);
        await _trackingService.MarkReportHandledInGestionaAsync(
            GetUsername(),
            request.DenunciaId,
            request.UploadedAtUtc,
            cancellationToken);
        return Ok(new { ok = true });
    }

    [HttpGet("{denunciaId:int}/ficheros/content")]
    public async Task<IActionResult> GetFicheroContent(
        int denunciaId,
        [FromQuery] string fileName,
        CancellationToken cancellationToken)
    {
        if (string.IsNullOrWhiteSpace(fileName))
        {
            return BadRequest(new ApiError("Nombre de fichero obligatorio."));
        }

        if (!await CanAccessAsync(denunciaId, cancellationToken))
        {
            return NotFound();
        }

        var ficheros = await _denunciaStore.GetFicherosByDenunciaAsync(denunciaId, cancellationToken);
        var fichero = ficheros.FirstOrDefault(file =>
            string.Equals(file.NombreFichero, fileName, StringComparison.Ordinal));

        if (fichero?.Fichero is not { Length: > 0 } bytes)
        {
            return NotFound();
        }

        return File(
            bytes,
            GetAttachmentContentType(fichero.NombreFichero),
            enableRangeProcessing: true);
    }

    [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.");

    private static GestionaComplaintFieldsResponse ToGestionaComplaintFields(DenunciasGestiona denuncia)
    {
        var preferenciaNotificacion = ResolveReportField(
            denuncia,
            denuncia.Notificacion_Preferencia,
            "preferencia de notificacion",
            "seleccione su preferencia de notificacion y seguimiento de su denuncia",
            "notificaciones");

        var seguimiento = ResolveReportField(
            denuncia,
            denuncia.SeguimientoOnline,
            "seguimiento online",
            "seguimiento de su denuncia");

        return new GestionaComplaintFieldsResponse(
            FechaDenuncia: ToNullableDate(denuncia.Fecha),
            NumeroDenunciaCanal: denuncia.Id_Denuncia,
            AQuienDenuncia: ResolveReportField(denuncia, denuncia.A_Quien_Denuncia, "a quien denuncia"),
            ResumenDenuncia: FirstNonEmpty(
                ResolveReportField(denuncia, string.Empty, "resumen de la denuncia", "resumen denuncia"),
                ResolveReportField(denuncia, denuncia.Descripcion_Denuncia, "describa su denuncia", "descripcion de la denuncia")),
            FechaHechos: ResolveFechaHechos(denuncia),
            LugarHechos: ResolveReportField(
                denuncia,
                denuncia.Lugar_Hechos,
                "lugar en el que ocurrieron los hechos que denuncia",
                "lugar en la que ocurrieron los hechos que denuncia",
                "lugar de los hechos"),
            AmbitoCompetencias: ResolveAmbitoCompetencias(denuncia),
            SolicitaProteccion: ResolveReportField(denuncia, denuncia.SolicitaProteccion, "solicita medidas concretas de proteccion", "solicita proteccion"),
            SexoDenunciante: ResolveReportField(denuncia, denuncia.Sexo, "sexo"),
            AutorizaRemisionDenuncia: ResolveReportField(denuncia, denuncia.AutorizaRemision, "autorizacion para remitir su denuncia", "autoriza remision de la denuncia"),
            AutorizaNotificacionesViaSms: ResolveReportField(
                denuncia,
                denuncia.Notificacion_Sms,
                "autorizo recibir notificaciones via sms",
                "autorizacion notificaciones via sms",
                "autorizacion para recibir notificaciones via sms",
                "autoriza notificaciones via sms",
                "autorizo recibir notificaciones sms",
                "notificaciones via sms",
                "sms"),
            PreferenciaNotificacionSeguimientoDenuncia: JoinDistinct(preferenciaNotificacion, seguimiento));
    }

    private async Task TryRegisterGestionaHistoryFromComplaintAsync(
        DenunciasGestiona denuncia,
        CancellationToken cancellationToken)
    {
        if (!denuncia.EnGestiona || denuncia.FechaSubidaAGestiona == DateTime.MinValue)
        {
            return;
        }

        try
        {
            await _denunciaStore.AddGestionaUploadHistoryAsync(
                new GestionaUploadHistoryCreateRequest(
                    denuncia.Id_Denuncia,
                    denuncia.Expediente_Gestiona ?? string.Empty,
                    denuncia.ExpedienteGestionaMostrable,
                    denuncia.UltimaSubidaGestionaTipoMostrable,
                    denuncia.UltimoGrupoAsignadoGestionaMostrable,
                    denuncia.FechaSubidaAGestiona,
                    denuncia.NombreDenuncia ?? string.Empty,
                    denuncia.ArchivoElegido ?? string.Empty),
                GetUsername(),
                cancellationToken);
            await _trackingService.MarkReportHandledInGestionaAsync(
                GetUsername(),
                denuncia.Id_Denuncia,
                denuncia.FechaSubidaAGestiona,
                cancellationToken);
        }
        catch (Exception ex)
        {
            _logger.LogWarning(
                ex,
                "No se ha podido registrar el historico de subida a Gestiona para la denuncia {DenunciaId}.",
                denuncia.Id_Denuncia);
        }
    }

    private static DateTime? ToNullableDate(DateTime value)
        => value == DateTime.MinValue ? null : value;

    private static string ResolveFechaHechos(DenunciasGestiona denuncia)
    {
        var literalValue = ResolveReportField(
            denuncia,
            string.Empty,
            "fecha de los hechos que denuncia",
            "fecha de los hechos");

        if (!string.IsNullOrWhiteSpace(literalValue))
        {
            return literalValue;
        }

        return denuncia.Fecha_Hechos == DateTime.MinValue
            ? string.Empty
            : denuncia.Fecha_Hechos.ToString("dd/MM/yyyy", CultureInfo.InvariantCulture);
    }

    private static string ResolveAmbitoCompetencias(DenunciasGestiona denuncia)
    {
        var directValue = ResolveReportField(
            denuncia,
            denuncia.Modalidad_Informacion,
            "ambito de competencias",
            "ambito competencial",
            "ambito",
            "competencias",
            "modalidad de informacion",
            "modalidad informacion");

        if (!string.IsNullOrWhiteSpace(directValue))
        {
            return directValue;
        }

        return FindReportFieldValue(denuncia, normalizedLabel =>
            normalizedLabel.Contains("ambito", StringComparison.Ordinal) &&
            normalizedLabel.Contains("compet", StringComparison.Ordinal));
    }

    private static string ResolveReportField(
        DenunciasGestiona denuncia,
        string? currentValue,
        params string[] candidateLabels)
    {
        if (!string.IsNullOrWhiteSpace(currentValue))
        {
            return currentValue.Trim();
        }

        var labels = candidateLabels
            .Select(NormalizeLabel)
            .Where(label => !string.IsNullOrWhiteSpace(label))
            .ToHashSet(StringComparer.Ordinal);

        if (labels.Count == 0)
        {
            return string.Empty;
        }

        foreach (var field in denuncia.GetCamposFormulario())
        {
            if (!string.IsNullOrWhiteSpace(field.Value) &&
                labels.Contains(NormalizeLabel(field.Label)))
            {
                return field.Value.Trim();
            }
        }

        return string.Empty;
    }

    private static string FindReportFieldValue(
        DenunciasGestiona denuncia,
        Func<string, bool> labelPredicate)
    {
        foreach (var field in denuncia.GetCamposFormulario())
        {
            if (!string.IsNullOrWhiteSpace(field.Value) &&
                labelPredicate(NormalizeLabel(field.Label)))
            {
                return field.Value.Trim();
            }
        }

        return string.Empty;
    }

    private static string JoinDistinct(params string[] values)
    {
        var result = new List<string>();
        var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        foreach (var value in values)
        {
            var trimmed = value?.Trim();
            if (!string.IsNullOrWhiteSpace(trimmed) && seen.Add(trimmed))
            {
                result.Add(trimmed);
            }
        }

        return string.Join("; ", result);
    }

    private static string FirstNonEmpty(params string[] values)
    {
        foreach (var value in values)
        {
            if (!string.IsNullOrWhiteSpace(value))
            {
                return value.Trim();
            }
        }

        return string.Empty;
    }

    private static string NormalizeLabel(string? value)
    {
        if (string.IsNullOrWhiteSpace(value))
        {
            return string.Empty;
        }

        var normalized = value.Normalize(NormalizationForm.FormD);
        var builder = new StringBuilder(normalized.Length);

        foreach (var ch in normalized)
        {
            if (CharUnicodeInfo.GetUnicodeCategory(ch) == UnicodeCategory.NonSpacingMark)
            {
                continue;
            }

            if (ch is '\u00BA' or '\u00AA')
            {
                continue;
            }

            builder.Append(char.IsLetterOrDigit(ch) ? char.ToLowerInvariant(ch) : ' ');
        }

        return string.Join(
            ' ',
            builder
                .ToString()
                .Normalize(NormalizationForm.FormC)
                .Split(' ', StringSplitOptions.RemoveEmptyEntries));
    }

    private static string GetAttachmentContentType(string? fileName)
    {
        return Path.GetExtension(fileName ?? string.Empty).ToLowerInvariant() switch
        {
            ".pdf" => "application/pdf",
            ".txt" => "text/plain",
            ".jpg" or ".jpeg" => "image/jpeg",
            ".png" => "image/png",
            ".gif" => "image/gif",
            ".zip" => "application/zip",
            _ => "application/octet-stream"
        };
    }
}
