using MongoDB.Bson;
using MongoDB.Driver;

namespace Infrastructure.Services.MongoDB;

public class MongoDbService
{
    private readonly string _collectionName;
    private readonly IMongoClient _database;
    private readonly string _databaseName;

    protected MongoDbService(string connectionString, string databaseName, string collectionName)
    {
        _databaseName = databaseName;
        _collectionName = collectionName;

        var settings = MongoClientSettings.FromConnectionString(connectionString);
        settings.ServerApi = new ServerApi(ServerApiVersion.V1);
        _database = new MongoClient(settings);

        try
        {
            _database.GetDatabase("admin").RunCommand<BsonDocument>(new BsonDocument("ping", 1));
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
    }

    public MongoDbService(IMongoClient database, string collectionName, string databaseName)
    {
        _database = database;
        _collectionName = collectionName;
        _databaseName = databaseName;
    }

    public IMongoCollection<T> GetCollection<T>()
    {
        return _database.GetDatabase(_databaseName).GetCollection<T>(_collectionName);
    }

    public async Task<List<T>> FindAsync<T>(List<(string FieldName, string Value)> criteria, CancellationToken token)
    {
        var collection = _database.GetDatabase(_databaseName).GetCollection<T>(_collectionName);

        var filters = new List<FilterDefinition<T>>();
        foreach (var (FieldName, Value) in criteria) filters.Add(Builders<T>.Filter.Eq(FieldName, Value));

        var combinedFilter = Builders<T>.Filter.And(filters);

        return await collection.Find(combinedFilter).ToListAsync(token);
    }

    [Obsolete("Obsolete")]
    public async Task AddAsync<T>(T document, CancellationToken token)
    {
        var collection = _database.GetDatabase(_databaseName).GetCollection<T>(_collectionName);
        await collection.InsertOneAsync(document, token);
    }

    public async Task ModifyAsync<T>(string keyField, string keyValue, T document, CancellationToken token)
    {
        var collection = _database.GetDatabase(_databaseName).GetCollection<T>(_collectionName);
        var filter = Builders<T>.Filter.Eq(keyField, keyValue);
        await collection.ReplaceOneAsync(filter, document, new ReplaceOptions { IsUpsert = true }, token);
    }

    public async Task DeleteAsync<T>(string keyField, string keyValue, CancellationToken token)
    {
        var collection = _database.GetDatabase(_databaseName).GetCollection<T>(_collectionName);
        var filter = Builders<T>.Filter.Eq(keyField, keyValue);
        await collection.DeleteOneAsync(filter, token);
    }

    public async Task DeleteByIdAsync<T>(string id, CancellationToken token)
    {
        var collection = _database.GetDatabase(_databaseName).GetCollection<T>(_collectionName);
        var filter = Builders<T>.Filter.Eq("_id", id);
        await collection.DeleteOneAsync(filter, token);
    }
}