using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using Dapper;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.QueryExecutor;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using static GB5Shared.QueryExecutor.QueryExecutor;

namespace GB5Shared.ListQuery
{
    // ─────────────────────────────────────────────────────────────────────
    //  IListQuery<TResult>
    //
    //  Marker interface for a query object. Every list in the system is
    //  represented as a record that implements this interface.
    //  The query object IS the request — it carries the typed criteria.
    //
    //  Example:
    //      public sealed record PendingMMDocumentsQuery(PendingMMDocumentCriteria Criteria)
    //          : IListQuery<AllocationDTO>;
    // ─────────────────────────────────────────────────────────────────────
    public interface IListQuery<TResult> { }

    // ─────────────────────────────────────────────────────────────────────
    //  IListQuery<TResult, TCriteria>
    //
    //  Extends the marker for queries that carry a typed Criteria property.
    //  Implement this (instead of the plain marker) when backed by a
    //  SqlListHandler<,,> subclass — the base reads query.Criteria directly.
    //
    //  Example:
    //      public sealed record FooListQuery(FooCriteria Criteria)
    //          : IListQuery<FooListDTO, FooCriteria>;
    // ─────────────────────────────────────────────────────────────────────
    public interface IListQuery<TResult, TCriteria> : IListQuery<TResult>
        where TCriteria : class
    {
        TCriteria Criteria { get; }
    }

    // ─────────────────────────────────────────────────────────────────────
    //  IListHandler<TQuery, TResult>
    //
    //  One handler per query type. The handler owns:
    //    • Building the SQL (via a QueryBuilder method)
    //    • Executing the query via IQueryExecutor
    //    • Returning a PagedResult<TResult> or IAsyncEnumerable<TResult>
    //
    //  Handlers never contain business logic, caching logic, or HTTP concerns.
    //
    //  Pattern A — Direct call (simple modules, single query variant):
    //      Inject IListHandler<TQuery, TResult> directly into the BLL method.
    //
    //  Pattern B — Routed (legacy fat methods, multi-variant endpoint):
    //      Let IQueryRouter build the correct IListQuery<T> and dispatch via IListDispatcher.
    // ─────────────────────────────────────────────────────────────────────
    public interface IListHandler<in TQuery, TResult>
        where TQuery : IListQuery<TResult>
    {
        /// <summary>Returns a paged result materialised into memory.</summary>
        Task<PagedResult<TResult>> HandleAsync(TQuery query, LoginDTO login, CancellationToken ct = default);

        /// <summary>
        /// Streams results one row at a time (constant memory).
        /// Used by NDJSON streaming endpoints — client reads rows as they arrive.
        /// </summary>
        IAsyncEnumerable<TResult> StreamAsync(TQuery query, LoginDTO login, CancellationToken ct = default);
    }

    // ─────────────────────────────────────────────────────────────────────
    //  IListDispatcher
    //
    //  Resolves and invokes the correct IListHandler for a given IListQuery.
    //  Used by IQueryRouter implementations (Pattern B).
    //
    //  No manual switch statements — DI is the registry.
    //  The dispatcher resolves IListHandler<TQuery,TResult> from the DI container.
    // ─────────────────────────────────────────────────────────────────────
    public interface IListDispatcher
    {
        Task<PagedResult<TResult>> DispatchAsync<TResult>(
            IListQuery<TResult> query, LoginDTO login, CancellationToken ct = default);

        IAsyncEnumerable<TResult> StreamAsync<TResult>(
            IListQuery<TResult> query, LoginDTO login, CancellationToken ct = default);
    }

    // ─────────────────────────────────────────────────────────────────────
    //  IQueryRouter<TResult>
    //
    //  The BLL/SL routing layer. For a single FE endpoint that can produce
    //  multiple different query shapes based on discriminator fields in the
    //  CriteriaDTO, the router:
    //    1. Reads 1–3 discriminator fields from the raw CriteriaDTO
    //    2. Calls CriteriaBinder.Bind<T>() to get a typed criteria
    //    3. Builds the correct IListQuery<TResult>
    //    4. Dispatches via IListDispatcher
    //
    //  Use this ONLY when a single endpoint serves multiple query variants.
    //  For simple modules, call IListHandler<TQuery,TResult>.HandleAsync() directly.
    // ─────────────────────────────────────────────────────────────────────
    public interface IQueryRouter<TResult>
    {
        Task<string> RouteAsync(
            GB5Shared.DTO.Framework.Criteria.CriteriaDTO criteria,
            string? searchText,
            int     pageOffset,
            int     pageSize,
            LoginDTO login,
            CancellationToken ct = default);
    }

