using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Meilisearch;
using meilisearch.NET.Interfaces;
using meilisearch.NET.Models;
using meilisearch.NET.Services.DocumentManagement;
using meilisearch.NET.Services.IndexManagement;
using meilisearch.NET.Services.ProcessManagement;
using Moq;
using Xunit;

namespace meilisearch.NET.Tests
{
    public class MeiliSearchServiceTests
    {
        private readonly Mock<IProcessManager> _mockProcessManager;
        private readonly Mock<IIndexManager> _mockIndexManager;
        private readonly Mock<IDocumentManager> _mockDocumentManager;
        private readonly Mock<MeilisearchClient> _mockClient;
        private readonly MeiliSearchService _service;

        public MeiliSearchServiceTests()
        {
            _mockProcessManager = new Mock<IProcessManager>();
            _mockIndexManager = new Mock<IIndexManager>();
            _mockDocumentManager = new Mock<IDocumentManager>();

            _service = new MeiliSearchService(
                _mockProcessManager.Object,
                _mockIndexManager.Object,
                _mockDocumentManager.Object
            );
        }

        [Fact]
        public async Task Start_CallsProcessManagerStartProcess()
        {
            // Arrange
            _mockProcessManager.Setup(x => x.StartProcess()).Returns(Task.CompletedTask);

            // Act
            await _service.Start();

            // Assert
            _mockProcessManager.Verify(x => x.StartProcess(), Times.Exactly(2));
        }

        [Fact]
        public void GetTotalStorageUsage_CallsIndexManagerWithCorrectParameters()
        {
            // Arrange
            const bool useCompressedSize = true;
            const long expectedUsage = 1000L;
            _mockIndexManager.Setup(x => x.GetTotalStorageUsage(useCompressedSize)).Returns(expectedUsage);

            // Act
            var result = _service.GetTotalStorageUsage(useCompressedSize);

            // Assert
            Assert.Equal(expectedUsage, result);
            _mockIndexManager.Verify(x => x.GetTotalStorageUsage(useCompressedSize), Times.Once);
        }

        [Fact]
        public void GetIndexStorageUsage_CallsIndexManagerWithCorrectParameters()
        {
            // Arrange
            const string indexName = "testIndex";
            const bool useCompressedSize = true;
            const long expectedUsage = 500L;
            _mockIndexManager.Setup(x => x.GetIndexStorageUsage(indexName, useCompressedSize)).Returns(expectedUsage);

            // Act
            var result = _service.GetIndexStorageUsage(indexName, useCompressedSize);

            // Assert
            Assert.Equal(expectedUsage, result);
            _mockIndexManager.Verify(x => x.GetIndexStorageUsage(indexName, useCompressedSize), Times.Once);
        }

        [Fact]
        public void Stop_CallsProcessManagerStopProcess()
        {
            // Act
            _service.Stop();

            // Assert
            _mockProcessManager.Verify(x => x.StopProcess(), Times.Once);
        }

        [Fact]
        public void IsRunning_ReturnsProcessManagerStatus()
        {
            // Arrange
            const bool expectedStatus = true;
            _mockProcessManager.Setup(x => x.IsProcessRunning()).Returns(expectedStatus);

            // Act
            var result = _service.IsRunning();

            // Assert
            Assert.Equal(expectedStatus, result);
            _mockProcessManager.Verify(x => x.IsProcessRunning(), Times.Once);
        }

        [Fact]
        public async Task SetIndexEnabled_CallsIndexManagerWithCorrectParameters()
        {
            // Arrange
            const string indexName = "testIndex";
            const bool enabled = true;
            _mockIndexManager.Setup(x => x.SetIndexEnabledAsync(indexName, enabled)).Returns(Task.CompletedTask);

            // Act
            await _service.SetIndexEnabled(indexName, enabled);

            // Assert
            _mockIndexManager.Verify(x => x.SetIndexEnabledAsync(indexName, enabled), Times.Once);
        }

        [Fact]
        public void GetResourceUsage_ReturnsProcessManagerStats()
        {
            // Arrange
            var expectedStats = new ProcessResourceStats();
            _mockProcessManager.Setup(x => x.GetResourceUsage()).Returns(expectedStats);

            // Act
            var result = _service.GetResourceUsage();

            // Assert
            Assert.Same(expectedStats, result);
            _mockProcessManager.Verify(x => x.GetResourceUsage(), Times.Once);
        }

        [Fact]
        public async Task GetAllIndexes_ReturnsIndexManagerResults()
        {
            // Arrange
            var expectedIndexes = new List<string> { "index1", "index2" };
            _mockIndexManager.Setup(x => x.GetAllIndexes()).ReturnsAsync(expectedIndexes);

            // Act
            var result = await _service.GetAllIndexes();

            // Assert
            Assert.Equal(expectedIndexes, result);
            _mockIndexManager.Verify(x => x.GetAllIndexes(), Times.Once);
        }

        [Fact]
        public async Task CreateIndex_CallsIndexManagerWithCorrectParameters()
        {
            // Arrange
            const string indexName = "testIndex";
            _mockIndexManager.Setup(x => x.CreateIndexAsync<TestDocument>(indexName)).Returns(Task.CompletedTask);

            // Act
            await _service.CreateIndex<TestDocument>(indexName);

            // Assert
            _mockIndexManager.Verify(x => x.CreateIndexAsync<TestDocument>(indexName), Times.Once);
        }

        [Fact]
        public async Task DeleteIndex_CallsIndexManagerWithCorrectParameters()
        {
            // Arrange
            const string indexName = "testIndex";
            _mockIndexManager.Setup(x => x.DeleteIndexAsync(indexName)).Returns(Task.CompletedTask);

            // Act
            await _service.DeleteIndex(indexName);

            // Assert
            _mockIndexManager.Verify(x => x.DeleteIndexAsync(indexName), Times.Once);
        }

        [Fact]
        public void AddDocument_CallsDocumentManagerWithCorrectParameters()
        {
            // Arrange
            const string repositoryId = "testRepo";
            var document = new TestDocument();
            const bool autoCommit = true;

            // Act
            _service.AddDocument(repositoryId, document, autoCommit);

            // Assert
            _mockDocumentManager.Verify(x => x.AddDocument(repositoryId, document, autoCommit), Times.Once);
        }

        [Fact]
        public void Dispose_CallsProcessManagerDispose()
        {
            // Act
            _service.Dispose();

            // Assert
            _mockProcessManager.Verify(x => x.Dispose(), Times.Once);
        }

        // Helper class for testing
        private class TestDocument : IDocument
        {
            public Guid Id { get; set; }
        }
    }
}