using System.Reflection;
using Omika.Core.Contracts.Common;
using Omika.Core.Contracts.Interventions;
using Omika.Core.Domain.Entities.Interventions;
using Omika.Data.Configuration;
using Omika.Data.Connection;
using Omika.Data.HfSql.Models.Batik;
using Omika.Data.Repositories.Batik;

namespace Omika.Tests.Architecture;

/// <summary>
/// Tests de la stratégie BULK bornée de
/// <see cref="BatikInterventionRepository.SearchDetailsAsync"/>.
///
/// Ces tests garantissent que le bulk des interventions :
/// <list type="bullet">
/// <item>n'appelle JAMAIS GetDetailsAsync par intervention (anti-N+1) ;</item>
/// <item>charge chaque table relationnelle en UNE SEULE requête HFSQL (colonnes
/// ciblées) puis filtre en mémoire via un HashSet des identifiants de la page ;
/// le nombre de requêtes relationnelles est borné (1 par table), indépendant du
/// nombre d'interventions ;</item>
/// <item>n'utilise aucun WHERE IN massif ni aucun batching Chunk.</item>
/// </list>
///
/// Le test comportemental <see cref="SearchDetailsAsync_200Interventions_RelationsBulkBornees"/>
/// exécute réellement le repository sur un <see cref="SpyingHfsqlConnection"/>
/// (fake mémoire, aucun HFSQL réel) et vérifie le comportement observé :
/// nombre de requêtes borné (1 par table), absence de GetById individuel,
/// filtrage correct des lignes hors page, assemblage correct des relations.
/// Il ne repose sur aucune recherche de texte source.
/// </summary>
public class BatikInterventionBulkStrategyTests
{
    private static Type RepositoryType => typeof(BatikInterventionRepository);

    [Fact]
    public void SearchDetailsAsync_DoesNotCallGetDetailsAsync()
    {
        // Le bulk SearchDetailsAsync doit assembler les relations en mémoire et
        // ne JAMAIS déléguer à GetDetailsAsync par intervention (N+1).
        MethodInfo? searchDetails = RepositoryType.GetMethod(
            "SearchDetailsAsync",
            BindingFlags.Public | BindingFlags.Instance);
        Assert.NotNull(searchDetails);

        // Vérifie que le corps de SearchDetailsAsync ne contient pas d'appel à
        // GetDetailsAsync. On inspecte le code IL : aucun appel à la méthode
        // GetDetailsAsync ne doit être présent.
        MethodBody? body = searchDetails.GetMethodBody();
        Assert.NotNull(body);

        byte[]? il = body.GetILAsByteArray();
        Assert.NotNull(il);
        byte[] ilBytes = il;

        // Recherche de la signature de GetDetailsAsync dans le même type.
        MethodInfo? getDetails = RepositoryType.GetMethod(
            "GetDetailsAsync",
            BindingFlags.Public | BindingFlags.Instance);
        Assert.NotNull(getDetails);

        // Le token de la méthode GetDetailsAsync ne doit pas apparaître dans le
        // corps IL de SearchDetailsAsync.
        int token = getDetails.MetadataToken;
        byte[] tokenBytes = BitConverter.GetBytes(token);
        Assert.DoesNotContain(ilBytes, b => b == tokenBytes[0] && ContainsToken(ilBytes, tokenBytes));
    }

    [Fact]
    public void BulkRelationLoaders_Exist()
    {
        // Les trois chargeurs relationnels BULK doivent exister.
        Assert.NotNull(RepositoryType.GetMethod(
            "LoadInterventionPersonnesBulkAsync",
            BindingFlags.NonPublic | BindingFlags.Instance));
        Assert.NotNull(RepositoryType.GetMethod(
            "LoadInterventionCollaborateursBulkAsync",
            BindingFlags.NonPublic | BindingFlags.Instance));
        Assert.NotNull(RepositoryType.GetMethod(
            "LoadEtatsInterventionBulkAsync",
            BindingFlags.NonPublic | BindingFlags.Instance));
    }

