using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using Dpz.Core.Entity.Base;
using Dpz.Core.Entity.Base.Indexes;
using Microsoft.Extensions.Logging;
using MongoDB.Bson;
using MongoDB.Driver;

namespace Dpz.Core.MongodbAccess;

/// <summary>
/// MongoDB 索引初始化器，根据实体上的 <see cref="IIndexedEntity{T}"/> 定义自动创建索引。
/// 每个实体类型在应用生命周期内只执行一次索引检查。
/// </summary>
public sealed class MongoIndexInitializer(ILogger<MongoIndexInitializer> logger)
    : IMongoIndexInitializer
{
    private readonly ConcurrentDictionary<Type, Task> _initializedTypes = new();

    /// <summary>
    /// 同步实体对应的集合索引与代码定义（每个类型只执行一次）
    /// </summary>
    public Task SynchronizeAsync<T>(
        IMongoCollection<T> collection,
        CancellationToken cancellationToken = default
    )
        where T : IBaseEntity
    {
        return _initializedTypes.GetOrAdd(
            typeof(T),
            _ => SynchronizeCoreAsync(collection, cancellationToken)
        );
    }

    /// <summary>
    /// 根据运行时类型同步索引（用于启动时批量初始化）
    /// </summary>
    public Task SynchronizeForTypeAsync(
        Type entityType,
        string connectionString,
        CancellationToken cancellationToken = default
    )
    {
        return _initializedTypes.GetOrAdd(
            entityType,
            _ =>
            {
                var method = GetType()
                    .GetMethod(
                        nameof(SynchronizeForTypeCoreAsync),
                        BindingFlags.NonPublic | BindingFlags.Instance
                    )!
                    .MakeGenericMethod(entityType);
                return (Task)method.Invoke(this, [connectionString, cancellationToken])!;
            }
        );
    }

    public Task ResetAsync(CancellationToken cancellationToken = default)
    {
        cancellationToken.ThrowIfCancellationRequested();
        _initializedTypes.Clear();
        logger.LogInformation("MongoDB 索引初始化状态已重置");
        return Task.CompletedTask;
    }

    private Task SynchronizeForTypeCoreAsync<T>(
        string connectionString,
        CancellationToken cancellationToken
    )
        where T : IBaseEntity
    {
        var access = new MongodbAccess<T>(connectionString);
        return SynchronizeCoreAsync(access.Collection, cancellationToken);
    }

    private async Task SynchronizeCoreAsync<T>(
        IMongoCollection<T> collection,
        CancellationToken cancellationToken
    )
        where T : IBaseEntity
    {
        try
        {
            var totalStopwatch = Stopwatch.StartNew();
            var definitions = GetIndexDefinitions<T>();
            if (definitions is not { Count: > 0 })
            {
                return;
            }

            var existingIndexes = await (
                await collection.Indexes.ListAsync(cancellationToken)
            ).ToListAsync(cancellationToken);

            var existingIndexMap = existingIndexes
                .Where(static index => index.TryGetValue("name", out _))
                .ToDictionary(
                    static index => index["name"].AsString,
                    static index => index,
                    StringComparer.OrdinalIgnoreCase
                );

            var createdCount = 0;
            var droppedCount = 0;
            var matchedCount = 0;

            foreach (var def in definitions)
            {
                var resolvedName = def.GetResolvedName();
                var model = BuildIndexModel<T>(def, resolvedName);
                if (model == null)
                {
                    continue;
                }

                if (existingIndexMap.TryGetValue(resolvedName, out var existing))
                {
                    if (IsIndexMatched(existing, def))
                    {
                        matchedCount++;
                        continue;
                    }

                    // 同名索引定义发生漂移时，遵循代码优先，删除并重建。
                    var dropStopwatch = Stopwatch.StartNew();
                    await collection.Indexes.DropOneAsync(resolvedName, cancellationToken);
                    dropStopwatch.Stop();
                    droppedCount++;
                    logger.LogInformation(
                        "删除索引完成: {EntityType}.{IndexName}, 耗时 {ElapsedMs}ms",
                        typeof(T).Name,
                        resolvedName,
                        dropStopwatch.ElapsedMilliseconds
                    );
                }

                var createStopwatch = Stopwatch.StartNew();
                await collection.Indexes.CreateOneAsync(
                    model,
                    cancellationToken: cancellationToken
                );
                createStopwatch.Stop();
                createdCount++;
                logger.LogInformation(
                    "创建索引完成: {EntityType}.{IndexName}, 耗时 {ElapsedMs}ms",
                    typeof(T).Name,
                    resolvedName,
                    createStopwatch.ElapsedMilliseconds
                );
            }

            totalStopwatch.Stop();
            logger.LogInformation(
                "索引初始化完成: {EntityType}, 定义={DefinedCount}, 已匹配={MatchedCount}, 删除={DroppedCount}, 创建={CreatedCount}, 总耗时={ElapsedMs}ms",
                typeof(T).Name,
                definitions.Count,
                matchedCount,
                droppedCount,
                createdCount,
                totalStopwatch.ElapsedMilliseconds
            );
        }
        catch (Exception e)
        {
            // 失败时移除已缓存的 Task，允许下次重试
            _initializedTypes.TryRemove(typeof(T), out _);
            logger.LogError(e, "索引同步失败: {EntityType}", typeof(T).Name);
        }
    }

    private CreateIndexModel<T>? BuildIndexModel<T>(EntityIndexDefinition def, string resolvedName)
        where T : IBaseEntity
    {
        IndexKeysDefinition<T>? keys = null;

        foreach (var field in def.Fields)
        {
            IndexKeysDefinition<T> key = field.KeyType switch
            {
                IndexKeyType.Text => Builders<T>.IndexKeys.Text(field.FieldName),
                _ => field.Direction == IndexSortDirection.Descending
                    ? Builders<T>.IndexKeys.Descending(field.FieldName)
                    : Builders<T>.IndexKeys.Ascending(field.FieldName),
            };
            keys = keys == null ? key : Builders<T>.IndexKeys.Combine(keys, key);
        }

        if (keys == null)
        {
            return null;
        }

        var options = new CreateIndexOptions { Name = resolvedName, Unique = def.Unique };

        // TTL 索引必须是单字段普通索引，且字段为 BSON Date 类型
        if (def.ExpireAfter is { } expireAfter)
        {
            if (def.Fields.Count != 1 || def.Fields[0].KeyType != IndexKeyType.Standard)
            {
                logger.LogWarning(
                    "索引定义无效: {IndexName} 的 ExpireAfter 仅支持单字段普通索引",
                    resolvedName
                );
                return null;
            }

            options.ExpireAfter = expireAfter;
        }

        // 文本索引权重
        if (def.TextWeights is { Count: > 0 })
        {
            var weightsDoc = new BsonDocument();
            foreach (var (fieldName, weight) in def.TextWeights)
            {
                weightsDoc[fieldName] = weight;
            }

            options.Weights = weightsDoc;
        }

        if (!string.IsNullOrEmpty(def.DefaultLanguage))
        {
            options.DefaultLanguage = def.DefaultLanguage;
        }

        return new CreateIndexModel<T>(keys, options);
    }

    private static bool IsIndexMatched(BsonDocument existing, EntityIndexDefinition def)
    {
        var hasTextField = def.Fields.Any(static field => field.KeyType == IndexKeyType.Text);

        if (!MatchesKeyDefinition(existing, def.Fields, hasTextField))
        {
            return false;
        }

        var existingUnique =
            existing.TryGetValue("unique", out var uniqueValue) && uniqueValue.ToBoolean();
        if (existingUnique != def.Unique)
        {
            return false;
        }

        var existingExpireAfterSeconds = existing.TryGetValue(
            "expireAfterSeconds",
            out var expireAfterValue
        )
            ? expireAfterValue.ToInt64()
            : (long?)null;
        var expectedExpireAfterSeconds = def.ExpireAfter is { } expireAfter
            ? (long)expireAfter.TotalSeconds
            : (long?)null;
        if (existingExpireAfterSeconds != expectedExpireAfterSeconds)
        {
            return false;
        }

        if (!hasTextField)
        {
            return true;
        }

        if (def.TextWeights is { Count: > 0 } && !MatchesTextWeights(existing, def.TextWeights))
        {
            return false;
        }

        if (!string.IsNullOrWhiteSpace(def.DefaultLanguage))
        {
            if (!existing.TryGetValue("default_language", out var languageValue))
            {
                return false;
            }

            if (
                !string.Equals(
                    languageValue.AsString,
                    def.DefaultLanguage,
                    StringComparison.Ordinal
                )
            )
            {
                return false;
            }
        }

        return true;
    }

    private static bool MatchesKeyDefinition(
        BsonDocument existing,
        IReadOnlyList<EntityIndexField> fields,
        bool hasTextField
    )
    {
        if (!existing.TryGetValue("key", out var keyValue) || keyValue is not BsonDocument keyDoc)
        {
            return false;
        }

        if (hasTextField)
        {
            return keyDoc.TryGetValue("_fts", out var textType) && textType == "text";
        }

        if (keyDoc.ElementCount != fields.Count)
        {
            return false;
        }

        for (var index = 0; index < fields.Count; index++)
        {
            var expectedField = fields[index];
            var element = keyDoc.GetElement(index);

            if (!string.Equals(element.Name, expectedField.FieldName, StringComparison.Ordinal))
            {
                return false;
            }

            var expectedDirection = (int)expectedField.Direction;
            if (!int.TryParse(element.Value.ToString(), out var existingDirection))
            {
                return false;
            }

            if (existingDirection != expectedDirection)
            {
                return false;
            }
        }

        return true;
    }

    private static bool MatchesTextWeights(
        BsonDocument existing,
        IReadOnlyDictionary<string, int> expectedWeights
    )
    {
        if (
            !existing.TryGetValue("weights", out var weightsValue)
            || weightsValue is not BsonDocument weights
        )
        {
            return false;
        }

        if (weights.ElementCount != expectedWeights.Count)
        {
            return false;
        }

        foreach (var (fieldName, expectedWeight) in expectedWeights)
        {
            if (!weights.TryGetValue(fieldName, out var weightValue))
            {
                return false;
            }

            if (!int.TryParse(weightValue.ToString(), out var actualWeight))
            {
                return false;
            }

            if (actualWeight != expectedWeight)
            {
                return false;
            }
        }

        return true;
    }

    private static IReadOnlyList<EntityIndexDefinition>? GetIndexDefinitions<T>()
        where T : IBaseEntity
    {
        if (!typeof(IIndexedEntity<T>).IsAssignableFrom(typeof(T)))
        {
            return null;
        }

        // 通过带完整约束的辅助方法调用 static abstract 接口方法
        var method = typeof(MongoIndexInitializer)
            .GetMethod(nameof(GetDefinitionsCore), BindingFlags.NonPublic | BindingFlags.Static)!
            .MakeGenericMethod(typeof(T));

        return (IReadOnlyList<EntityIndexDefinition>?)method.Invoke(null, null);
    }

    private static IReadOnlyList<EntityIndexDefinition> GetDefinitionsCore<T>()
        where T : IBaseEntity, IIndexedEntity<T>
    {
        return T.GetIndexDefinitions();
    }
}