@page "/Gestiona"
@rendermode InteractiveServer
@attribute [Authorize]
@using GestionaDenunciasAN.Models
@using GestionaDenunciasAN.Services
@using GestionaDenuncias.Shared.Models
@using System.Globalization
@attribute [StreamRendering]
@inject GestionaDenunciasAN.Models.UserState userState
@inject NavigationManager Navigation
@inject IHostEnvironment HostEnvironment
@inject IDenunciaStore DenunciaStore
@inject ApiDenunciasClient ApiDenuncias

<PageTitle>Denuncias Gestión</PageTitle>

<style>
    /* Contenedor para la lista de denuncias */
    .gestion-list {
        margin-top: 20px;
    }
    /* Estilo general para cada card */
    .collapse-card {
        margin-bottom: 1rem;
        border: 1px solid #ccc;
        border-radius: 6px;
        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
        overflow: hidden;
        transition: transform 0.3s ease, box-shadow 0.3s ease;
    }

        .collapse-card:hover {
            transform: scale(1.02);
            box-shadow: 0 4px 8px rgba(0,0,0,0.2);
        }
    /* Aplicar fondo verde a toda la card */
    .Aceptada {
        background-color: #d4edda;
        color: #155724;
    }
        /* Forzar fondo transparente en cabecera y cuerpo para que hereden el color de la card */
        .Aceptada .card-header,
        .Aceptada .card-body {
            background-color: transparent;
        }
    /* Estilos para la cabecera de la card */
    .card-header {
        padding: 0.75rem 1.25rem;
        cursor: pointer;
    }

        .card-header h5 {
            margin: 0;
            font-size: 1.1rem;
        }

    .header-info {
        font-size: 0.9rem;
        margin-top: 0.5rem;
    }

        .header-info span {
            margin-right: 15px;
        }
    /* Estilos para el cuerpo de la card */
    .card-body {
        padding: 1.25rem;
    }
    /* Estilos para los títulos de sección dentro de la card */
    .section-heading {
        text-align: center;
        font-weight: bold;
        text-decoration: underline;
        font-size: 1.1em;
        margin-top: 1rem;
        margin-bottom: 0.5rem;
    }
</style>

<h1>Denuncias en Gestión</h1>

<!-- Campo de búsqueda -->
<input type="text"
       class="form-control"
       placeholder="Buscar denuncias..."
       @bind="busqueda"
       @bind:event="oninput"
       style="margin-bottom:20px;" />