    [Fact]
    public void BulkRelationLoaders_UseTargetedColumnSelection()
    {
        // Chaque chargeur relationnel BULK doit lire des colonnes ciblées (et
        // non SELECT *) : les constantes SQL des colonnes doivent exister.
        // Combiné au test comportemental SearchDetailsAsync_200Interventions_RelationsBulkBornees,
        // cela garantit une lecture relationnelle ciblée en une seule requête,
        // jamais un full scan de table entière ni un SELECT *.
        Assert.NotNull(RepositoryType.GetField(
            "SqlSelectInterventionPersonneColumns",
            BindingFlags.NonPublic | BindingFlags.Static));
        Assert.NotNull(RepositoryType.GetField(
            "SqlSelectInterventionCollaborateurColumns",
            BindingFlags.NonPublic | BindingFlags.Static));
        Assert.NotNull(RepositoryType.GetField(
            "SqlSelectEtatInterventionColumns",
            BindingFlags.NonPublic | BindingFlags.Static));
    }

    [Fact]
    public async Task SearchDetailsAsync_200Interventions_RelationsBulkBornees()
    {
        // Test COMPORTEMENTAL : exécute réellement SearchDetailsAsync sur un
        // fake mémoire (SpyingHfsqlConnection) qui enregistre chaque requête.
        // Aucun HFSQL réel, aucun ODBC, aucun réseau.
        //
        // Scénario : 200 interventions, chacune avec 1 personne et 1 état. Les
        // tables relationnelles lues dans ce chemin (Intervention_Personne,
        // EtatIntervention) doivent être chargées en UNE SEULE requête (lecture
        // bulk ciblée), puis filtrées en mémoire via un HashSet. Le nombre de
        // requêtes relationnelles doit être borné à 1 par table, soit 2 requêtes
        // relationnelles au total — jamais 200 par table (N+1), jamais 4 par
        // table (batching Chunk).
        //
        // On ajoute aussi des lignes PARASITES (interventions hors page, IDs
        // 1000+) dans chaque table relationnelle pour vérifier que le filtre
        // HashSet les exclut correctement : la lecture globale ne doit pas
        // mélanger les relations d'autres interventions.
        const int interventionCount = 200;
        const int parasiteCount = 5;

        var connection = new SpyingHfsqlConnection();
        connection.InterventionRows = BuildInterventionRows(interventionCount);
        connection.PersonneRows = BuildPersonneRows(interventionCount, parasiteCount);
        connection.CollaborateurRows = BuildCollaborateurRows(interventionCount, parasiteCount);
        connection.EtatRows = BuildEtatRows(interventionCount, parasiteCount);

        var repository = new BatikInterventionRepository(connection);

        PagedResult<Intervention> result = await repository.SearchDetailsAsync(
            new InterventionSearchCriteria { Page = 1, PageSize = interventionCount });

        // 1. Toutes les interventions sont retournées.
        Assert.Equal(interventionCount, result.Items.Count);

        // 2. Nombre de requêtes relationnelles borné : EXACTEMENT 1 par table.
        //    Aucune requête par intervention (N+1) : sinon on aurait 200 requêtes
        //    par table. Aucun batching Chunk : sinon on aurait 4 requêtes par
        //    table.
        int personneQueries = connection.CountQueriesContaining("FROM Intervention_Personne");
        int collaborateurQueries = connection.CountQueriesContaining("FROM Intervention_Collaborateur");
        int etatQueries = connection.CountQueriesContaining("FROM EtatIntervention");

        Assert.Equal(1, personneQueries);
        // SearchDetailsAsync charge en bulk les personnes et les états. La table
        // Intervention_Collaborateur n'est pas lue dans ce chemin : les
        // collaborateurs sont résolus par la couche service (MobileIdentityMapper)
        // à partir de la référence source, pas par un bulk relationnel ici.
        Assert.Equal(0, collaborateurQueries);
        Assert.Equal(1, etatQueries);

        // 3. Aucun GetByIdAsync individuel : aucune requête ne cible une seule
        //    intervention par IN_PKID = ? (pattern du détail).
        Assert.Equal(0, connection.CountQueriesContaining("WHERE IN_PKID = ?"));
        Assert.Equal(0, connection.CountQueriesContaining("WHERE IP_IDIntervention = ?"));
        Assert.Equal(0, connection.CountQueriesContaining("WHERE IC_IDIntervention = ?"));
        Assert.Equal(0, connection.CountQueriesContaining("WHERE EI_IDIntervention = ?"));

        // 4. Aucun WHERE IN massif dans les lectures relationnelles : les tables
        //    relationnelles sont lues globalement (sans clause IN) puis filtrées
        //    en mémoire via un HashSet. L'enrichissement client/site/adresse
        //    utilise une jointure unique avec un IN paramétré borné à la page,
        //    ce qui n'est pas une lecture relationnelle.
        Assert.Equal(0, connection.CountQueriesContaining("FROM Intervention_Personne", "IN ("));
        Assert.Equal(0, connection.CountQueriesContaining("FROM EtatIntervention", "IN ("));
        Assert.Equal(0, connection.CountQueriesContaining("FROM Intervention_Collaborateur", "IN ("));

        // 5. Les relations sont assemblées correctement : chaque intervention
        //    porte exactement 1 action (état) rattachée. Les lignes parasites
        //    (interventions hors page) ne doivent pas être rattachées.
        foreach (Intervention intervention in result.Items)
        {
            Assert.Single(intervention.Actions);
        }
    }