    // ─────────────────────────────────────────────────────────────────────
    //  IQueryBuilder<TQuery, TResult>
    //
    //  The ONE thing a module developer writes per list query variant.
    //  Implement this in the module's QB class — no handler file needed.
    //  GenericListHandler is wired automatically by AddListInfrastructure().
    //
    //  The Build() method receives the full query (which carries Criteria)
    //  and the resolved dialect. Return parameterised SQL only — no execution.
    //
    //  Sort safety: Build() MUST validate sortBy against an internal allowlist
    //  via SqlClauses.OrderBy(). Never concatenate client sort columns into SQL.
    //
    //  Example:
    //      public sealed class PendingMMDocumentsQB
    //          : IQueryBuilder<PendingMMDocumentsQuery, PendingAllocationListDTO>
    //      {
    //          private static readonly IReadOnlyDictionary<string, string> _sort =
    //              new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
    //              { ["headerdate"] = "h.MMHEADERDATE", ["partyname"] = "pt.PARTYNAME" };
    //
    //          public (string Sql, DynamicParameters Params) Build(
    //              PendingMMDocumentsQuery query, ISqlDialect dialect)
    //          {
    //              var orderBy = SqlClauses.OrderBy(
    //                  query.Criteria.SortBy, query.Criteria.SortDesc,
    //                  _sort, defaultCol: "h.MMHEADERID DESC");
    //              return PendingAllocationQB.BuildPendingMMDocuments(
    //                  query.Criteria, dialect, orderBy);
    //          }
    //      }
    // ─────────────────────────────────────────────────────────────────────
    public interface IQueryBuilder<TQuery, TResult>
        where TQuery : IListQuery<TResult>
    {
        (string Sql, DynamicParameters Params) Build(
            TQuery query,
            LoginDTO login,
            ISqlDialect dialect);
    }

    // ─────────────────────────────────────────────────────────────────────
    //  ListDispatcher  – resolves handler via DI service provider
    //
    //  Handlers are resolved by type using IServiceProvider.
    //  MethodInfo invocations are cached after the first call per handler type.
    // ─────────────────────────────────────────────────────────────────────
    public sealed class ListDispatcher : IListDispatcher
    {
        private readonly IServiceProvider _services;

        // Cache reflected MethodInfo to avoid repeated GetMethod calls
        private static readonly ConcurrentDictionary<Type, MethodInfo> _handleMethods = new();
        private static readonly ConcurrentDictionary<Type, MethodInfo> _streamMethods  = new();

        public ListDispatcher(IServiceProvider services) => _services = services;

        public Task<PagedResult<TResult>> DispatchAsync<TResult>(
            IListQuery<TResult> query, LoginDTO login, CancellationToken ct = default)
        {
            var handler    = ResolveHandler<TResult>(query.GetType(), out var handlerType);
            var invoke     = _handleMethods.GetOrAdd(handlerType,
                t => t.GetMethod(nameof(IListHandler<IListQuery<TResult>, TResult>.HandleAsync))!);
            return (Task<PagedResult<TResult>>)invoke.Invoke(handler, [query, login, ct])!;
        }

        public IAsyncEnumerable<TResult> StreamAsync<TResult>(
            IListQuery<TResult> query, LoginDTO login, CancellationToken ct = default)
        {
            var handler = ResolveHandler<TResult>(query.GetType(), out var handlerType);
            var invoke  = _streamMethods.GetOrAdd(handlerType,
                t => t.GetMethod(nameof(IListHandler<IListQuery<TResult>, TResult>.StreamAsync))!);
            return (IAsyncEnumerable<TResult>)invoke.Invoke(handler, [query, login, ct])!;
        }

        private object ResolveHandler<TResult>(Type queryType, out Type handlerType)
        {
            handlerType = typeof(IListHandler<,>).MakeGenericType(queryType, typeof(TResult));
            return _services.GetService(handlerType)
                ?? throw new InvalidOperationException(
                    $"No handler registered for query type '{queryType.Name}'. " +
                    $"Register IListHandler<{queryType.Name}, {typeof(TResult).Name}> in DI.");
        }
    }

