using MongoDB.Driver;
using QuestionsApi.Models;
using System.Security.Cryptography;
using System.Text;

namespace QuestionsApi.Services;

public class QuestionAttemptStore
{
    private readonly IMongoCollection<QuestionAttempt> _col;

    public const int CounterBucketCount = 32;

    public QuestionAttemptStore(MongoDatabaseProvider mongo)
    {
        _col = mongo.Database.GetCollection<QuestionAttempt>("QuestionAttempts");

        var firstAttemptIndex = Builders<QuestionAttempt>.IndexKeys
            .Ascending(a => a.QuestionExternalId)
            .Ascending(a => a.UserId);
        _col.Indexes.CreateOne(new CreateIndexModel<QuestionAttempt>(
            firstAttemptIndex,
            new CreateIndexOptions { Unique = true }));

        var questionIndex = Builders<QuestionAttempt>.IndexKeys.Ascending(a => a.QuestionExternalId);
        _col.Indexes.CreateOne(new CreateIndexModel<QuestionAttempt>(questionIndex));

        var createdIndex = Builders<QuestionAttempt>.IndexKeys.Ascending(a => a.CreatedUtc);
        _col.Indexes.CreateOne(new CreateIndexModel<QuestionAttempt>(createdIndex));
    }

    public async Task<QuestionAttemptRecordResult> RecordFirstAttemptAsync(
        string questionExternalId,
        string userId,
        string choiceId,
        bool isCorrect,
        bool isSkip = false)
    {
        var attempt = new QuestionAttempt
        {
            QuestionExternalId = questionExternalId,
            UserId = userId,
            ChoiceId = choiceId,
            IsCorrect = isCorrect,
            IsSkip = isSkip,
            CounterBucket = GetCounterBucket(userId),
            RatingApplied = false,
            CreatedUtc = DateTime.UtcNow
        };

        try
        {
            await _col.InsertOneAsync(attempt);
            return new QuestionAttemptRecordResult { Inserted = true, Attempt = attempt };
        }
        catch (MongoWriteException ex) when (ex.WriteError.Category == ServerErrorCategory.DuplicateKey)
        {
            var existing = await _col
                .Find(a => a.QuestionExternalId == questionExternalId && a.UserId == userId)
                .FirstAsync();
            return new QuestionAttemptRecordResult { Inserted = false, Attempt = existing };
        }
    }

    public async Task<Dictionary<string, int>> GetPercentagesForQuestionAsync(string questionExternalId)
    {
        var results = await GetPercentagesByQuestionAsync([questionExternalId]);
        return results.GetValueOrDefault(questionExternalId, []);
    }

    public async Task<Dictionary<string, Dictionary<string, int>>> GetPercentagesByQuestionAsync(IEnumerable<string> questionExternalIds)
    {
        var ids = questionExternalIds.Where(id => !string.IsNullOrWhiteSpace(id)).Distinct().ToList();
        if (ids.Count == 0)
            return [];

        var totals = await _col.Aggregate()
            .Match(a => ids.Contains(a.QuestionExternalId) && !a.IsSkip)
            .Group(
                attempt => new { attempt.QuestionExternalId, attempt.ChoiceId },
                group => new QuestionAttemptCounterTotal
                {
                    Key = new QuestionChoiceCounterKey
                    {
                        QuestionExternalId = group.Key.QuestionExternalId,
                        ChoiceId = group.Key.ChoiceId
                    },
                    Count = group.Sum(_ => 1L)
                })
            .ToListAsync();
        var output = new Dictionary<string, Dictionary<string, int>>();

        foreach (var group in totals.GroupBy(total => total.Key.QuestionExternalId))
        {
            var total = group.Sum(item => item.Count);
            if (total == 0)
                continue;

            output[group.Key] = group
                .ToDictionary(
                    item => item.Key.ChoiceId,
                    item => (int)Math.Round(item.Count * 100.0 / total));
        }

        return output;
    }

    public Task<List<string>> GetActiveQuestionIdsAsync(DateTime sinceUtc) =>
        _col.Distinct(
            attempt => attempt.QuestionExternalId,
            Builders<QuestionAttempt>.Filter.Gte(attempt => attempt.CreatedUtc, sinceUtc))
            .ToListAsync();

    public IMongoCollection<QuestionAttempt> Collection => _col;

    public async Task<bool> TryAcquireRatingLeaseAsync(string attemptId, string owner, TimeSpan duration)
    {
        var now = DateTime.UtcNow;
        var filter = Builders<QuestionAttempt>.Filter.And(
            Builders<QuestionAttempt>.Filter.Eq(attempt => attempt.Id, attemptId),
            Builders<QuestionAttempt>.Filter.Exists(attempt => attempt.RatingApplied, true),
            Builders<QuestionAttempt>.Filter.Eq(attempt => attempt.RatingApplied, false),
            Builders<QuestionAttempt>.Filter.Or(
                Builders<QuestionAttempt>.Filter.Lt(attempt => attempt.RatingLeaseUntilUtc, now),
                Builders<QuestionAttempt>.Filter.Eq(attempt => attempt.RatingLeaseOwner, owner)));
        var update = Builders<QuestionAttempt>.Update
            .Set(attempt => attempt.RatingLeaseOwner, owner)
            .Set(attempt => attempt.RatingLeaseUntilUtc, now.Add(duration));
        var leased = await _col.FindOneAndUpdateAsync(
            filter,
            update,
            new FindOneAndUpdateOptions<QuestionAttempt> { ReturnDocument = ReturnDocument.After });
        return leased?.RatingLeaseOwner == owner;
    }

    public Task MarkRatingAppliedAsync(string attemptId, string owner) =>
        _col.UpdateOneAsync(
            attempt => attempt.Id == attemptId && attempt.RatingLeaseOwner == owner,
            Builders<QuestionAttempt>.Update
                .Set(attempt => attempt.RatingApplied, true)
                .Set(attempt => attempt.RatingLeaseUntilUtc, DateTime.MinValue));

    public Task ReleaseRatingLeaseAsync(string attemptId, string owner) =>
        _col.UpdateOneAsync(
            attempt => attempt.Id == attemptId && attempt.RatingLeaseOwner == owner && attempt.RatingApplied == false,
            Builders<QuestionAttempt>.Update.Set(attempt => attempt.RatingLeaseUntilUtc, DateTime.MinValue));

    public static int GetCounterBucket(string userId)
    {
        var hash = SHA256.HashData(Encoding.UTF8.GetBytes(userId));
        return (int)(BitConverter.ToUInt32(hash, 0) % CounterBucketCount);
    }
}