@if (!hasLoaded)
{
    <div class="alert alert-info">Cargando datos...</div>
}
else if ((historialGestiona == null || !historialGestiona.Any()) &&
         (denunciasGestiona == null || !denunciasGestiona.Any()))
{
    <p>No hay denuncias en gestión.</p>
}
else
{
    <div class="gestion-list">
        @foreach (var denuncia in denunciasGestiona.Where(d =>
       string.IsNullOrWhiteSpace(busqueda) ||
       d.Id_Denuncia.ToString().Contains(busqueda) ||
       (!string.IsNullOrEmpty(d.NombreDenuncia) && d.NombreDenuncia.Contains(busqueda, StringComparison.OrdinalIgnoreCase)) ||
       (!string.IsNullOrEmpty(d.ArchivoElegido) && d.ArchivoElegido.Contains(busqueda, StringComparison.OrdinalIgnoreCase)) ||
       (!string.IsNullOrEmpty(d.Estado) && d.Estado.Contains(busqueda, StringComparison.OrdinalIgnoreCase))
        ))
        {
            var collapseId = $"collapse{denuncia.Id_Denuncia}";
            var latestHistory = GetLatestHistory(denuncia.Id_Denuncia);
            var uploadMoment = GetUploadMoment(denuncia, latestHistory);
            <div class="card collapse-card Aceptada">
                <div class="card-header" data-bs-toggle="collapse" data-bs-target="#@collapseId" aria-expanded="false" aria-controls="@collapseId">
                    <h5 class="mb-0">Denuncia ID: @denuncia.Id_Denuncia</h5>
                    <div class="header-info">
                        <span><strong>Asunto:</strong> @GetHeaderSubject(denuncia, latestHistory)</span>
                        @if (!string.IsNullOrWhiteSpace(denuncia.ExpedienteGestionaMostrable))
                        {
                            <span><strong>Nº expediente:</strong> @denuncia.ExpedienteGestionaMostrable</span>
                        }
                        @if (!string.IsNullOrWhiteSpace(GetUploadType(denuncia, latestHistory)))
                        {
                            <span><strong>Última subida:</strong> @GetUploadType(denuncia, latestHistory)</span>
                        }
                        @if (!string.IsNullOrWhiteSpace(GetAssignedGroup(denuncia, latestHistory)))
                        {
                            <span><strong>Grupo asignado:</strong> @FormatGroupCode(GetAssignedGroup(denuncia, latestHistory))</span>
                        }
                        @if (!string.IsNullOrWhiteSpace(GetUploadUser(latestHistory)))
                        {
                            <span><strong>Usuario subida:</strong> @GetUploadUser(latestHistory)</span>
                        }
                        <span><strong>Fecha de Subida:</strong> @FormatUploadDate(uploadMoment)</span>
                        <span><strong>Hora de Subida:</strong> @FormatUploadTime(uploadMoment)</span>
                        @if (!string.IsNullOrWhiteSpace(GetAuditDateText(denuncia)))
                        {
                            <span><strong>Última actividad Gestiona:</strong> @GetAuditDateText(denuncia)</span>
                        }
                    </div>
                </div>
                <div id="@collapseId" class="collapse">
                    <div class="card-body">
                        @if (ficherosAdjuntosPurgados.Contains(denuncia.Id_Denuncia))
                        {
                            <div class="alert alert-warning mt-3">
                                La informacion de detalle de esta denuncia no se puede mostrar porque sus datos estan purgados criptograficamente. Se mantiene visible la cabecera operativa del expediente.
                            </div>
                        }
                        else
                        {
                        <!-- Datos Generales -->
                        <h5 class="section-heading">Datos Generales</h5>
                        <dl class="row">
                            @if (denuncia.Id_RegistroDenuncia != 0)
                            {
                                <dt class="col-sm-3">ID Registro Denuncia</dt>
                                <dd class="col-sm-9">@denuncia.Id_RegistroDenuncia</dd>
                            }
                            @if (denuncia.Id_Denuncia != 0)
                            {
                                <dt class="col-sm-3">ID Denuncia</dt>
                                <dd class="col-sm-9">@denuncia.Id_Denuncia</dd>
                            }
                            @if (denuncia.Fecha != DateTime.MinValue)
                            {
                                <dt class="col-sm-3">Fecha</dt>
                                <dd class="col-sm-9">@denuncia.Fecha.ToString("dd/MM/yyyy HH:mm")</dd>
                            }
                            @if (!string.IsNullOrWhiteSpace(denuncia.ExpedienteGestionaMostrable))
                            {
                                <dt class="col-sm-3">Nº expediente Gestiona</dt>
                                <dd class="col-sm-9">@denuncia.ExpedienteGestionaMostrable</dd>
                            }
                            @if (!string.IsNullOrWhiteSpace(GetAuditDateText(denuncia)))
                            {
                                <dt class="col-sm-3">Última actividad Gestiona</dt>
                                <dd class="col-sm-9">@GetAuditDateText(denuncia)</dd>
                            }
                            @if (!string.IsNullOrWhiteSpace(GetAuditMessage(denuncia)))
                            {
                                <dt class="col-sm-3">Última acción Gestiona</dt>
                                <dd class="col-sm-9">@GetAuditMessage(denuncia)</dd>
                            }
                            @if (denuncia.Id_Persona_Gestiona != 0)
                            {
                                <dt class="col-sm-3">ID Persona Gestión</dt>
                                <dd class="col-sm-9">@denuncia.Id_Persona_Gestiona</dd>
                            }
                            @if (!string.IsNullOrWhiteSpace(denuncia.Etiqueta))
                            {
                                <dt class="col-sm-3">Etiqueta</dt>
                                <dd class="col-sm-9">@denuncia.Etiqueta</dd>
                            }
                        </dl>

                        <!-- Datos del Denunciante -->
                        @if (!string.IsNullOrWhiteSpace(denuncia.Nombre) ||
                       !string.IsNullOrWhiteSpace(denuncia.Apellidos) ||
                       !string.IsNullOrWhiteSpace(denuncia.Sexo) ||
                       !string.IsNullOrWhiteSpace(denuncia.Dni))
                        {
                            <h5 class="section-heading">Datos del Denunciante</h5>
                            <dl class="row">
                                @if (!string.IsNullOrWhiteSpace(denuncia.Nombre))
                                {
                                    <dt class="col-sm-3">Nombre</dt>
                                    <dd class="col-sm-9">@denuncia.Nombre</dd>
                                }
                                @if (!string.IsNullOrWhiteSpace(denuncia.Apellidos))
                                {
                                    <dt class="col-sm-3">Apellidos</dt>
                                    <dd class="col-sm-9">@denuncia.Apellidos</dd>
                                }
                                @if (!string.IsNullOrWhiteSpace(denuncia.Sexo))
                                {
                                    <dt class="col-sm-3">Sexo</dt>

                                    <dd class="col-sm-9">@denuncia.Sexo</dd>
                                }
                                @if (!string.IsNullOrWhiteSpace(denuncia.Dni))
                                {
                                    <dt class="col-sm-3">DNI</dt>
                                    <dd class="col-sm-9">@denuncia.Dni</dd>
                                }
                            </dl>
                        }  

                        <!-- Detalles de la Denuncia -->
                        <h5 class="section-heading">Detalles de la Denuncia</h5>
                        <dl class="row">
                            <dt class="col-sm-3">Asunto</dt>
                            <dd class="col-sm-9">@denuncia.Asunto</dd>
                            <dt class="col-sm-3">A Quien Denuncia</dt>
                            <dd class="col-sm-9">@denuncia.A_Quien_Denuncia</dd>
                            <dt class="col-sm-3">Descripción Denuncia</dt>
                            <dd class="col-sm-9">@denuncia.Descripcion_Denuncia</dd>
                            <dt class="col-sm-3">Denunciado Ante Inst</dt>
                            <dd class="col-sm-9">@denuncia.Denunciado_Ante_Inst</dd>
                            @if (!string.IsNullOrWhiteSpace(denuncia.Modalidad_Informacion))
                            {
                                <dt class="col-sm-3">Modalidad Información</dt>
                                <dd class="col-sm-9">@denuncia.Modalidad_Informacion</dd>
                            }
                            <dt class="col-sm-3">Lugar Hechos</dt>
                            <dd class="col-sm-9">@denuncia.Lugar_Hechos</dd>
                            @if (denuncia.Fecha_Hechos != DateTime.MinValue)
                            {
                                <dt class="col-sm-3">Fecha Hechos</dt>
                                <dd class="col-sm-9">@denuncia.Fecha_Hechos.ToString("dd/MM/yyyy")</dd>
                            }
                        </dl>

                        <!-- Datos de Notificación -->
                        <h5 class="section-heading">Datos de Notificación</h5>
                        <dl class="row">
                            @if (!string.IsNullOrWhiteSpace(denuncia.Notificacion_Preferencia))
                            {
                                <dt class="col-sm-3">Notificación Preferencia</dt>
                                <dd class="col-sm-9">@denuncia.Notificacion_Preferencia</dd>
                            }
                            @if (!string.IsNullOrWhiteSpace(denuncia.Notificacion_Electronica))
                            {
                                <dt class="col-sm-3">Notificación Electrónica</dt>
                                <dd class="col-sm-9">@denuncia.Notificacion_Electronica</dd>
                            }
                            @if (!string.IsNullOrWhiteSpace(denuncia.Correo_Electronico))
                            {
                                <dt class="col-sm-3">Correo Electrónico</dt>
                                <dd class="col-sm-9">@denuncia.Correo_Electronico</dd>
                            }
                            @if (!string.IsNullOrWhiteSpace(denuncia.Notificacion_Sms))
                            {
                                <dt class="col-sm-3">Notificación SMS</dt>
                                <dd class="col-sm-9">@denuncia.Notificacion_Sms</dd>
                            }
                        </dl>

                        <!-- Otros -->
                        <h5 class="section-heading">Otros</h5>
                        <dl class="row">
                            @if (denuncia.Condiciones)
                            {
                                <dt class="col-sm-3">Condiciones</dt>
                                <dd class="col-sm-9">Sí</dd>
                            }
                            @if (!string.IsNullOrWhiteSpace(denuncia.Comments))
                            {
                                <dt class="col-sm-3">Comentarios</dt>
                                <dd class="col-sm-9"><pre>@denuncia.Comments</pre></dd>
                            }
                        </dl>

                        <!-- Ficheros adjuntos -->
                        @if (ficherosAdjuntos.ContainsKey(denuncia.Id_Denuncia) && ficherosAdjuntos[denuncia.Id_Denuncia].Any())
                        {
                            <h5 class="section-heading">Ficheros Adjuntos</h5>
                            <table class="table table-striped">
                                <thead>
                                    <tr>
                                        <th>Nombre</th>
                                        <th>Tamaño (bytes)</th>
                                        <th>Ver</th>
                                    </tr>
                                </thead>
                                <tbody>
                                    @foreach (var fichero in ficherosAdjuntos[denuncia.Id_Denuncia])
                                    {
                                        <tr>
                                            <td>@fichero.NombreFichero</td>
                                            <td>@fichero.Fichero.Length</td>
                                            <td>
                                                <a class="btn btn-primary btn-sm" href="@BuildAttachmentContentUrl(denuncia.Id_Denuncia, fichero.NombreFichero)" target="_blank" rel="noopener">
                                                    <i class="bi bi-eye"></i> Ver
                                                </a>
                                            </td>
                                        </tr>
                                    }
                                </tbody>
                            </table>
                        }
                        }
                    </div>
                </div>
            </div>
        }
        @foreach (var item in GetHeaderOnlyHistoryItems())
        {
            var uploadMoment = item.UploadedAtUtc;
            <div class="card collapse-card Aceptada">
                <div class="card-header">
                    <h5 class="mb-0">Denuncia ID: @item.DenunciaId</h5>
                    <div class="header-info">
                        <span><strong>Asunto:</strong> @DisplayOrDash(item.Asunto)</span>
                        <span><strong>Nº expediente:</strong> @DisplayOrDash(item.CodigoExpedienteGestiona)</span>
                        <span><strong>Última subida:</strong> @DisplayOrDash(item.TipoSubida)</span>
                        <span><strong>Grupo asignado:</strong> @DisplayOrDash(FormatGroupCode(item.GrupoAsignado))</span>
                        @if (!string.IsNullOrWhiteSpace(GetUploadUser(item)))
                        {
                            <span><strong>Usuario subida:</strong> @GetUploadUser(item)</span>
                        }
                        <span><strong>Fecha de Subida:</strong> @FormatUploadDate(uploadMoment)</span>
                        <span><strong>Hora de Subida:</strong> @FormatUploadTime(uploadMoment)</span>
                        <span class="text-muted">Detalle no disponible por purga criptográfica.</span>
                    </div>
                </div>
            </div>
        }
    </div>
}