    // ─────────────────────────────────────────────────────────────────────
    //  GenericListHandler<TQuery, TResult>
    //
    //  The universal handler. Owns (once, here in GB5Shared):
    //    • Guard execution (IQueryGuard<TQuery> — all run; empty = permissive)
    //    • Dialect resolution via SqlDialectFactory
    //    • IQueryBuilder<TQuery,TResult>.Build()
    //    • IQueryExecutor.QueryPagedAsync / QueryStreamAsync
    //    • Timing + structured slow-query log (>2000ms → LogWarning)
    //
    //  Registered automatically by AddListInfrastructure() for every
    //  IQueryBuilder<TQ,TR> found in the scanned assemblies.
    //  Module developers do NOT register or subclass this.
    //
    //  QueryIntent is resolved once per TQuery type (cached in QueryIntentResolver).
    //  Phase 2 will use it for DB routing — today it is metadata only.
    // ─────────────────────────────────────────────────────────────────────
    public sealed class GenericListHandler<TQuery, TResult>
        : IListHandler<TQuery, TResult>
        where TQuery : IListQuery<TResult>
    {
        // Resolved once per TQuery type — zero overhead after first call
        private static readonly QueryIntent _intent =
            QueryIntentResolver.Get(typeof(TQuery));

        private readonly IQueryExecutor                              _qe;
        private readonly IQueryBuilder<TQuery, TResult>             _qb;
        private readonly IEnumerable<IQueryGuard<TQuery>>           _guards;
        private readonly ILogger<GenericListHandler<TQuery, TResult>> _logger;

        public GenericListHandler(
            IQueryExecutor                              qe,
            IQueryBuilder<TQuery, TResult>             qb,
            IEnumerable<IQueryGuard<TQuery>>           guards,
            ILogger<GenericListHandler<TQuery, TResult>> logger)
        {
            _qe      = qe;
            _qb      = qb;
            _guards  = guards;
            _logger  = logger;
        }

        /// <inheritdoc/>
        public async Task<PagedResult<TResult>> HandleAsync(
    TQuery query,
    LoginDTO login,
    CancellationToken ct = default)
        {
            RunGuards(query, login);

            var dialect = SqlDialectFactory.Get(login.DatabaseType);

            var (sql, param) = _qb.Build(query, login, dialect);

            var sw = Stopwatch.StartNew();

            try
            {
                return await _qe.QueryPagedAsync<TResult>(login, sql, param)
                                .ConfigureAwait(false);
            }
            finally
            {
                sw.Stop();
                LogTiming(sw.Elapsed);
            }
        }

        /// <inheritdoc/>
        public async IAsyncEnumerable<TResult> StreamAsync(
            TQuery query,
            LoginDTO login,
            [EnumeratorCancellation] CancellationToken ct = default)
        {
            RunGuards(query, login);

            var dialect = SqlDialectFactory.Get(login.DatabaseType);

            var (sql, param) = _qb.Build(query, login, dialect);

            var sw = Stopwatch.StartNew();

            await foreach (var row in _qe.QueryStreamAsync<TResult>(login, sql, param, ct)
                                         .ConfigureAwait(false))
            {
                yield return row;
            }

            LogTiming(sw.Elapsed);
        }
        private void RunGuards(TQuery query, LoginDTO login)
        {
            if (_guards == null || !_guards.Any())
                return;

            foreach (var guard in _guards)
            {
                try
                {
                    guard.Validate(query, login);
                }
                catch (Exception ex)
                {
                    throw new InvalidOperationException(
                        $"Guard validation failed: {guard.GetType().Name}",
                        ex);
                }
            }
        }

        private void LogTiming(TimeSpan elapsed)
        {
            if (elapsed.TotalMilliseconds > 2000)
                _logger.LogWarning(
                    "Slow query {QueryType} completed in {ElapsedMs}ms (intent={Intent}) — review filters/indexes",
                    typeof(TQuery).Name, (long)elapsed.TotalMilliseconds, _intent);
            else
                _logger.LogDebug(
                    "Query {QueryType} completed in {ElapsedMs}ms",
                    typeof(TQuery).Name, (long)elapsed.TotalMilliseconds);
        }
    }

