using GestionaDenuncias.Shared.Models;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;

namespace ApiDenuncias.Services
{
    public class GestionaService : IGestionaService
    {
        private readonly HttpClient _http;
        private readonly GestionaOptions _opts;
        private readonly ILogger<GestionaService> _logger;

        public GestionaService(
            HttpClient http,
            IOptions<GestionaOptions> optsAccessor,
            ILogger<GestionaService> logger)
        {
            _http = http;
            _opts = optsAccessor.Value;
            _logger = logger;
        }

        // =========================================================
        // Helpers
        // =========================================================

        private static string BuildFilterViewParam(object filterView)
        {
            var json = JsonSerializer.Serialize(filterView);
            var b64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(json));
            return $"filter-view={Uri.EscapeDataString(b64)}";
        }

        private static string? GetLinkHref(JsonElement item, string rel)
        {
            if (!item.TryGetProperty("links", out var links) || links.ValueKind != JsonValueKind.Array)
            {
                return null;
            }

            foreach (var link in links.EnumerateArray())
            {
                if (link.TryGetProperty("rel", out var relProp) &&
                    string.Equals(relProp.GetString(), rel, StringComparison.OrdinalIgnoreCase) &&
                    link.TryGetProperty("href", out var hrefProp) &&
                    hrefProp.ValueKind == JsonValueKind.String)
                {
                    return hrefProp.GetString();
                }
            }

            return null;
        }