<script>
    function createObjectUrl(base64, contentType) {
        const binaryString = window.atob(base64);
        const len = binaryString.length;
        const bytes = new Uint8Array(len);
        for (let i = 0; i < len; i++) {
            bytes[i] = binaryString.charCodeAt(i);
        }
        const blob = new Blob([bytes], { type: contentType });
        return URL.createObjectURL(blob);
    }
    function openFile(event, base64, contentType) {
        event.preventDefault();
        event.stopPropagation();
        const objectUrl = createObjectUrl(base64, contentType);
        window.open(objectUrl, '_blank');
    }
</script>

@code {
    private List<DenunciasGestiona> denunciasGestiona = new();
    private List<GestionaUploadHistoryEntry> historialGestiona = new();
    private Dictionary<int, List<FicherosDenuncias>> ficherosAdjuntos = new();
    private HashSet<int> ficherosAdjuntosPurgados = new();
    private Dictionary<int, GestionaAuditInfo> auditoriasGestiona = new();

    // Variable para la búsqueda
    private string busqueda = "";

    private bool hasLoaded = false;

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if (firstRender)
        {
            await CargarHistorialGestionaAsync();
            await CargarGestionaAsync();
            await CargarFicherosAdjuntosAsync(denunciasGestiona.Select(d => d.Id_Denuncia));
            await CargarAuditoriasGestionaAsync(denunciasGestiona);
            hasLoaded = true;
            StateHasChanged();
        }
    }

    private async Task CargarGestionaAsync()
    {
        var todas = await CargarDenunciasJsonAsync();
        denunciasGestiona = todas
            .Where(d => d.EnGestiona)
            .ToList();
    }

    private async Task CargarHistorialGestionaAsync()
    {
        try
        {
            historialGestiona = await ApiDenuncias.GetGestionaUploadHistoryAsync();
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"No se ha podido cargar el histórico de subidas a Gestiona: {ex}");
            historialGestiona = new List<GestionaUploadHistoryEntry>();
        }
    }
    private async Task<List<DenunciasGestiona>> CargarDenunciasJsonAsync()
    {
        return await DenunciaStore.GetDenunciasByScopeAsync(DenunciaListScope.InGestiona);
    }

    private async Task CargarAuditoriasGestionaAsync(IEnumerable<DenunciasGestiona> denuncias)
    {
        auditoriasGestiona.Clear();
        var items = denuncias
            .Where(d => d.Id_Denuncia > 0 && !string.IsNullOrWhiteSpace(d.Expediente_Gestiona) && !string.Equals(d.Expediente_Gestiona, "Pendiente", StringComparison.OrdinalIgnoreCase))
            .DistinctBy(d => d.Id_Denuncia)
            .ToList();

        using var gate = new System.Threading.SemaphoreSlim(4, 4);
        var tasks = items.Select(async denuncia =>
        {
            await gate.WaitAsync();
            try
            {
                var audit = await ApiDenuncias.GetGestionaFileLatestAuditAsync(denuncia.Expediente_Gestiona);
                if (audit?.Fecha is null && string.IsNullOrWhiteSpace(audit?.Mensaje))
                {
                    return;
                }

                lock (auditoriasGestiona)
                {
                    auditoriasGestiona[denuncia.Id_Denuncia] = audit;
                }
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine($"No se ha podido cargar la auditoría de Gestiona para la denuncia {denuncia.Id_Denuncia}: {ex}");
            }
            finally
            {
                gate.Release();
            }
        });

        await Task.WhenAll(tasks);
    }

    private string GetAuditDateText(DenunciasGestiona denuncia)
    {
        return auditoriasGestiona.TryGetValue(denuncia.Id_Denuncia, out var audit) && audit.Fecha is not null
            ? audit.Fecha.Value.ToLocalTime().ToString("dd/MM/yyyy HH:mm")
            : string.Empty;
    }

    private string GetAuditMessage(DenunciasGestiona denuncia)
    {
        return auditoriasGestiona.TryGetValue(denuncia.Id_Denuncia, out var audit)
            ? audit.Mensaje ?? string.Empty
            : string.Empty;
    }

    private GestionaUploadHistoryEntry? GetLatestHistory(int denunciaId)
    {
        return historialGestiona
            .Where(item => item.DenunciaId == denunciaId)
            .OrderByDescending(item => item.UploadedAtUtc)
            .ThenByDescending(item => item.Id)
            .FirstOrDefault();
    }

    private IEnumerable<GestionaUploadHistoryEntry> GetHeaderOnlyHistoryItems()
    {
        var visibleComplaintIds = denunciasGestiona
            .Select(denuncia => denuncia.Id_Denuncia)
            .ToHashSet();

        return historialGestiona
            .Where(item => !visibleComplaintIds.Contains(item.DenunciaId))
            .Where(MatchesHistorySearch)
            .GroupBy(item => item.DenunciaId)
            .Select(group => group
                .OrderByDescending(item => item.UploadedAtUtc)
                .ThenByDescending(item => item.Id)
                .First())
            .OrderByDescending(item => item.UploadedAtUtc)
            .ThenByDescending(item => item.Id);
    }

    private static DateTime GetUploadMoment(DenunciasGestiona denuncia, GestionaUploadHistoryEntry? history)
    {
        if (history?.UploadedAtUtc is DateTime historyDate && historyDate != DateTime.MinValue)
        {
            return historyDate;
        }

        return denuncia.FechaSubidaAGestiona;
    }

    private static string GetHeaderSubject(DenunciasGestiona denuncia, GestionaUploadHistoryEntry? history)
    {
        return !string.IsNullOrWhiteSpace(history?.Asunto)
            ? history.Asunto.Trim()
            : DisplayOrDash(denuncia.NombreDenuncia);
    }

    private static string GetUploadType(DenunciasGestiona denuncia, GestionaUploadHistoryEntry? history)
    {
        return !string.IsNullOrWhiteSpace(history?.TipoSubida)
            ? history.TipoSubida.Trim()
            : denuncia.UltimaSubidaGestionaTipoMostrable;
    }

    private static string GetAssignedGroup(DenunciasGestiona denuncia, GestionaUploadHistoryEntry? history)
    {
        return !string.IsNullOrWhiteSpace(history?.GrupoAsignado)
            ? history.GrupoAsignado.Trim()
            : denuncia.UltimoGrupoAsignadoGestionaMostrable;
    }

    private static string GetUploadUser(GestionaUploadHistoryEntry? history)
    {
        return string.IsNullOrWhiteSpace(history?.Usuario) ||
               string.Equals(history.Usuario, "No registrado", StringComparison.OrdinalIgnoreCase)
            ? string.Empty
            : history.Usuario.Trim();
    }

    private static string FormatUploadDate(DateTime value)
    {
        var local = ToLocalUploadTime(value);
        return local == DateTime.MinValue ? "-" : local.ToString("dd/MM/yyyy");
    }

    private static string FormatUploadTime(DateTime value)
    {
        var local = ToLocalUploadTime(value);
        return local == DateTime.MinValue ? "-" : local.ToString("HH:mm");
    }

    private static DateTime ToLocalUploadTime(DateTime value)
    {
        return value == DateTime.MinValue
            ? DateTime.MinValue
            : DateTime.SpecifyKind(value, DateTimeKind.Utc).ToLocalTime();
    }

    private bool MatchesHistorySearch(GestionaUploadHistoryEntry item)
    {
        if (string.IsNullOrWhiteSpace(busqueda))
        {
            return true;
        }

        var search = busqueda.Trim();
        return item.DenunciaId.ToString(CultureInfo.InvariantCulture).Contains(search, StringComparison.OrdinalIgnoreCase) ||
               (item.CodigoExpedienteGestiona ?? string.Empty).Contains(search, StringComparison.OrdinalIgnoreCase) ||
               (item.TipoSubida ?? string.Empty).Contains(search, StringComparison.OrdinalIgnoreCase) ||
               (item.GrupoAsignado ?? string.Empty).Contains(search, StringComparison.OrdinalIgnoreCase) ||
               (item.Usuario ?? string.Empty).Contains(search, StringComparison.OrdinalIgnoreCase) ||
               (item.Asunto ?? string.Empty).Contains(search, StringComparison.OrdinalIgnoreCase) ||
               (item.Documentos ?? string.Empty).Contains(search, StringComparison.OrdinalIgnoreCase);
    }

    private static string FormatHistoryDate(DateTime value)
    {
        var local = ToLocalUploadTime(value);
        return local == DateTime.MinValue
            ? "-"
            : local.ToString("dd/MM/yyyy HH:mm");
    }

    private static string DisplayOrDash(string? value)
        => string.IsNullOrWhiteSpace(value) ? "-" : value.Trim();

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

        var trimmed = value.Trim();
        var code = new string(trimmed.TakeWhile(char.IsDigit).ToArray());
        return string.IsNullOrWhiteSpace(code) ? trimmed : code;
    }
    private async Task CargarFicherosAdjuntosAsync(IEnumerable<int> denunciaIds)
    {
        ficherosAdjuntos.Clear();
        ficherosAdjuntosPurgados.Clear();
        foreach (var denunciaId in denunciaIds.Where(id => id > 0).Distinct())
        {
            try
            {
                var ficheros = await DenunciaStore.GetFicherosByDenunciaAsync(denunciaId);
                if (ficheros.Count > 0)
                {
                    ficherosAdjuntos[denunciaId] = ficheros;
                }
            }
            catch (InvalidOperationException ex) when (IsPurgedDataError(ex))
            {
                ficherosAdjuntosPurgados.Add(denunciaId);
                Console.Error.WriteLine($"No se han podido cargar los adjuntos de la denuncia {denunciaId} porque estan purgados: {ex.Message}");
            }
        }
    }

    private static bool IsPurgedDataError(Exception ex)
    {
        var message = ex.Message ?? string.Empty;
        return message.Contains("datos purgados", StringComparison.OrdinalIgnoreCase) ||
               message.Contains("Denuncia no disponible", StringComparison.OrdinalIgnoreCase);
    }

    private static string BuildAttachmentContentUrl(int denunciaId, string? fileName)
    {
        return $"/api/denuncias/{denunciaId}/ficheros/content?fileName={Uri.EscapeDataString(fileName ?? string.Empty)}";
    }
    private string GetContentType(string fileName)
    { 
        var ext = Path.GetExtension(fileName).ToLowerInvariant();
        return ext switch
        {
            ".jpg" or ".jpeg" => "image/jpeg",
            ".png" => "image/png",
            ".gif" => "image/gif",
            ".pdf" => "application/pdf",
            ".txt" => "text/plain",
            _ => "application/octet-stream",
        };
    }

}