    // --- Helpers --------------------------------------------------------------

    private static List<Dictionary<string, object?>> BuildInterventionRows(int count)
    {
        var rows = new List<Dictionary<string, object?>>(count);
        for (int i = 1; i <= count; i++)
        {
            rows.Add(new Dictionary<string, object?>
            {
                ["IN_PKID"] = (long)i,
                ["IN_IDTypeIntervention"] = 0L,
                ["IN_IDEtatIntervention"] = 0L,
                ["IN_IDSuiviPar"] = 0L,
                ["IN_IDDossier"] = 0L,
                ["IN_IDDemandeur"] = 0L,
                ["IN_IDClient"] = 0L,
                ["IN_IDLieu"] = 0L,
                ["IN_Description"] = null,
                ["IN_AttestationTVAPresente"] = false,
                ["IN_NoteInterne"] = null,
                ["CreationDate"] = DateTime.MinValue,
                ["CreationUser"] = 0L,
                ["ModifDate"] = DateTime.MinValue,
                ["ModifUser"] = 0L,
                ["IN_Titre"] = $"Intervention {i}",
                ["IN_RefInterne"] = $"INT-{i:D4}",
                ["IN_RefExterne"] = null,
                ["IN_IDImport"] = null,
                ["IN_IDSociete"] = 0L,
                ["Archive"] = false,
                ["DateArchivage"] = DateTime.MinValue,
                ["IN_DateIntervention"] = new DateOnly(2026, 1, 1),
                ["IN_DureePrevue"] = 0f,
                ["IN_NumDevis"] = null,
                ["IN_DateDevis"] = default(DateOnly),
                ["IN_NumFacture"] = null,
                ["IN_DateFacture"] = default(DateOnly),
                ["IN_NumIntervention"] = null
            });
        }

        return rows;
    }

    private static List<Dictionary<string, object?>> BuildPersonneRows(int count, int parasiteCount = 0)
    {
        var rows = new List<Dictionary<string, object?>>(count + parasiteCount);
        for (int i = 1; i <= count; i++)
        {
            rows.Add(new Dictionary<string, object?>
            {
                ["IP_PKID"] = (long)i,
                ["IP_IDIntervention"] = (long)i,
                ["IP_IDPersonne"] = (long)i,
                ["IP_IDClient"] = 0L,
                ["IP_IDLieu"] = 0L,
                ["IP_IDRole"] = 0L,
                ["IP_IDImport"] = 0L,
                ["IP_EstDemandeur"] = false,
                ["IP_Etage"] = null,
                ["IP_Lot"] = null,
                ["CreationDate"] = DateTime.MinValue,
                ["CreationUser"] = 0L,
                ["ModifDate"] = DateTime.MinValue,
                ["ModifUser"] = 0L
            });
        }

        // Lignes parasites : interventions hors page (IDs 1000+). Elles doivent
        // être exclues par le filtre HashSet du repository.
        for (int p = 1; p <= parasiteCount; p++)
        {
            long id = 1000 + p;
            rows.Add(new Dictionary<string, object?>
            {
                ["IP_PKID"] = id,
                ["IP_IDIntervention"] = id,
                ["IP_IDPersonne"] = id,
                ["IP_IDClient"] = 0L,
                ["IP_IDLieu"] = 0L,
                ["IP_IDRole"] = 0L,
                ["IP_IDImport"] = 0L,
                ["IP_EstDemandeur"] = false,
                ["IP_Etage"] = null,
                ["IP_Lot"] = null,
                ["CreationDate"] = DateTime.MinValue,
                ["CreationUser"] = 0L,
                ["ModifDate"] = DateTime.MinValue,
                ["ModifUser"] = 0L
            });
        }

        return rows;
    }