        // Reemplaza este helper si quieres controlar la versión en Accept:
        private void AddTokenAndAccept(HttpRequestMessage req, string mediaType, string? version = null)
        {
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            req.Headers.Accept.Clear();
            if (string.IsNullOrWhiteSpace(version))
            {
                req.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(mediaType));
            }
            else
            {
                var mt = new MediaTypeWithQualityHeaderValue(mediaType);
                mt.Parameters.Add(new NameValueHeaderValue("version", version));
                req.Headers.Accept.Add(mt);
            }
        }

        // Helper estilo Postman para /rest/files sin filter-view
        private void AddBasicHeaders(HttpRequestMessage req)
        {
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            req.Headers.Accept.Clear();
            req.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
        }

        private void LogDeprecatedHeaders(HttpResponseMessage response, string operation)
        {
            if (response.Headers.TryGetValues("X-Gestiona-Deprecated", out var deprecated))
            {
                _logger.LogWarning(
                    "Gestiona devolvio X-Gestiona-Deprecated en {Operation}: {Deprecated}",
                    operation,
                    string.Join(" | ", deprecated));
            }
        }



        // =========================================================
        // Expedientes (file)
        // =========================================================

        public async Task<GestionaCreateFileResponse> CreateFileAsync(string subject, string documentSeries, string siaCode)
        {
            _ = subject;
            _ = documentSeries;

            var url = await ResolveExternalProcedureCreateFileUrlAsync(siaCode);
            using var req = new HttpRequestMessage(HttpMethod.Post, url);
            req.Headers.Accept.Clear();
            req.Headers.Accept.Add(
                MediaTypeWithQualityHeaderValue.Parse("application/vnd.gestiona.file-opening+json; version=1"));
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);

            using var resp = await _http.SendAsync(req);
            LogDeprecatedHeaders(resp, "POST create-file");
            var body = await resp.Content.ReadAsStringAsync();
            if (!resp.IsSuccessStatusCode)
                throw new InvalidOperationException($"CreateFileAsync: {(int)resp.StatusCode} {resp.StatusCode}\n{body}");

            using var doc = JsonDocument.Parse(body);
            var fileUrl = GetLinkHref(doc.RootElement, "file")
                ?? throw new InvalidOperationException("CreateFileAsync: Gestiona no ha devuelto link 'file'.");
            var fileOpenUrl = GetLinkHref(doc.RootElement, "file-open")
                ?? throw new InvalidOperationException("CreateFileAsync: Gestiona no ha devuelto link 'file-open'.");

            return new GestionaCreateFileResponse(fileUrl, fileOpenUrl);
        }

        private async Task<string> ResolveExternalProcedureCreateFileUrlAsync(string siaCode)
        {
            var proceduresUrl = await ResolveRootLinkHrefAsync("vnd.gestiona.catalog-2015")
                ?? "/rest/catalog-2015/procedures";
            var procedures = await GetContentArrayAsync(
                proceduresUrl,
                "application/vnd.gestiona.procedures-2015-page+json",
                "GET catalogo de procedimientos Gestiona");

            var procedure = SelectProcedure(procedures, siaCode);
            var externalProceduresUrl = GetLinkHref(procedure, "external-procedures")
                ?? throw new InvalidOperationException(
                    "El procedimiento seleccionado no contiene link 'external-procedures'.");
            var externalProcedures = await GetContentArrayAsync(
                externalProceduresUrl,
                "application/vnd.gestiona.external-procedures-2015-page+json",
                "GET procedimientos externos Gestiona");

            var externalProcedure = SelectExternalProcedure(externalProcedures, procedure, siaCode);
            return GetLinkHref(externalProcedure, "create-file")
                ?? throw new InvalidOperationException(
                    "El procedimiento externo seleccionado no contiene link 'create-file'.");
        }

        private async Task<string?> ResolveRootLinkHrefAsync(string rel)
        {
            using var req = new HttpRequestMessage(HttpMethod.Get, "/rest");
            AddBasicHeaders(req);

            using var resp = await _http.SendAsync(req);
            LogDeprecatedHeaders(resp, "GET /rest");
            var body = await resp.Content.ReadAsStringAsync();
            if (!resp.IsSuccessStatusCode)
            {
                throw new InvalidOperationException($"ResolveRootLinkHrefAsync: {(int)resp.StatusCode} {resp.StatusCode}\n{body}");
            }

            using var doc = JsonDocument.Parse(body);
            return ToAbsoluteGestionaHref(GetLinkHref(doc.RootElement, rel));
        }

        private async Task<List<JsonElement>> GetContentArrayAsync(string url, string accept, string operation)
        {
            using var req = new HttpRequestMessage(HttpMethod.Get, url);
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            req.Headers.Accept.Clear();
            req.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(accept));

            using var resp = await _http.SendAsync(req);
            LogDeprecatedHeaders(resp, operation);
            var body = await resp.Content.ReadAsStringAsync();
            if (!resp.IsSuccessStatusCode)
            {
                throw new InvalidOperationException($"{operation}: {(int)resp.StatusCode} {resp.StatusCode}\n{body}");
            }

            using var doc = JsonDocument.Parse(body);
            var source = doc.RootElement.TryGetProperty("content", out var content) &&
                         content.ValueKind == JsonValueKind.Array
                ? content
                : doc.RootElement;

            if (source.ValueKind != JsonValueKind.Array)
            {
                return [];
            }

            return source.EnumerateArray().Select(item => item.Clone()).ToList();
        }

        private JsonElement SelectProcedure(IReadOnlyList<JsonElement> procedures, string siaCode)
        {
            if (procedures.Count == 0)
            {
                throw new InvalidOperationException("Gestiona no ha devuelto procedimientos en el catalogo.");
            }

            var configuredName = NormalizeKey(_opts.ProcedureName);
            if (!string.IsNullOrWhiteSpace(configuredName))
            {
                var match = procedures.FirstOrDefault(item =>
                    NormalizeKey(GetJsonString(item, "name")).Contains(configuredName, StringComparison.Ordinal) ||
                    NormalizeKey(GetJsonString(item, "title")).Contains(configuredName, StringComparison.Ordinal) ||
                    NormalizeKey(GetJsonString(item, "description")).Contains(configuredName, StringComparison.Ordinal));

                if (match.ValueKind != JsonValueKind.Undefined)
                {
                    return match;
                }

                throw new InvalidOperationException(
                    $"No se ha encontrado en Gestiona el procedimiento configurado '{_opts.ProcedureName}'. Procedimientos disponibles: {DescribeCatalogItems(procedures)}.");
            }

            var normalizedSia = NormalizeKey(siaCode);
            if (!string.IsNullOrWhiteSpace(normalizedSia))
            {
                var match = procedures.FirstOrDefault(item =>
                    NormalizeKey(GetJsonString(item, "sia_code")) == normalizedSia ||
                    NormalizeKey(GetJsonString(item, "code")) == normalizedSia);

                if (match.ValueKind != JsonValueKind.Undefined)
                {
                    return match;
                }
            }

            if (procedures.Count == 1)
            {
                return procedures[0];
            }

            throw new InvalidOperationException(
                "Falta configurar Gestiona:ProcedureName para seleccionar el procedimiento sin usar IDs fijos.");
        }

        private JsonElement SelectExternalProcedure(
            IReadOnlyList<JsonElement> externalProcedures,
            JsonElement selectedProcedure,
            string siaCode)
        {
            var withCreateFile = externalProcedures
                .Where(item => !string.IsNullOrWhiteSpace(GetLinkHref(item, "create-file")))
                .ToList();

            if (withCreateFile.Count == 0)
            {
                throw new InvalidOperationException("El procedimiento seleccionado no tiene procedimientos externos con link 'create-file'.");
            }

            var configuredSia = NormalizeKey(
                string.IsNullOrWhiteSpace(_opts.ExternalProcedureSiaCode)
                    ? siaCode
                    : _opts.ExternalProcedureSiaCode);
            if (!string.IsNullOrWhiteSpace(configuredSia))
            {
                var match = withCreateFile.FirstOrDefault(item =>
                    NormalizeKey(GetJsonString(item, "sia_code")) == configuredSia ||
                    NormalizeKey(GetJsonString(item, "code")) == configuredSia);

                if (match.ValueKind != JsonValueKind.Undefined)
                {
                    return match;
                }
            }

            var configuredName = NormalizeKey(_opts.ExternalProcedureName);
            if (!string.IsNullOrWhiteSpace(configuredName))
            {
                var match = withCreateFile.FirstOrDefault(item =>
                    NormalizeKey(GetJsonString(item, "name")).Contains(configuredName, StringComparison.Ordinal) ||
                    NormalizeKey(GetJsonString(item, "title")).Contains(configuredName, StringComparison.Ordinal));

                if (match.ValueKind != JsonValueKind.Undefined)
                {
                    return match;
                }
            }

            var procedureId = GetJsonString(selectedProcedure, "id");
            if (!string.IsNullOrWhiteSpace(procedureId))
            {
                var sameId = withCreateFile.FirstOrDefault(item =>
                    string.Equals(GetJsonString(item, "id"), procedureId, StringComparison.OrdinalIgnoreCase));
                if (sameId.ValueKind != JsonValueKind.Undefined)
                {
                    return sameId;
                }
            }

            if (withCreateFile.Count == 1)
            {
                return withCreateFile[0];
            }

            throw new InvalidOperationException(
                $"No se puede seleccionar de forma inequivoca el procedimiento externo. Configura Gestiona:ExternalProcedureName o Gestiona:ExternalProcedureSiaCode. Disponibles: {DescribeCatalogItems(withCreateFile)}.");
        }

        private async Task<string> ResolveAssignableGroupHrefAsync(string groupCode)
        {
            if (string.IsNullOrWhiteSpace(groupCode))
            {
                throw new InvalidOperationException("Debe indicarse el codigo funcional del grupo de Gestiona.");
            }

            var groupsUrl = await ResolveRootLinkHrefAsync("vnd.gestiona.files.assignees.groups")
                ?? "/rest/files/assignees/groups";
            var groups = await GetContentArrayAsync(
                groupsUrl,
                "application/vnd.gestiona.groups-page+json",
                "GET grupos asignables Gestiona");

            var normalizedCode = NormalizeKey(groupCode);
            foreach (var group in groups)
            {
                var code = NormalizeKey(GetJsonString(group, "code"));
                var name = NormalizeKey(GetJsonString(group, "name"));
                var title = NormalizeKey(GetJsonString(group, "title"));

                if (code == normalizedCode ||
                    name == normalizedCode ||
                    title == normalizedCode ||
                    name.StartsWith(normalizedCode + " ", StringComparison.Ordinal) ||
                    title.StartsWith(normalizedCode + " ", StringComparison.Ordinal))
                {
                    var href = ToAbsoluteGestionaHref(GetLinkHref(group, "self"));
                    if (!string.IsNullOrWhiteSpace(href))
                    {
                        return href!;
                    }
                }
            }

            throw new InvalidOperationException(
                $"No se ha encontrado en Gestiona el grupo asignable '{groupCode}'. Grupos disponibles: {DescribeCatalogItems(groups)}.");
        }

        private string? ToAbsoluteGestionaHref(string? href)
        {
            if (string.IsNullOrWhiteSpace(href))
            {
                return null;
            }

            if (Uri.TryCreate(href, UriKind.Absolute, out _))
            {
                return href;
            }

            return href.StartsWith("/", StringComparison.Ordinal)
                ? $"{_opts.ApiBase.TrimEnd('/')}{href}"
                : href;
        }

        private static string DescribeCatalogItems(IEnumerable<JsonElement> items)
        {
            var values = items
                .Select(item => FirstNonEmpty(
                    GetJsonString(item, "name"),
                    GetJsonString(item, "title"),
                    GetJsonString(item, "code"),
                    GetJsonString(item, "sia_code"),
                    GetJsonString(item, "id")))
                .Where(value => !string.IsNullOrWhiteSpace(value))
                .Take(10)
                .ToList();

            return values.Count == 0 ? "(sin nombres disponibles)" : string.Join("; ", values);
        }

        public async Task OpenFileAsync(
            string fileUrl,
            string? fileOpenUrl,
            string assignedGroupCode,
            bool confidential,
            string freeTitle)
        {
            if (string.IsNullOrWhiteSpace(fileOpenUrl))
            {
                throw new InvalidOperationException(
                    "OpenFileAsync: falta el link 'file-open' devuelto por Gestiona. No se usa el fallback /open para evitar la ruta deprecated.");
            }

            var url = fileOpenUrl;
            var assignedGroupHref = await ResolveAssignableGroupHrefAsync(assignedGroupCode);
            var managementGroupCode = string.IsNullOrWhiteSpace(_opts.ManagementUnitGroupCode)
                ? "700"
                : _opts.ManagementUnitGroupCode.Trim();
            var managementGroupHref = await ResolveAssignableGroupHrefAsync(managementGroupCode);

            var payload = new
            {
                free_title = freeTitle,
                entry_date = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString(),
                confidential,
                initial_assignation = new[]
                {
                    new { rel = "group", href = assignedGroupHref }
                },
                links = new[]
                {
                    new { rel = "management-unit-group", href = managementGroupHref }
                }
            };

            var json = JsonSerializer.Serialize(payload);
            using var content = new StringContent(json, Encoding.UTF8, "application/vnd.gestiona.file-opening+json");
            content.Headers.ContentType!.Parameters.Add(new NameValueHeaderValue("version", "1"));

            using var req = new HttpRequestMessage(HttpMethod.Post, url) { Content = content };
            AddTokenAndAccept(req, "application/json");

            using var resp = await _http.SendAsync(req);
            LogDeprecatedHeaders(resp, "POST file-open");
            var body = await resp.Content.ReadAsStringAsync();
            if (!resp.IsSuccessStatusCode)
                throw new InvalidOperationException($"OpenFileAsync: {(int)resp.StatusCode} {resp.StatusCode}\n{body}");
        }

        public async Task AssignFileAsync(string fileUrl, string assignedGroupCode)
        {
            if (string.IsNullOrWhiteSpace(fileUrl))
            {
                throw new InvalidOperationException("AssignFileAsync: falta la URL del expediente.");
            }

            if (string.IsNullOrWhiteSpace(assignedGroupCode))
            {
                throw new InvalidOperationException("AssignFileAsync: falta el grupo asignado.");
            }

            var assigneesUrl = await ResolveFileAssigneesUrlAsync(fileUrl);
            var assignedGroupHref = await ResolveAssignableGroupHrefAsync(assignedGroupCode);
            var payload = new
            {
                links = new[]
                {
                    new { rel = "group", href = assignedGroupHref }
                }
            };
            var json = JsonSerializer.Serialize(payload);
            using var content = new StringContent(json, Encoding.UTF8, "application/vnd.gestiona.links");

            using var req = new HttpRequestMessage(HttpMethod.Put, assigneesUrl)
            {
                Content = content
            };
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            req.Headers.Accept.Clear();
            req.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/vnd.gestiona.links"));

            using var resp = await _http.SendAsync(req);
            LogDeprecatedHeaders(resp, "PUT file assignees");
            var body = await resp.Content.ReadAsStringAsync();
            if (!resp.IsSuccessStatusCode)
            {
                throw new InvalidOperationException($"AssignFileAsync: {(int)resp.StatusCode} {resp.StatusCode}\n{body}");
            }
        }

        private async Task<string> ResolveFileAssigneesUrlAsync(string fileUrl)
        {
            var normalizedFileUrl = fileUrl.TrimEnd('/');
            using var req = new HttpRequestMessage(HttpMethod.Get, normalizedFileUrl);
            AddTokenAndAccept(req, "application/vnd.gestiona.file+json", "2");

            using var resp = await _http.SendAsync(req);
            LogDeprecatedHeaders(resp, $"GET {normalizedFileUrl}");
            var body = await resp.Content.ReadAsStringAsync();
            if (!resp.IsSuccessStatusCode)
            {
                throw new InvalidOperationException(
                    $"ResolveFileAssigneesUrlAsync: {(int)resp.StatusCode} {resp.StatusCode}\n{body}");
            }

            using var doc = JsonDocument.Parse(body);
            return ToAbsoluteGestionaHref(GetLinkHref(doc.RootElement, "assignees"))
                   ?? $"{normalizedFileUrl}/assignees";
        }

        public async Task<Guid> CreateFolderAsync(string fileUrl, string folderName)
        {
            var endpoint = $"{fileUrl}/documents-and-folders";
            var payload = new { name = folderName };
            var json = JsonSerializer.Serialize(payload);
            using var content = new StringContent(json, Encoding.UTF8, "application/vnd.gestiona.file-folder+json");
            content.Headers.ContentType!.Parameters.Add(new NameValueHeaderValue("version", "1"));

            using var req = new HttpRequestMessage(HttpMethod.Post, endpoint)
            {
                Content = content
            };
            req.Headers.TryAddWithoutValidation("Prefer", "return=minimal");
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            req.Headers.Accept.Clear();

            using var resp = await _http.SendAsync(req);
            LogDeprecatedHeaders(resp, "POST file-folder");
            var body = await resp.Content.ReadAsStringAsync();
            if (!resp.IsSuccessStatusCode)
                throw new InvalidOperationException($"CreateFolderAsync: {(int)resp.StatusCode} {resp.StatusCode}\n{body}");

            var selfHref = TryGetSelfHref(body) ?? resp.Headers.Location?.ToString();
            if (string.IsNullOrWhiteSpace(selfHref))
            {
                throw new InvalidOperationException("CreateFolderAsync: Gestiona no ha devuelto link self ni Location.");
            }

            return Guid.Parse(selfHref.TrimEnd('/').Split('/').Last());
        }

        public async Task<string> CreateUploadAsync(byte[] contentBytes, string fileName)
        {
            using var createReq = new HttpRequestMessage(HttpMethod.Post, "/rest/uploads");
            createReq.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            createReq.Headers.TryAddWithoutValidation("Prefer", "return=minimal");
            createReq.Headers.Accept.Add(
                MediaTypeWithQualityHeaderValue.Parse("application/vnd.gestiona.upload+json"));

            using var createResp = await _http.SendAsync(createReq);
            LogDeprecatedHeaders(createResp, "POST /rest/uploads");
            var createBody = await createResp.Content.ReadAsStringAsync();
            if (!createResp.IsSuccessStatusCode)
                throw new InvalidOperationException($"CreateUpload (POST): {(int)createResp.StatusCode} {createResp.StatusCode}\n{createBody}");

            var uploadUri = createResp.Headers.Location?.ToString()
                            ?? throw new InvalidOperationException("No se devolvió Location en /rest/uploads");

            string md5Hex;
            using (var md5 = MD5.Create())
            {
                var hash = md5.ComputeHash(contentBytes);
                md5Hex = BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
            }

            using var putReq = new HttpRequestMessage(HttpMethod.Put, uploadUri);
            putReq.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            putReq.Headers.TryAddWithoutValidation("X-Gestiona-Upload-MD5", md5Hex);
            putReq.Headers.TryAddWithoutValidation("Slug", fileName);
            putReq.Headers.TryAddWithoutValidation("Prefer", "return=minimal");
            putReq.Headers.Accept.Add(
                MediaTypeWithQualityHeaderValue.Parse("application/vnd.gestiona.upload+json"));
            putReq.Content = new ByteArrayContent(contentBytes);
            putReq.Content.Headers.ContentType = new MediaTypeHeaderValue("application/pdf");

            using var putResp = await _http.SendAsync(putReq);
            LogDeprecatedHeaders(putResp, "PUT upload content");
            var infoJson = await putResp.Content.ReadAsStringAsync();
            if (!putResp.IsSuccessStatusCode)
                throw new InvalidOperationException($"CreateUpload (PUT): {(int)putResp.StatusCode} {putResp.StatusCode}\n{infoJson}");

            if (!string.IsNullOrWhiteSpace(infoJson))
            {
                using var infoDoc = JsonDocument.Parse(infoJson);
                var status = infoDoc.RootElement.TryGetProperty("status", out var statusProp)
                    ? statusProp.GetString()
                    : "READY";
                if (!string.Equals(status, "READY", StringComparison.OrdinalIgnoreCase))
                    throw new InvalidOperationException($"Upload no READY: {status}");
            }
            return uploadUri;
        }

        public async Task UploadDocumentAsync(string fileUrl, byte[] contentBytes, string fileName)
        {
            var uploadUri = await CreateUploadAsync(contentBytes, fileName);

            var metaPayload = new
            {
                type = "DIGITAL",
                name = fileName,
                description = "Denuncia combinada",
                elaboration_state = "EE01",
                metadata_language = "ES",
                links = new[] { new { rel = "content", href = uploadUri } }
            };

            var metaJson = JsonSerializer.Serialize(metaPayload);
            using var metaContent = new StringContent(metaJson, Encoding.UTF8);
            metaContent.Headers.ContentType =
                MediaTypeHeaderValue.Parse("application/vnd.gestiona.file-document+json; version=4");

            using var metaReq = new HttpRequestMessage(HttpMethod.Post, $"{fileUrl}/documents-and-folders")
            { Content = metaContent };
            metaReq.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            metaReq.Headers.TryAddWithoutValidation("Prefer", "return=minimal");
            metaReq.Headers.Accept.Clear();

            using var metaResp = await _http.SendAsync(metaReq);
            LogDeprecatedHeaders(metaResp, "POST file document");
            var body = await metaResp.Content.ReadAsStringAsync();
            if (!metaResp.IsSuccessStatusCode)
                throw new InvalidOperationException($"UploadDocumentAsync: {(int)metaResp.StatusCode} {metaResp.StatusCode}\n{body}");
        }

        private static string? TryGetSelfHref(string body)
        {
            if (string.IsNullOrWhiteSpace(body))
            {
                return null;
            }

            try
            {
                using var doc = JsonDocument.Parse(body);
                return GetLinkHref(doc.RootElement, "self");
            }
            catch
            {
                return null;
            }
        }

        // =========================
        // TERCEROS
        // =========================

        public async Task<(string Id, string SelfHref)> BuscarTerceroPorNifAsync(string nif)
        {
            var filtro = new
            {
                nif
            };

            using var req = new HttpRequestMessage(HttpMethod.Get, "/rest/thirds");
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            req.Headers.TryAddWithoutValidation("Accept", "application/vnd.gestiona.thirds-page+json");
            req.Content = new StringContent(
                JsonSerializer.Serialize(filtro),
                Encoding.UTF8,
                "application/vnd.gestiona.filter.thirds+json");

            using var resp = await _http.SendAsync(req);
            var body = await resp.Content.ReadAsStringAsync();

            if (resp.StatusCode == System.Net.HttpStatusCode.NoContent ||
                string.IsNullOrWhiteSpace(body))
            {
                return default;
            }

            if (!resp.IsSuccessStatusCode)
            {
                throw new InvalidOperationException(
                    $"Error BuscarTerceroPorNifAsync: {(int)resp.StatusCode} {resp.ReasonPhrase}\n{body}");
            }

            using var doc = JsonDocument.Parse(body);
            if (!doc.RootElement.TryGetProperty("content", out var content) || content.ValueKind != JsonValueKind.Array)
                return default;

            var match = content.EnumerateArray().FirstOrDefault(e =>
                e.TryGetProperty("nif", out var nifProp) && nifProp.GetString() == nif);

            if (match.ValueKind == JsonValueKind.Undefined) return default;

            var id = match.GetProperty("id").GetString()!;
            var self = match.GetProperty("links").EnumerateArray()
                            .First(l => l.GetProperty("rel").GetString() == "self")
                            .GetProperty("href").GetString()!;
            return (id, self);
        }

        public async Task<(string Id, string SelfHref)> CrearTerceroAsync(ThirdPartyIdentityData thirdParty)
        {
            if (thirdParty is null)
                throw new ArgumentNullException(nameof(thirdParty));

            if (string.IsNullOrWhiteSpace(thirdParty.DocumentId))
                throw new ArgumentException("Documento identificativo obligatorio.", nameof(thirdParty));

            if (thirdParty.IsLegalEntity)
            {
                if (string.IsNullOrWhiteSpace(thirdParty.BusinessName))
                    throw new ArgumentException("La razón social es obligatoria para terceros jurídicos.", nameof(thirdParty));
            }
            else
            {
                if (string.IsNullOrWhiteSpace(thirdParty.FirstName))
                    throw new ArgumentException("Nombre obligatorio.", nameof(thirdParty));
                if (string.IsNullOrWhiteSpace(thirdParty.LastName))
                    throw new ArgumentException("Primer apellido obligatorio.", nameof(thirdParty));
            }

            var payload = new Dictionary<string, object?>
            {
                ["nif_country"] = NormalizeCountryCode(
                    string.IsNullOrWhiteSpace(thirdParty.CountryCode)
                        ? thirdParty.Address?.CountryCode
                        : thirdParty.CountryCode),
                ["nif"] = thirdParty.DocumentId.Trim(),
                ["type"] = thirdParty.IsLegalEntity ? "JURIDICAL" : "PHISIC",
                ["notification_channel"] = BuildNotificationChannel(thirdParty)
            };
            var nifType = GuessNifType(thirdParty.DocumentId, thirdParty.IsLegalEntity);
            if (!string.IsNullOrWhiteSpace(nifType))
            {
                payload["nif_type"] = nifType;
            }

            if (thirdParty.IsLegalEntity)
            {
                payload["business_name"] = thirdParty.BusinessName.Trim();
            }
            else
            {
                var (firstSurname, secondSurname) = SplitSurnames(thirdParty.LastName);
                payload["first_name"] = thirdParty.FirstName.Trim();
                payload["first_surname"] = firstSurname;
                if (!string.IsNullOrWhiteSpace(secondSurname))
                    payload["second_surname"] = secondSurname;
            }

            if (!string.IsNullOrWhiteSpace(thirdParty.Email))
                payload["email"] = thirdParty.Email.Trim();

            var jsonOpts = new JsonSerializerOptions
            {
                DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
            };
            var json = JsonSerializer.Serialize(payload, jsonOpts);

            using var content = new StringContent(json, Encoding.UTF8, "application/vnd.gestiona.third+json");
            content.Headers.ContentType!.Parameters.Add(new NameValueHeaderValue("version", "3"));

            using var req = new HttpRequestMessage(HttpMethod.Post, "/rest/thirds")
            {
                Content = content
            };
            req.Headers.Accept.Clear();
            req.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.gestiona.third+json"));
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);

            using var resp = await _http.SendAsync(req);
            var body = await resp.Content.ReadAsStringAsync();

            if (!resp.IsSuccessStatusCode)
                throw new InvalidOperationException(
                    $"Error CrearTerceroAsync: {(int)resp.StatusCode} {resp.ReasonPhrase}\n{body}");

            using var doc = JsonDocument.Parse(body);
            var id = doc.RootElement.GetProperty("id").GetString()!;
            var selfHref = doc.RootElement.GetProperty("links").EnumerateArray()
                .First(l => l.GetProperty("rel").GetString() == "self")
                .GetProperty("href").GetString()!;

            if (thirdParty.Address?.HasAnyValue == true)
            {
                await TryEnsureThirdAddressAsync(selfHref, thirdParty.Address);
            }

            return (id, selfHref);
        }

        public async Task<HashSet<string>> ObtenerTercerosEnlazadosAsync(string fileUrl)
        {
            using var req = new HttpRequestMessage(HttpMethod.Get, $"{fileUrl}/thirdparties");
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            req.Headers.TryAddWithoutValidation("Accept", "*/*");

            using var resp = await _http.SendAsync(req);
            if (resp.StatusCode == System.Net.HttpStatusCode.NoContent)
                return new HashSet<string>(StringComparer.Ordinal);

            var body = await resp.Content.ReadAsStringAsync();
            if (!resp.IsSuccessStatusCode)
                throw new InvalidOperationException(
                    $"Error ObtenerTercerosEnlazadosAsync: {(int)resp.StatusCode} {resp.ReasonPhrase}\n{body}");

            if (string.IsNullOrWhiteSpace(body))
                return new HashSet<string>(StringComparer.Ordinal);

            using var doc = JsonDocument.Parse(body);
            var set = new HashSet<string>(StringComparer.Ordinal);
            if (doc.RootElement.TryGetProperty("content", out var content) && content.ValueKind == JsonValueKind.Array)
            {
                foreach (var item in content.EnumerateArray())
                {
                    if (item.TryGetProperty("links", out var links))  
                    {
                        var third = links.EnumerateArray().FirstOrDefault(l => l.GetProperty("rel").GetString() == "third");
                        if (third.ValueKind != JsonValueKind.Undefined)
                            set.Add(third.GetProperty("href").GetString()!);
                    }
                }
            }
            return set;
        }

        public async Task EnlazarTerceroExistenteAsync(string fileUrl, string thirdSelfHref)
        {
            var payload = new { href = thirdSelfHref };
            var json = JsonSerializer.Serialize(payload);
            using var content = new StringContent(json, Encoding.UTF8);
            content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/vnd.gestiona.third-link+json");

            using var req = new HttpRequestMessage(HttpMethod.Post, $"{fileUrl}/thirdparties");
            req.Content = content;
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            req.Headers.TryAddWithoutValidation("Accept", "*/*");

            var resp = await _http.SendAsync(req);
            var body = await resp.Content.ReadAsStringAsync();

            if (!resp.IsSuccessStatusCode)
                throw new InvalidOperationException($"Error EnlazarTerceroExistenteAsync: {resp.StatusCode}\n{body}");
        }

        public async Task<GestionaEnsureThirdResponse> AsegurarTerceroYEnlazarAsync(string fileUrl, ThirdPartyIdentityData thirdParty)
        {
            if (thirdParty is null)
                throw new ArgumentNullException(nameof(thirdParty));

            thirdParty = NormalizeThirdParty(thirdParty);
            var warnings = new List<string>();

            if (string.IsNullOrWhiteSpace(thirdParty.DocumentId))
            {
                return new GestionaEnsureThirdResponse(true, warnings);
            }

            var encontrado = await BuscarTerceroPorNifAsync(thirdParty.DocumentId);

            if (string.IsNullOrEmpty(encontrado.SelfHref))
            {
                if (!CanCreateThirdParty(thirdParty))
                {
                    _logger.LogWarning(
                        "Se omite la creacion/enlace del tercero en Gestiona para el expediente {FileUrl}: datos identificativos incompletos.",
                        fileUrl);
                    return new GestionaEnsureThirdResponse(true, warnings);
                }

                encontrado = await CrearTerceroAsync(thirdParty);
            }
            else
            {
                warnings.AddRange(await BuildThirdPartyDifferenceWarningsAsync(encontrado.SelfHref, thirdParty));
                if (thirdParty.Address?.HasAnyValue == true)
                {
                    await TryEnsureThirdAddressAsync(encontrado.SelfHref, thirdParty.Address);
                }
            }

            var yaEnlazados = await ObtenerTercerosEnlazadosAsync(fileUrl);
            if (!yaEnlazados.Contains(encontrado.SelfHref))
                await EnlazarTerceroExistenteAsync(fileUrl, encontrado.SelfHref);

            return new GestionaEnsureThirdResponse(true, warnings);
        }

        private async Task<List<string>> BuildThirdPartyDifferenceWarningsAsync(
            string thirdSelfHref,
            ThirdPartyIdentityData thirdParty)
        {
            var warnings = new List<string>();
            var details = await GetThirdPartyDetailsAsync(thirdSelfHref);
            if (details is null)
            {
                return warnings;
            }

            var gestionaType = GetJsonString(details.Value, "type");
            var expectedType = thirdParty.IsLegalEntity ? "JURIDICAL" : "PHISIC";
            AddThirdDifferenceWarning(warnings, "tipo de tercero", expectedType, gestionaType, normalizeAsCode: true);

            if (thirdParty.IsLegalEntity)
            {
                AddThirdDifferenceWarning(
                    warnings,
                    "razon social",
                    thirdParty.BusinessName,
                    GetJsonString(details.Value, "business_name"));
            }
            else
            {
                AddThirdDifferenceWarning(
                    warnings,
                    "nombre",
                    thirdParty.FirstName,
                    GetJsonString(details.Value, "first_name"));

                var gestionaLastName = string.Join(
                    ' ',
                    new[]
                    {
                        GetJsonString(details.Value, "first_surname"),
                        GetJsonString(details.Value, "second_surname")
                    }.Where(value => !string.IsNullOrWhiteSpace(value)));
                AddThirdDifferenceWarning(warnings, "apellidos", thirdParty.LastName, gestionaLastName);
            }

            AddThirdDifferenceWarning(warnings, "email", thirdParty.Email, GetJsonString(details.Value, "email"));
            AddThirdDifferenceWarning(
                warnings,
                "pais del documento",
                NormalizeCountryCode(thirdParty.CountryCode),
                GetJsonString(details.Value, "nif_country"),
                normalizeAsCode: true);
            AddThirdDifferenceWarning(
                warnings,
                "canal de notificacion",
                BuildNotificationChannel(thirdParty),
                GetJsonString(details.Value, "notification_channel"),
                normalizeAsCode: true);

            if (warnings.Count > 0)
            {
                warnings.Insert(
                    0,
                    "El tercero ya existia en Gestiona y no se han sustituido sus datos. Si alguno debe cambiarse, actualizalo manualmente en Gestiona.");
            }

            return warnings;
        }

        private async Task<JsonElement?> GetThirdPartyDetailsAsync(string thirdSelfHref)
        {
            if (string.IsNullOrWhiteSpace(thirdSelfHref))
            {
                return null;
            }

            using var req = new HttpRequestMessage(HttpMethod.Get, thirdSelfHref);
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            req.Headers.Accept.Clear();
            req.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/vnd.gestiona.third+json; version=3"));

            using var resp = await _http.SendAsync(req);
            LogDeprecatedHeaders(resp, "GET third");
            if (!resp.IsSuccessStatusCode)
            {
                return null;
            }

            var body = await resp.Content.ReadAsStringAsync();
            if (string.IsNullOrWhiteSpace(body))
            {
                return null;
            }

            using var doc = JsonDocument.Parse(body);
            return doc.RootElement.Clone();
        }

        private static void AddThirdDifferenceWarning(
            List<string> warnings,
            string fieldName,
            string? complaintValue,
            string? gestionaValue,
            bool normalizeAsCode = false)
        {
            if (string.IsNullOrWhiteSpace(complaintValue))
            {
                return;
            }

            var left = normalizeAsCode
                ? NormalizeKey(complaintValue)
                : NormalizeForComparison(complaintValue);
            var right = normalizeAsCode
                ? NormalizeKey(gestionaValue)
                : NormalizeForComparison(gestionaValue);

            if (string.Equals(left, right, StringComparison.Ordinal))
            {
                return;
            }

            warnings.Add(
                $"El campo {fieldName} no coincide con Gestiona (denuncia: '{FormatWarningValue(complaintValue)}'; Gestiona: '{FormatWarningValue(gestionaValue)}').");
        }

        private static string NormalizeForComparison(string? value)
        {
            return string.Join(
                ' ',
                (value ?? string.Empty)
                    .Trim()
                    .Split(' ', StringSplitOptions.RemoveEmptyEntries))
                .ToUpperInvariant();
        }

        private static string FormatWarningValue(string? value)
        {
            var normalized = string.Join(
                ' ',
                (value ?? string.Empty)
                    .Trim()
                    .Split(' ', StringSplitOptions.RemoveEmptyEntries));
            if (string.IsNullOrWhiteSpace(normalized))
            {
                return "sin dato";
            }

            const int maxLength = 80;
            return normalized.Length <= maxLength
                ? normalized
                : normalized[..maxLength] + "...";
        }

        private static ThirdPartyIdentityData NormalizeThirdParty(ThirdPartyIdentityData thirdParty)
        {
            if (!thirdParty.IsAnonymous)
            {
                var documentId = (thirdParty.DocumentId ?? string.Empty).Trim().ToUpperInvariant();
                var firstName = (thirdParty.FirstName ?? string.Empty).Trim();
                var lastName = (thirdParty.LastName ?? string.Empty).Trim();
                var businessName = (thirdParty.BusinessName ?? string.Empty).Trim();
                var isLegalEntity = thirdParty.IsLegalEntity ||
                                    LooksLikeLegalEntityDocument(documentId) ||
                                    (!string.IsNullOrWhiteSpace(businessName) &&
                                     string.IsNullOrWhiteSpace(firstName));

                return new ThirdPartyIdentityData
                {
                    IsAnonymous = false,
                    IsLegalEntity = isLegalEntity,
                    DocumentId = documentId,
                    FirstName = isLegalEntity ? string.Empty : firstName,
                    LastName = isLegalEntity ? string.Empty : lastName,
                    BusinessName = businessName,
                    Email = (thirdParty.Email ?? string.Empty).Trim(),
                    CountryCode = string.IsNullOrWhiteSpace(thirdParty.CountryCode) ? "ESP" : thirdParty.CountryCode.Trim(),
                    NotificationPreference = thirdParty.NotificationPreference ?? string.Empty,
                    ElectronicNotification = thirdParty.ElectronicNotification ?? string.Empty,
                    PostalNotificationPreference = thirdParty.PostalNotificationPreference ?? string.Empty,
                    Address = thirdParty.Address
                };
            }

            return new ThirdPartyIdentityData
            {
                IsAnonymous = true,
                IsLegalEntity = false,
                DocumentId = "00000000T",
                FirstName = "Anonimo",
                LastName = "-",
                BusinessName = string.Empty,
                Email = string.Empty,
                CountryCode = string.IsNullOrWhiteSpace(thirdParty.CountryCode) ? "ESP" : thirdParty.CountryCode,
                NotificationPreference = thirdParty.NotificationPreference ?? string.Empty,
                ElectronicNotification = thirdParty.ElectronicNotification ?? string.Empty,
                PostalNotificationPreference = thirdParty.PostalNotificationPreference ?? string.Empty,
                Address = null
            };
        }

        private static bool CanCreateThirdParty(ThirdPartyIdentityData thirdParty)
        {
            if (string.IsNullOrWhiteSpace(thirdParty.DocumentId))
            {
                return false;
            }

            return thirdParty.IsLegalEntity
                ? !string.IsNullOrWhiteSpace(thirdParty.BusinessName)
                : !string.IsNullOrWhiteSpace(thirdParty.FirstName) &&
                  !string.IsNullOrWhiteSpace(thirdParty.LastName);
        }

        private static bool LooksLikeLegalEntityDocument(string documentId)
        {
            var value = (documentId ?? string.Empty).Trim().ToUpperInvariant();
            return Regex.IsMatch(value, @"^[ABCDEFGHJKLMNPQRSUVW]\d{7}[A-Z0-9]$");
        }

        // --- CONSULTAS DE EXPEDIENTES (sin recorrer histórico paginado) ---

        private async Task<string> GetFilesAsync(object? filter = null)
        {
            using var req = new HttpRequestMessage(HttpMethod.Get, "/rest/files");
            AddBasicHeaders(req);
            req.Headers.Accept.Clear();
            req.Headers.Accept.Add(
                MediaTypeWithQualityHeaderValue.Parse("application/vnd.gestiona.files-page+json"));

            if (filter is not null)
            {
                var json = JsonSerializer.Serialize(filter);
                req.Content = new StringContent(json, Encoding.UTF8, "application/vnd.gestiona.filter.files+json");
            }

            using var resp = await _http.SendAsync(req);
            LogDeprecatedHeaders(resp, "GET /rest/files");
            if (resp.StatusCode == System.Net.HttpStatusCode.NoContent)
            {
                return "{\"content\":[]}";
            }

            var body = await resp.Content.ReadAsStringAsync();
            if (!resp.IsSuccessStatusCode)
                throw new InvalidOperationException($"GET /rest/files: {(int)resp.StatusCode} {resp.ReasonPhrase}\n{body}");

            if (string.IsNullOrWhiteSpace(body))
            {
                return "{\"content\":[]}";
            }

            return body;
        }

        private static bool TryGetFilesContent(JsonDocument doc, out JsonElement content)
        {
            if (doc.RootElement.TryGetProperty("content", out var contentElement) &&
                contentElement.ValueKind == JsonValueKind.Array)
            {
                content = contentElement;
                return true;
            }

            if (doc.RootElement.ValueKind == JsonValueKind.Array)
            {
                content = doc.RootElement;
                return true;
            }

            content = default;
            return false;
        }

        /// <summary>
        /// Devuelve el JSON crudo de /rest/files acumulando hasta maxPages páginas.
        /// </summary>
        public async Task<string> ListarExpedientesJsonAsyncBasico(int maxPages = 1)
        {
            _ = maxPages;

            var json = await GetFilesAsync();
            using var doc = JsonDocument.Parse(json);

            if (!TryGetFilesContent(doc, out var content))
            {
                return "[]";
            }

            var sb = new StringBuilder();
            sb.Append('[');

            var first = true;
            foreach (var item in content.EnumerateArray())
            {
                if (!first)
                {
                    sb.Append(',');
                }

                sb.Append(item.GetRawText());
                first = false;
            }

            sb.Append(']');
            return sb.ToString();
        }

        /// <summary>
        /// Busca un expediente cuyo asunto sea "Denuncia {idDenuncia}-CD".
        /// </summary>
        public async Task<GestionaExpedienteInfo?> BuscarExpedientePorIdEnAsuntoAsync(int idDenuncia)
        {
            var needle = $"Denuncia {idDenuncia}-CD";

            var json = await GetFilesAsync(new
            {
                subject = needle
            });
            using var doc = JsonDocument.Parse(json);

            if (!TryGetFilesContent(doc, out var content) || content.GetArrayLength() == 0)
            {
                return null;
            }

            foreach (var item in content.EnumerateArray())
            {
                var expediente = BuildExpedienteInfo(item);
                if (expediente is not null)
                {
                    return expediente;
                }
            }

            return null;
        }

        public async Task<GestionaExpedienteInfo?> BuscarExpedientePorCodigoAsync(string codigoExpediente)
        {
            if (string.IsNullOrWhiteSpace(codigoExpediente))
            {
                return null;
            }

            var normalizedCode = codigoExpediente.Trim();
            var json = await GetFilesAsync(new
            {
                code = normalizedCode
            });
            using var doc = JsonDocument.Parse(json);

            if (!TryGetFilesContent(doc, out var content) || content.GetArrayLength() == 0)
            {
                return null;
            }

            GestionaExpedienteInfo? first = null;
            foreach (var item in content.EnumerateArray())
            {
                var expediente = BuildExpedienteInfo(item);
                if (expediente is null)
                {
                    continue;
                }

                if (first is null)
                {
                    first = expediente;
                }

                if (string.Equals(
                    expediente.CodigoExpediente?.Trim(),
                    normalizedCode,
                    StringComparison.OrdinalIgnoreCase))
                {
                    return expediente;
                }
            }

            return first;
        }

        public async Task<GestionaExpedienteInfo?> ObtenerExpedienteAsync(string fileUrl)
        {
            if (string.IsNullOrWhiteSpace(fileUrl))
            {
                return null;
            }

            using var req = new HttpRequestMessage(HttpMethod.Get, fileUrl);
            AddTokenAndAccept(req, "application/vnd.gestiona.file+json", "2");

            using var resp = await _http.SendAsync(req);
            LogDeprecatedHeaders(resp, $"GET {fileUrl}");
            if (resp.StatusCode == System.Net.HttpStatusCode.NoContent ||
                resp.StatusCode == System.Net.HttpStatusCode.NotFound)
            {
                return null;
            }

            var body = await resp.Content.ReadAsStringAsync();
            if (!resp.IsSuccessStatusCode)
            {
                throw new InvalidOperationException(
                    $"ObtenerExpedienteAsync: {(int)resp.StatusCode} {resp.ReasonPhrase}\n{body}");
            }

            if (string.IsNullOrWhiteSpace(body))
            {
                return null;
            }

            using var doc = JsonDocument.Parse(body);
            return BuildExpedienteInfo(doc.RootElement, fileUrl);
        }

        private static GestionaExpedienteInfo? BuildExpedienteInfo(JsonElement item, string? fallbackFileUrl = null)
        {
            var code = GetJsonString(item, "code");
            var freeTitle = GetJsonString(item, "free_title");
            var subject = GetJsonString(item, "subject");
            var selectableTitle = GetJsonString(item, "selectable_title");
            var procedureName = GetJsonString(item, "procedure_name");

            string? fileUrl = fallbackFileUrl;
            if (item.TryGetProperty("links", out var links) && links.ValueKind == JsonValueKind.Array)
            {
                foreach (var link in links.EnumerateArray())
                {
                    if (link.TryGetProperty("rel", out var rel) &&
                        string.Equals(rel.GetString(), "file", StringComparison.OrdinalIgnoreCase) &&
                        link.TryGetProperty("href", out var href) &&
                        href.ValueKind == JsonValueKind.String)
                    {
                        fileUrl = href.GetString();
                        break;
                    }
                }
            }

            if (string.IsNullOrWhiteSpace(fileUrl) &&
                item.TryGetProperty("id", out var idProp) &&
                idProp.ValueKind == JsonValueKind.String)
            {
                fileUrl = $"/rest/files/{idProp.GetString()}";
            }

            if (string.IsNullOrWhiteSpace(fileUrl))
            {
                return null;
            }

            return new GestionaExpedienteInfo
            {
                FileUrl = fileUrl,
                CodigoExpediente = code,
                FreeTitle = FirstNonEmpty(freeTitle, subject, selectableTitle, procedureName)
            };
        }


        public async Task<GestionaAuditInfo?> ObtenerUltimaAuditoriaExpedienteAsync(string fileUrl)
        {
            if (string.IsNullOrWhiteSpace(fileUrl))
            {
                return null;
            }

            var auditUrl = $"{fileUrl.TrimEnd('/')}/audit";
            using var req = new HttpRequestMessage(HttpMethod.Get, auditUrl);
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            req.Headers.Accept.Clear();
            req.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/vnd.gestiona.audit.entries-page"));

            using var resp = await _http.SendAsync(req);
            LogDeprecatedHeaders(resp, $"GET {auditUrl}");
            if (resp.StatusCode == System.Net.HttpStatusCode.NoContent ||
                resp.StatusCode == System.Net.HttpStatusCode.NotFound)
            {
                return null;
            }

            var body = await resp.Content.ReadAsStringAsync();
            if (!resp.IsSuccessStatusCode)
            {
                throw new InvalidOperationException(
                    $"ObtenerUltimaAuditoriaExpedienteAsync: {(int)resp.StatusCode} {resp.ReasonPhrase}\n{body}");
            }

            if (string.IsNullOrWhiteSpace(body))
            {
                return null;
            }

            using var doc = JsonDocument.Parse(body);
            if (!doc.RootElement.TryGetProperty("content", out var content) ||
                content.ValueKind != JsonValueKind.Array ||
                content.GetArrayLength() == 0)
            {
                return null;
            }

            GestionaAuditInfo? latest = null;
            foreach (var item in content.EnumerateArray())
            {
                var entryDate = GetJsonDateTimeOffset(item, "entry_date");
                if (entryDate is null)
                {
                    continue;
                }

                if (latest?.Fecha is not null && entryDate.Value <= latest.Fecha.Value)
                {
                    continue;
                }

                latest = new GestionaAuditInfo
                {
                    Fecha = entryDate,
                    Mensaje = GetJsonString(item, "message")
                };
            }

            return latest;
        }

        public async Task<List<ExpedienteTerceroDto>> ObtenerExpedientesPorTerceroAsync(
            string nif,
            DateTimeOffset? desde = null,
            DateTimeOffset? hasta = null,
            int maxPages = 1,
            int maxResults = 30,
            int maxParallel = 6
        )
        {
            if (string.IsNullOrWhiteSpace(nif))
                throw new ArgumentException("NIF obligatorio.", nameof(nif));

            nif = nif.Trim().ToUpperInvariant();
            _ = maxPages;

            var resultados = new List<ExpedienteTerceroDto>();
            var json = await GetFilesAsync(new
            {
                dni = nif
            });
            using var doc = JsonDocument.Parse(json);

            if (!TryGetFilesContent(doc, out var content) || content.GetArrayLength() == 0)
            {
                return resultados;
            }

            foreach (var item in content.EnumerateArray())
            {
                if (resultados.Count >= maxResults)
                {
                    break;
                }

                var creation = GetJsonDateTimeOffset(item, "creation_date");
                var updated = GetFirstJsonDateTimeOffset(
                    item,
                    "update_date",
                    "updated_at",
                    "modification_date",
                    "modified_at",
                    "last_update",
                    "last_modified");

                if (desde.HasValue && creation.HasValue && creation.Value < desde.Value)
                    continue;

                if (hasta.HasValue && creation.HasValue && creation.Value > hasta.Value)
                    continue;

                string? fileUrl = null;
                if (item.TryGetProperty("links", out var links) && links.ValueKind == JsonValueKind.Array)
                {
                    foreach (var l in links.EnumerateArray())
                    {
                        if (l.TryGetProperty("rel", out var relProp) &&
                            string.Equals(relProp.GetString(), "file", StringComparison.OrdinalIgnoreCase) &&
                            l.TryGetProperty("href", out var hrefProp))
                        {
                            fileUrl = hrefProp.GetString();
                            break;
                        }
                    }
                }

                if (string.IsNullOrWhiteSpace(fileUrl) &&
                    item.TryGetProperty("id", out var idProp) &&
                    idProp.ValueKind == JsonValueKind.String)
                {
                    fileUrl = $"/rest/files/{idProp.GetString()}";
                }

                if (string.IsNullOrWhiteSpace(fileUrl))
                    continue;

                var code = GetJsonString(item, "code");
                var subject = GetJsonString(item, "subject");
                var freeTitle = GetJsonString(item, "free_title");
                var selectableTitle = GetJsonString(item, "selectable_title");
                var procedureName = GetJsonString(item, "procedure_name");
                var asunto = FirstNonEmpty(freeTitle, subject, selectableTitle, procedureName);

                string? state = null;
                if (item.TryGetProperty("state", out var pState) && pState.ValueKind == JsonValueKind.String)
                    state = pState.GetString();
                else if (item.TryGetProperty("status", out var pStatus) && pStatus.ValueKind == JsonValueKind.String)
                    state = pStatus.GetString();

                resultados.Add(new ExpedienteTerceroDto
                {
                    FileUrl = fileUrl,
                    CodigoExpediente = code,
                    Asunto = asunto,
                    Procedimiento = procedureName,
                    FechaCreacion = creation,
                    FechaUltimaModificacion = updated ?? creation,
                    Estado = state
                });
            }

            await EnrichExpedientesWithAuditAsync(resultados, maxParallel);
            return resultados;
        }

        private async Task EnrichExpedientesWithAuditAsync(
            IReadOnlyList<ExpedienteTerceroDto> expedientes,
            int maxParallel)
        {
            if (expedientes.Count == 0)
            {
                return;
            }

            var parallelism = Math.Clamp(maxParallel, 1, 6);
            using var gate = new SemaphoreSlim(parallelism, parallelism);
            var tasks = expedientes
                .Where(expediente => !string.IsNullOrWhiteSpace(expediente.FileUrl))
                .Select(async expediente =>
                {
                    await gate.WaitAsync();
                    try
                    {
                        var audit = await ObtenerUltimaAuditoriaExpedienteAsync(expediente.FileUrl);
                        if (audit is null)
                        {
                            return;
                        }

                        if (audit.Fecha is not null)
                        {
                            expediente.FechaUltimaModificacion = audit.Fecha;
                        }

                        if (!string.IsNullOrWhiteSpace(audit.Mensaje))
                        {
                            expediente.UltimaAuditoriaMensaje = audit.Mensaje;
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.LogWarning(
                            ex,
                            "No se ha podido consultar la auditoria del expediente {FileUrl}.",
                            expediente.FileUrl);
                    }
                    finally
                    {
                        gate.Release();
                    }
                });

            await Task.WhenAll(tasks);
        }

        private async Task TryEnsureThirdAddressAsync(string thirdSelfHref, ThirdPartyAddressData address)
        {
            if (!address.HasAnyValue)
            {
                return;
            }

            if (await ThirdHasAddressesAsync(thirdSelfHref))
            {
                return;
            }

            var addressPayload = await BuildAddressPayloadAsync(address);
            if (addressPayload is null)
            {
                return;
            }

            var payload = new Dictionary<string, object?>
            {
                ["content"] = new[] { addressPayload }
            };

            var json = JsonSerializer.Serialize(payload, new JsonSerializerOptions
            {
                DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
            });

            using var content = new StringContent(json, Encoding.UTF8, "application/vnd.gestiona.third-addresses+json");
            content.Headers.ContentType!.Parameters.Add(new NameValueHeaderValue("version", "2"));

            using var req = new HttpRequestMessage(HttpMethod.Put, $"{thirdSelfHref.TrimEnd('/')}/addresses")
            {
                Content = content
            };
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            req.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

            using var resp = await _http.SendAsync(req);
            var body = await resp.Content.ReadAsStringAsync();
            if (!resp.IsSuccessStatusCode)
                throw new InvalidOperationException($"Error actualizando dirección del tercero: {(int)resp.StatusCode} {resp.ReasonPhrase}\n{body}");
        }

        private async Task<bool> ThirdHasAddressesAsync(string thirdSelfHref)
        {
            using var req = new HttpRequestMessage(HttpMethod.Get, $"{thirdSelfHref.TrimEnd('/')}/addresses");
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            req.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

            using var resp = await _http.SendAsync(req);
            if (resp.StatusCode == System.Net.HttpStatusCode.NoContent ||
                resp.StatusCode == System.Net.HttpStatusCode.NotFound)
            {
                return false;
            }

            resp.EnsureSuccessStatusCode();
            var body = await resp.Content.ReadAsStringAsync();
            using var doc = JsonDocument.Parse(body);
            return doc.RootElement.TryGetProperty("content", out var content) &&
                   content.ValueKind == JsonValueKind.Array &&
                   content.GetArrayLength() > 0;
        }

        private async Task<Dictionary<string, object?>?> BuildAddressPayloadAsync(ThirdPartyAddressData address)
        {
            var provinceCode = await ResolveProvinceCodeAsync(address.Province, NormalizeCountryCode(address.CountryCode));
            var townHref = await ResolveTownHrefAsync(provinceCode, address.Municipality);

            if (string.IsNullOrWhiteSpace(address.Street) &&
                string.IsNullOrWhiteSpace(address.Municipality) &&
                string.IsNullOrWhiteSpace(address.ZipCode))
            {
                return null;
            }

            var payload = new Dictionary<string, object?>
            {
                ["address"] = address.Street,
                ["number"] = address.Number,
                ["floor"] = address.Floor,
                ["door"] = address.Door,
                ["block"] = address.Block,
                ["stair"] = address.Stair,
                ["zipcode"] = address.ZipCode,
                ["country"] = NormalizeCountryCode(address.CountryCode),
                ["province"] = provinceCode,
                ["type_of_road"] = string.IsNullOrWhiteSpace(address.RoadTypeCode) ? "CL" : address.RoadTypeCode,
                ["default_address"] = true,
            };

            if (!string.IsNullOrWhiteSpace(townHref))
            {
                payload["links"] = new[]
                {
                    new Dictionary<string, string>
                    {
                        ["rel"] = "town",
                        ["href"] = townHref
                    }
                };
            }
            else if (!string.IsNullOrWhiteSpace(address.Municipality))
            {
                payload["zone"] = address.Municipality.Trim();
            }

            return payload;
        }

        private async Task<string?> ResolveProvinceCodeAsync(string? province, string countryCode)
        {
            if (string.IsNullOrWhiteSpace(province))
            {
                return null;
            }

            var normalizedSearch = NormalizeKey(province);
            using var req = new HttpRequestMessage(HttpMethod.Get, "/rest/provinces");
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            req.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

            using var resp = await _http.SendAsync(req);
            resp.EnsureSuccessStatusCode();
            var body = await resp.Content.ReadAsStringAsync();
            using var doc = JsonDocument.Parse(body);

            var collection = doc.RootElement.TryGetProperty("content", out var content) &&
                             content.ValueKind == JsonValueKind.Array
                ? content
                : doc.RootElement;

            if (collection.ValueKind != JsonValueKind.Array)
            {
                return province.Trim().ToUpperInvariant();
            }

            foreach (var item in collection.EnumerateArray())
            {
                var code = item.TryGetProperty("code", out var codeProp) ? codeProp.GetString() : null;
                var name = item.TryGetProperty("name", out var nameProp) ? nameProp.GetString() : null;
                var itemCountry = item.TryGetProperty("country_code", out var countryProp) ? countryProp.GetString() : null;

                if (!string.IsNullOrWhiteSpace(itemCountry) &&
                    !string.Equals(NormalizeCountryCode(itemCountry), countryCode, StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }

                if (NormalizeKey(code) == normalizedSearch || NormalizeKey(name) == normalizedSearch)
                {
                    return code ?? province.Trim().ToUpperInvariant();
                }
            }

            return province.Trim().ToUpperInvariant();
        }

        private async Task<string?> ResolveTownHrefAsync(string? provinceCode, string? municipality)
        {
            if (string.IsNullOrWhiteSpace(provinceCode) || string.IsNullOrWhiteSpace(municipality))
            {
                return null;
            }

            using var req = new HttpRequestMessage(HttpMethod.Get, $"/rest/provinces/{Uri.EscapeDataString(provinceCode)}/towns");
            req.Headers.TryAddWithoutValidation("X-Gestiona-Access-Token", _opts.AccessToken);
            req.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

            using var resp = await _http.SendAsync(req);
            if (!resp.IsSuccessStatusCode)
            {
                return null;
            }

            var body = await resp.Content.ReadAsStringAsync();
            using var doc = JsonDocument.Parse(body);

            var collection = doc.RootElement.TryGetProperty("content", out var content) &&
                             content.ValueKind == JsonValueKind.Array
                ? content
                : doc.RootElement;

            if (collection.ValueKind != JsonValueKind.Array)
            {
                return null;
            }

            var normalizedSearch = NormalizeKey(municipality);
            foreach (var item in collection.EnumerateArray())
            {
                var name = item.TryGetProperty("name", out var nameProp) ? nameProp.GetString() : null;
                if (NormalizeKey(name) != normalizedSearch)
                {
                    continue;
                }

                if (!item.TryGetProperty("links", out var links) || links.ValueKind != JsonValueKind.Array)
                {
                    continue;
                }

                foreach (var link in links.EnumerateArray())
                {
                    if (link.TryGetProperty("rel", out var relProp) &&
                        string.Equals(relProp.GetString(), "self", StringComparison.OrdinalIgnoreCase) &&
                        link.TryGetProperty("href", out var hrefProp))
                    {
                        return hrefProp.GetString();
                    }
                }
            }

            return null;
        }

        private static string? GetJsonString(JsonElement item, string propertyName)
        {
            return item.TryGetProperty(propertyName, out var property) &&
                   property.ValueKind == JsonValueKind.String
                ? property.GetString()
                : null;
        }

        private static DateTimeOffset? GetFirstJsonDateTimeOffset(JsonElement item, params string[] propertyNames)
        {
            foreach (var propertyName in propertyNames)
            {
                var value = GetJsonDateTimeOffset(item, propertyName);
                if (value is not null)
                {
                    return value;
                }
            }

            return null;
        }

        private static DateTimeOffset? GetJsonDateTimeOffset(JsonElement item, string propertyName)
        {
            if (!item.TryGetProperty(propertyName, out var property))
            {
                return null;
            }

            if (property.ValueKind == JsonValueKind.Number &&
                property.TryGetInt64(out var timestamp))
            {
                return DateTimeOffset.FromUnixTimeSeconds(timestamp);
            }

            if (property.ValueKind != JsonValueKind.String)
            {
                return null;
            }

            var raw = property.GetString();
            if (string.IsNullOrWhiteSpace(raw))
            {
                return null;
            }

            if (long.TryParse(raw, NumberStyles.Integer, CultureInfo.InvariantCulture, out var timestampString))
            {
                return DateTimeOffset.FromUnixTimeSeconds(timestampString);
            }

            return DateTimeOffset.TryParse(
                raw.Replace("Z", "+00:00", StringComparison.Ordinal),
                CultureInfo.InvariantCulture,
                DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal,
                out var parsed)
                ? parsed
                : null;
        }

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

            return null;
        }

        private static (string FirstSurname, string? SecondSurname) SplitSurnames(string apellidos)
        {
            var parts = (apellidos ?? string.Empty)
                .Split(' ', StringSplitOptions.RemoveEmptyEntries);

            if (parts.Length == 0)
            {
                return ("-", null);
            }

            if (parts.Length == 1)
            {
                return (parts[0], null);
            }

            return (parts[0], string.Join(' ', parts.Skip(1)));
        }

        private static string BuildNotificationChannel(ThirdPartyIdentityData thirdParty)
        {
            var notificationText = NormalizeKey(string.Join(
                ' ',
                thirdParty.NotificationPreference,
                thirdParty.ElectronicNotification,
                thirdParty.PostalNotificationPreference));

            var requestsPostal =
                notificationText.Contains("CORREO POSTAL", StringComparison.Ordinal) ||
                notificationText.Contains("POSTAL", StringComparison.Ordinal);
            var requestsElectronic =
                notificationText.Contains("ELECTRONICA", StringComparison.Ordinal) ||
                notificationText.Contains("TELEMATICA", StringComparison.Ordinal) ||
                notificationText.Contains("ONLINE", StringComparison.Ordinal);

            if (requestsPostal && thirdParty.Address?.HasAnyValue == true && !requestsElectronic)
            {
                return "PAPER";
            }

            return "TELEMATIC";
        }

        private static string? GuessNifType(string nif, bool isLegalEntity)
        {
            var value = (nif ?? string.Empty).Trim().ToUpperInvariant();
            if (isLegalEntity && Regex.IsMatch(value, @"^[A-Z]\d{7}[A-Z0-9]$"))
            {
                return "CIF";
            }

            if (value.StartsWith("X", StringComparison.Ordinal) ||
                value.StartsWith("Y", StringComparison.Ordinal) ||
                value.StartsWith("Z", StringComparison.Ordinal))
            {
                return "NIE";
            }

            if (Regex.IsMatch(value, @"^\d{7,8}[A-Z0-9]$"))
            {
                return "NIF";
            }

            return null;
        }

        private static string NormalizeCountryCode(string? country)
        {
            var value = NormalizeKey(country);
            return value switch
            {
                "" => "ESP",
                "es" or "esp" or "espana" or "españa" or "spain" => "ESP",
                "prt" or "pt" or "portugal" => "PRT",
                _ when country is { Length: >= 3 } => country.Trim().ToUpperInvariant()[..3],
                _ => "ESP",
            };
        }

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

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

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

                builder.Append(char.IsLetterOrDigit(character) ? char.ToUpperInvariant(character) : ' ');
            }

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



    }
}