    // ─────────────────────────────────────────────────────────────────────
    //  PagedListResult<T>
    //
    //  Returned by IListHandler.HandleAsync().
    //  Note: GB5Shared.QueryExecutor.PagedResult<T> already exists with
    //  Items + TotalCount. This type re-uses that shape under the ListQuery
    //  namespace so handlers don't need to import QueryExecutor directly.
    //  Internally, handlers call IQueryExecutor.QueryPagedAsync<T>() which
    //  returns the QueryExecutor.PagedResult<T> and map it here.
    // ─────────────────────────────────────────────────────────────────────
    public sealed class PagedListResult<T>
    {
        public IEnumerable<T> Items      { get; init; } = [];
        public int            TotalCount { get; init; }
        public bool           IsTruncated => TotalCount > (Items as ICollection<T>)?.Count;

        /// <summary>
        /// Converts a <see cref="PagedResult{T}"/> from IQueryExecutor
        /// into a <see cref="PagedListResult{T}"/>.
        /// </summary>
        public static PagedListResult<T> From(PagedResult<T> source) =>
            new() { Items = source.Items ?? [], TotalCount = source.TotalCount };
    }

    // ─────────────────────────────────────────────────────────────────────
    //  DI registration helpers
    // ─────────────────────────────────────────────────────────────────────
    public static class ListQueryServiceExtensions
    {
        /// <summary>
        /// Registers IListDispatcher, scans <paramref name="scanAssemblies"/> for
        /// IQueryBuilder&lt;TQ,TR&gt; implementations, auto-registers
        /// GenericListHandler&lt;TQ,TR&gt; as IListHandler&lt;TQ,TR&gt; for each one found,
        /// and registers all IQueryGuard&lt;TQuery&gt; implementations.
        ///
        /// Replaces <c>AddListDispatcher()</c>. Call once in Program.cs:
        ///     builder.Services.AddListInfrastructure(mmDALAssembly);
        /// </summary>
        public static IServiceCollection AddListInfrastructure(
            this IServiceCollection services,
            params Assembly[]       scanAssemblies)
        {
            services.AddScoped<IListDispatcher, ListDispatcher>();

            if (scanAssemblies is null or { Length: 0 }) return services;

            foreach (var assembly in scanAssemblies)
            foreach (var type in assembly.GetTypes()
                         .Where(t => !t.IsAbstract && !t.IsInterface))
            {
                foreach (var iface in type.GetInterfaces()
                             .Where(i => i.IsGenericType &&
                                         i.GetGenericTypeDefinition() == typeof(IQueryBuilder<,>)))
                {
                    // IQueryBuilder<TQ,TR> → register the QB class itself
                    services.AddScoped(iface, type);

                    // Auto-register GenericListHandler<TQ,TR> as IListHandler<TQ,TR>
                    var args        = iface.GetGenericArguments();          // [TQuery, TResult]
                    var handlerType = typeof(GenericListHandler<,>).MakeGenericType(args);
                    var handlerIface = typeof(IListHandler<,>).MakeGenericType(args);
                    services.AddScoped(handlerIface, handlerType);
                }

                foreach (var iface in type.GetInterfaces()
                             .Where(i => i.IsGenericType &&
                                         i.GetGenericTypeDefinition() == typeof(IQueryGuard<>)))
                {
                    // Register guard — IEnumerable<IQueryGuard<TQuery>> collects all registrations
                    services.AddScoped(iface, type);
                }
            }

            return services;
        }

        /// <summary>Registers IListDispatcher as Scoped (no assembly scan).</summary>
        [Obsolete("Use AddListInfrastructure(assemblies) to also register IQueryBuilder handlers. " +
                  "AddListDispatcher() remains for projects that register handlers manually.")]
        public static IServiceCollection AddListDispatcher(this IServiceCollection services)
        {
            services.AddScoped<IListDispatcher, ListDispatcher>();
            return services;
        }

        /// <summary>
        /// Registers a handler for a specific query type explicitly.
        /// Useful for overriding a GenericListHandler registration with a custom handler.
        /// </summary>
        public static IServiceCollection AddListHandler<TQuery, TResult, THandler>(
            this IServiceCollection services)
            where TQuery   : IListQuery<TResult>
            where THandler : class, IListHandler<TQuery, TResult>
        {
            services.AddScoped<IListHandler<TQuery, TResult>, THandler>();
            return services;
        }
    }
}