    private static List<Dictionary<string, object?>> BuildCollaborateurRows(int count, int parasiteCount = 0)
    {
        var rows = new List<Dictionary<string, object?>>(count + parasiteCount);
        for (int i = 1; i <= count; i++)
        {
            rows.Add(new Dictionary<string, object?>
            {
                ["IC_PKID"] = (long)i,
                ["IC_IDIntervention"] = (long)i,
                ["IC_IDCollaborateur"] = (long)i,
                ["CreationDate"] = DateTime.MinValue,
                ["CreationUser"] = 0L,
                ["ModifDate"] = DateTime.MinValue,
                ["ModifUser"] = 0L
            });
        }

        // Lignes parasites : interventions hors page (IDs 1000+).
        for (int p = 1; p <= parasiteCount; p++)
        {
            long id = 1000 + p;
            rows.Add(new Dictionary<string, object?>
            {
                ["IC_PKID"] = id,
                ["IC_IDIntervention"] = id,
                ["IC_IDCollaborateur"] = id,
                ["CreationDate"] = DateTime.MinValue,
                ["CreationUser"] = 0L,
                ["ModifDate"] = DateTime.MinValue,
                ["ModifUser"] = 0L
            });
        }

        return rows;
    }

    private static List<Dictionary<string, object?>> BuildEtatRows(int count, int parasiteCount = 0)
    {
        var rows = new List<Dictionary<string, object?>>(count + parasiteCount);
        for (int i = 1; i <= count; i++)
        {
            rows.Add(new Dictionary<string, object?>
            {
                ["EI_PKID"] = (long)i,
                ["EI_IDEtat"] = 0L,
                ["EI_DateDebut"] = new DateTime(2026, 1, 1),
                ["EI_DateFin"] = new DateTime(2026, 1, 2),
                ["EI_Description"] = $"État {i}",
                ["EI_IDIntervention"] = (long)i
            });
        }

        // Lignes parasites : interventions hors page (IDs 1000+).
        for (int p = 1; p <= parasiteCount; p++)
        {
            long id = 1000 + p;
            rows.Add(new Dictionary<string, object?>
            {
                ["EI_PKID"] = id,
                ["EI_IDEtat"] = 0L,
                ["EI_DateDebut"] = new DateTime(2026, 1, 1),
                ["EI_DateFin"] = new DateTime(2026, 1, 2),
                ["EI_Description"] = $"État parasite {p}",
                ["EI_IDIntervention"] = id
            });
        }

        return rows;
    }

    private static bool ContainsToken(byte[] il, byte[] tokenBytes)
    {
        for (int i = 0; i <= il.Length - tokenBytes.Length; i++)
        {
            bool match = true;
            for (int j = 0; j < tokenBytes.Length; j++)
            {
                if (il[i + j] != tokenBytes[j])
                {
                    match = false;
                    break;
                }
            }

            if (match)
            {
                return true;
            }
        }

        return false;
    }

    // =========================================================================
    // SpyingHfsqlConnection
    // =========================================================================
    // Fake mémoire de IHfsqlConnection qui enregistre chaque requête SQL et
    // retourne des lignes par table. Aucun HFSQL réel, aucun ODBC, aucun réseau.
    // Permet de compter les requêtes et de vérifier le comportement bulk réel.
    // =========================================================================

    private sealed class SpyingHfsqlConnection : IHfsqlConnection
    {
        public HfsqlOptions Options => new();
        public HfsqlConnectionState State { get; private set; } = HfsqlConnectionState.Closed;

        public int QueryCount { get; private set; }
        public IReadOnlyList<string> AllSql => _allSql;
        private readonly List<string> _allSql = [];

        public IReadOnlyList<IReadOnlyDictionary<string, object?>> InterventionRows { get; set; } = [];
        public IReadOnlyList<IReadOnlyDictionary<string, object?>> PersonneRows { get; set; } = [];
        public IReadOnlyList<IReadOnlyDictionary<string, object?>> CollaborateurRows { get; set; } = [];
        public IReadOnlyList<IReadOnlyDictionary<string, object?>> EtatRows { get; set; } = [];

