using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Company.Domain.CameraBugReportAgg;
using MongoDB.Bson;
using MongoDB.Driver;

namespace CompanyManagement.Infrastructure.Mongo.CameraBugReportRepo;

/// <summary>
/// پیاده‌سازی انبار گزارش خرابی دوربین برای MongoDB
/// </summary>
public class CameraBugReportRepository : ICameraBugReportRepository
{
    private readonly IMongoCollection<CameraBugReport> _cameraBugReports;

    public CameraBugReportRepository(IMongoDatabase database)
    {
        _cameraBugReports = database.GetCollection<CameraBugReport>("CameraBugReports");
    }

    public async Task CreateAsync(CameraBugReport bugReport)
    {
        await _cameraBugReports.InsertOneAsync(bugReport);
    }

    public async Task UpdateAsync(CameraBugReport bugReport)
    {
        await _cameraBugReports.ReplaceOneAsync(
            x => x.Id == bugReport.Id,
            bugReport);
    }

    public async Task<CameraBugReport> GetByIdAsync(Guid id)
    {
        return await _cameraBugReports
            .Find(x => x.Id == id)
            .FirstOrDefaultAsync();
    }

    public async Task<List<CameraBugReport>> GetAllAsync()
    {
        return await _cameraBugReports
            .Find(_ => true)
            .ToListAsync();
    }

    public async Task<List<CameraBugReport>> GetAllAsync(int skip, int take)
    {
        return await _cameraBugReports
            .Find(_ => true)
            .Skip(skip)
            .Limit(take)
            .SortByDescending(x => x.CreationDate)
            .ToListAsync();
    }

    public async Task DeleteAsync(Guid id)
    {
        await _cameraBugReports.DeleteOneAsync(x => x.Id == id);
    }

    public async Task<bool> IsExistAsync(Guid id)
    {
        var result = await _cameraBugReports
            .Find(x => x.Id == id)
            .FirstOrDefaultAsync();
        return result != null;
    }

    public async Task<List<CameraBugReport>> FilterAsync(
        CameraBugReportType? type = null,
        CameraBugPriority? priority = null,
        CameraBugReportStatus? status = null,
        string searchTerm = null,
        int skip = 0,
        int take = 10)
    {
        var filterDefinition = BuildFilterDefinition(type, priority, status, searchTerm);

        return await _cameraBugReports
            .Find(filterDefinition)
            .Skip(skip)
            .Limit(take)
            .SortByDescending(x => x.CreationDate)
            .ToListAsync();
    }

    public async Task<int> CountAsync(
        CameraBugReportType? type = null,
        CameraBugPriority? priority = null,
        CameraBugReportStatus? status = null,
        string searchTerm = null)
    {
        var filterDefinition = BuildFilterDefinition(type, priority, status, searchTerm);
        var count = await _cameraBugReports.CountDocumentsAsync(filterDefinition);
        return (int)count;
    }

    private FilterDefinition<CameraBugReport> BuildFilterDefinition(
        CameraBugReportType? type = null,
        CameraBugPriority? priority = null,
        CameraBugReportStatus? status = null,
        string searchTerm = null)
    {
        var filters = new List<FilterDefinition<CameraBugReport>>();

        if (type.HasValue)
            filters.Add(Builders<CameraBugReport>.Filter.Eq(x => x.Type, type.Value));

        if (priority.HasValue)
            filters.Add(Builders<CameraBugReport>.Filter.Eq(x => x.Priority, priority.Value));

        if (status.HasValue)
            filters.Add(Builders<CameraBugReport>.Filter.Eq(x => x.Status, status.Value));

        if (!string.IsNullOrEmpty(searchTerm))
        {
            var searchFilter = Builders<CameraBugReport>.Filter.Or(
                Builders<CameraBugReport>.Filter.Regex(x => x.Title, new BsonRegularExpression(searchTerm, "i")),
                Builders<CameraBugReport>.Filter.Regex(x => x.Description, new BsonRegularExpression(searchTerm, "i")),
                Builders<CameraBugReport>.Filter.Regex(x => x.UserEmail, new BsonRegularExpression(searchTerm, "i"))
            );
            filters.Add(searchFilter);
        }

        if (filters.Count == 0)
            return Builders<CameraBugReport>.Filter.Empty;

        return Builders<CameraBugReport>.Filter.And(filters);
    }

    // Sync methods from IRepository interface (not used in MongoDB flow but required for interface implementation)
    public CameraBugReport Get(long id)
    {
        throw new NotImplementedException("استفاده از GetByIdAsync برای MongoDB");
    }

    public List<CameraBugReport> Get()
    {
        throw new NotImplementedException("استفاده از GetAllAsync برای MongoDB");
    }

    public void Create(CameraBugReport entity)
    {
        throw new NotImplementedException("استفاده از CreateAsync برای MongoDB");
    }

    public bool ExistsIgnoreQueryFilter(System.Linq.Expressions.Expression<Func<CameraBugReport, bool>> expression)
    {
        throw new NotImplementedException("استفاده از IsExistAsync برای MongoDB");
    }

    public bool Exists(System.Linq.Expressions.Expression<Func<CameraBugReport, bool>> expression)
    {
        throw new NotImplementedException("استفاده از FilterAsync برای MongoDB");
    }

    public void SaveChanges()
    {
        throw new NotImplementedException("MongoDB نیازی به SaveChanges ندارد");
    }

    public async Task SaveChangesAsync()
    {
        // MongoDB خودکار ذخیره می‌کند، بنابراین این متد خالی است
        await Task.CompletedTask;
    }

    public Task<Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction> BeginTransactionAsync()
    {
        throw new NotImplementedException("MongoDB اعاملات را بصورت متفاوت مدیریت می‌کند");
    }
}