        public int CountQueriesContaining(params string[] fragments)
            => _allSql.Count(sql => fragments.All(f => sql.Contains(f, StringComparison.OrdinalIgnoreCase)));

        private void Record(string sql)
        {
            QueryCount++;
            _allSql.Add(sql);
        }

        public Task OpenAsync(CancellationToken cancellationToken = default)
        {
            State = HfsqlConnectionState.Open;
            return Task.CompletedTask;
        }

        public Task CloseAsync()
        {
            State = HfsqlConnectionState.Closed;
            return Task.CompletedTask;
        }

        public Task<object?> ExecuteScalarAsync(string sql, IReadOnlyList<object?>? parameters = null, CancellationToken cancellationToken = default)
        {
            Record(sql);
            if (sql.Contains("COUNT(*)", StringComparison.OrdinalIgnoreCase))
            {
                return Task.FromResult<object?>((long)InterventionRows.Count);
            }

            return Task.FromResult<object?>(null);
        }

        public Task<int> ExecuteNonQueryAsync(string sql, IReadOnlyList<object?>? parameters = null, CancellationToken cancellationToken = default)
        {
            Record(sql);
            return Task.FromResult(0);
        }

        public Task<IReadOnlyList<IReadOnlyDictionary<string, object?>>> QueryAsync(
            string sql, IReadOnlyList<object?>? parameters = null, CancellationToken cancellationToken = default)
        {
            Record(sql);
            return Task.FromResult(ResolveRows(sql, parameters));
        }

        public Task<IReadOnlyList<HfsqlColumnMetadata>> GetColumnsAsync(
            string tableName, CancellationToken cancellationToken = default)
        {
            return Task.FromResult<IReadOnlyList<HfsqlColumnMetadata>>([]);
        }

        public ValueTask DisposeAsync()
        {
            State = HfsqlConnectionState.Closed;
            return ValueTask.CompletedTask;
        }

        private IReadOnlyList<IReadOnlyDictionary<string, object?>> ResolveRows(
            string sql, IReadOnlyList<object?>? parameters)
        {
            // Les requêtes relationnelles sont des lectures globales (SELECT ...
            // FROM table, sans WHERE IN) : le repository filtre ensuite en mémoire
            // via un HashSet des identifiants de la page. Le fake retourne donc
            // TOUTES les lignes (y compris les parasites hors page) pour que le
            // filtre mémoire du repository soit réellement exercé.
            if (ContainsFrom(sql, "Intervention_Personne"))
            {
                return FilterByInterventionId(PersonneRows, parameters, "IP_IDIntervention");
            }

            if (ContainsFrom(sql, "Intervention_Collaborateur"))
            {
                return FilterByInterventionId(CollaborateurRows, parameters, "IC_IDIntervention");
            }

            if (ContainsFrom(sql, "EtatIntervention"))
            {
                return FilterByInterventionId(EtatRows, parameters, "EI_IDIntervention");
            }

            if (ContainsFrom(sql, "Intervention"))
            {
                return InterventionRows;
            }

            return [];
        }

        private static IReadOnlyList<IReadOnlyDictionary<string, object?>> FilterByInterventionId(
            IReadOnlyList<IReadOnlyDictionary<string, object?>> rows,
            IReadOnlyList<object?>? parameters,
            string idColumn)
        {
            if (parameters is null || parameters.Count == 0)
            {
                return rows;
            }

            var ids = new HashSet<long>();
            foreach (object? p in parameters)
            {
                if (p is long l)
                {
                    ids.Add(l);
                }
                else if (p is int i)
                {
                    ids.Add(i);
                }
            }

            if (ids.Count == 0)
            {
                return rows;
            }

            return rows
                .Where(r => r.TryGetValue(idColumn, out object? v) && v is long id && ids.Contains(id))
                .ToList();
        }

        private static bool ContainsFrom(string sql, string table)
        {
            string marker = $"FROM {table}";
            int index = sql.IndexOf(marker, StringComparison.OrdinalIgnoreCase);
            while (index >= 0)
            {
                int next = index + marker.Length;
                if (next >= sql.Length || (!char.IsLetterOrDigit(sql[next]) && sql[next] != '_'))
                {
                    return true;
                }

                index = sql.IndexOf(marker, index + 1, StringComparison.OrdinalIgnoreCase);
            }

            return false;
        }
    }
}