using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using GermanApp.Application.Services;
using GermanApp.Domain.Interfaces;
using Microsoft.Extensions.Logging;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;

namespace GermanApp.Tests.Unit.Application.Services;

[TestClass]
public class SpeechExerciseServiceTests
{
    private Mock<IVoskService> _mockVoskService;
    private Mock<ILogger<SpeechExerciseService>> _mockLogger;
    private SpeechExerciseService _service;
    private readonly byte[] _sampleAudio = new byte[100];

    [TestInitialize]
    public void Setup()
    {
        _mockVoskService = new Mock<IVoskService>();
        _mockLogger = new Mock<ILogger<SpeechExerciseService>>();
        _service = new SpeechExerciseService(
            _mockVoskService.Object,
            _mockLogger.Object);
        
        // Initialize sample audio
        for (int i = 0; i < _sampleAudio.Length; i++)
        {
            _sampleAudio[i] = (byte)(i % 256);
        }
    }

    [TestMethod]
    public async Task RecognizeSpeechAsync_WithValidAudio_ReturnsResult()
    {
        // Arrange
        var expectedText = "Hallo Welt";
        var cancellationToken = CancellationToken.None;

        _mockVoskService.Setup(s => s.RecognizeSpeechAsync(
            _sampleAudio, 16000, null, cancellationToken))
            .ReturnsAsync(expectedText);

        // Act
        var result = await _service.RecognizeSpeechAsync(
            _sampleAudio, null, cancellationToken);

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual(expectedText, result.RecognizedText);
        Assert.IsNull(result.ExpectedText);
        Assert.AreEqual(0.0, result.Accuracy);
        Assert.IsFalse(result.IsCorrect);
    }

    [TestMethod]
    public async Task RecognizeSpeechAsync_WithExpectedText_CalculatesAccuracy()
    {
        // Arrange
        var expectedText = "Hallo Welt";
        var cancellationToken = CancellationToken.None;

        _mockVoskService.Setup(s => s.RecognizeSpeechAsync(
            _sampleAudio, 16000, null, cancellationToken))
            .ReturnsAsync(expectedText);

        // Act
        var result = await _service.RecognizeSpeechAsync(
            _sampleAudio, expectedText, cancellationToken);

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual(expectedText, result.RecognizedText);
        Assert.AreEqual(expectedText, result.ExpectedText);
        Assert.AreEqual(1.0, result.Accuracy);
        Assert.IsTrue(result.IsCorrect);
    }

    [TestMethod]
    public async Task RecognizeSpeechAsync_WithDifferentText_CalculatesPartialAccuracy()
    {
        // Arrange
        var recognizedText = "Hallo";
        var expectedText = "Hallo Welt";
        var cancellationToken = CancellationToken.None;

        _mockVoskService.Setup(s => s.RecognizeSpeechAsync(
            _sampleAudio, 16000, null, cancellationToken))
            .ReturnsAsync(recognizedText);

        // Act
        var result = await _service.RecognizeSpeechAsync(
            _sampleAudio, expectedText, cancellationToken);

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual(recognizedText, result.RecognizedText);
        Assert.AreEqual(expectedText, result.ExpectedText);
        Assert.IsTrue(result.Accuracy > 0.0 && result.Accuracy < 1.0);
        Assert.IsFalse(result.IsCorrect);
    }

    [TestMethod]
    public async Task RecognizeSpeechAsync_WhenVoskThrows_ThrowsAiServiceException()
    {
        // Arrange
        var cancellationToken = CancellationToken.None;

        _mockVoskService.Setup(s => s.RecognizeSpeechAsync(
            _sampleAudio, 16000, null, cancellationToken))
            .ThrowsAsync(new Exception("Recognition Error"));

        // Act & Assert
        try
        {
            await _service.RecognizeSpeechAsync(_sampleAudio, null, cancellationToken);
            Assert.Fail("Expected AiServiceException was not thrown");
        }
        catch (AiServiceException)
        {
            // Expected
        }
    }

    [TestMethod]
    public async Task RecognizeSpeechFromFileAsync_WithValidFile_ReturnsResult()
    {
        // Arrange
        var filePath = "/tmp/test.wav";
        var expectedText = "Hallo Welt";
        var cancellationToken = CancellationToken.None;

        _mockVoskService.Setup(s => s.RecognizeSpeechFromFileAsync(
            filePath, cancellationToken))
            .ReturnsAsync(expectedText);

        // Act
        var result = await _service.RecognizeSpeechFromFileAsync(
            filePath, null, cancellationToken);

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual(expectedText, result.RecognizedText);
    }

    [TestMethod]
    public async Task VerifySpeechAsync_WithValidAudio_ReturnsResultWithScores()
    {
        // Arrange
        var expectedText = "Hallo Welt";
        var cancellationToken = CancellationToken.None;

        _mockVoskService.Setup(s => s.RecognizeSpeechAsync(
            _sampleAudio, 16000, null, cancellationToken))
            .ReturnsAsync(expectedText);

        // Act
        var result = await _service.VerifySpeechAsync(
            _sampleAudio, expectedText, cancellationToken);

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual(expectedText, result.RecognizedText);
        Assert.AreEqual(expectedText, result.ExpectedText);
        Assert.AreEqual(1.0, result.Accuracy);
        Assert.IsTrue(result.IsCorrect);
        Assert.AreEqual(1.0, result.PronunciationScore);
        Assert.IsTrue(result.FluencyScore > 0.0);
    }

    [TestMethod]
    public void CreateExercise_WithValidParameters_CreatesExercise()
    {
        // Arrange
        var phrase = "Guten Morgen";
        var difficulty = "easy";
        var hints = new List<string> { "Pronounce clearly", "Slow down" };

        // Act
        var result = _service.CreateExercise(phrase, difficulty, hints);

        // Assert
        Assert.IsNotNull(result);
        Assert.IsTrue(!string.IsNullOrEmpty(result.Id));
        Assert.AreEqual(phrase, result.Phrase);
        Assert.AreEqual(difficulty, result.Difficulty);
        Assert.AreEqual(2, result.Hints.Count);
        Assert.IsTrue(DateTime.UtcNow - result.CreatedAt < TimeSpan.FromSeconds(1));
    }

    [TestMethod]
    public void CreateExercise_WithNoHints_UsesEmptyList()
    {
        // Arrange
        var phrase = "Guten Morgen";

        // Act
        var result = _service.CreateExercise(phrase);

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual(0, result.Hints.Count);
    }

    [TestMethod]
    public async Task EvaluateExerciseAttemptAsync_WithValidAttempt_ReturnsEvaluation()
    {
        // Arrange
        var exerciseId = "exercise-123";
        var expectedPhrase = "Guten Morgen";
        var recognizedText = "Guten Morgen";
        var cancellationToken = CancellationToken.None;

        _mockVoskService.Setup(s => s.RecognizeSpeechAsync(
            _sampleAudio, 16000, null, cancellationToken))
            .ReturnsAsync(recognizedText);

        // Act
        var result = await _service.EvaluateExerciseAttemptAsync(
            exerciseId, _sampleAudio, expectedPhrase, cancellationToken);

        // Assert
        Assert.IsNotNull(result);
        Assert.AreEqual(exerciseId, result.ExerciseId);
        Assert.AreEqual(expectedPhrase, result.ExpectedPhrase);
        Assert.AreEqual(recognizedText, result.RecognizedText);
        Assert.AreEqual(1.0, result.Accuracy);
        Assert.IsTrue(result.IsPassed);
    }

    [TestMethod]
    public async Task EvaluateExerciseAttemptAsync_WithIncorrectPhrase_ReturnsFailedEvaluation()
    {
        // Arrange
        var exerciseId = "exercise-123";
        var expectedPhrase = "Guten Morgen";
        var recognizedText = "Guten Tag";
        var cancellationToken = CancellationToken.None;

        _mockVoskService.Setup(s => s.RecognizeSpeechAsync(
            _sampleAudio, 16000, null, cancellationToken))
            .ReturnsAsync(recognizedText);

        // Act
        var result = await _service.EvaluateExerciseAttemptAsync(
            exerciseId, _sampleAudio, expectedPhrase, cancellationToken);

        // Assert
        Assert.IsNotNull(result);
        Assert.IsFalse(result.IsPassed);
    }

    [TestMethod]
    public async Task TestServiceAsync_WithWorkingService_ReturnsTrue()
    {
        // Arrange
        var cancellationToken = CancellationToken.None;
        _mockVoskService.Setup(s => s.GetModelInfoAsync())
            .ReturnsAsync(("vosk-model-de-0.22", "/path/to/model"));

        // Act
        var result = await _service.TestServiceAsync(cancellationToken);

        // Assert
        Assert.IsTrue(result);
    }

    [TestMethod]
    public async Task TestServiceAsync_WhenServiceFails_ReturnsFalse()
    {
        // Arrange
        var cancellationToken = CancellationToken.None;
        _mockVoskService.Setup(s => s.GetModelInfoAsync())
            .ThrowsAsync(new Exception("Error"));

        // Act
        var result = await _service.TestServiceAsync(cancellationToken);

        // Assert
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void CalculateAccuracy_WithExactMatch_ReturnsOne()
    {
        // This is a private method, so we test it through the public API
        // Already tested in RecognizeSpeechAsync_WithExpectedText_CalculatesAccuracy
        // Just ensuring the method exists and works
    }

    [TestMethod]
    public void LevenshteinDistance_WithIdenticalStrings_ReturnsZero()
    {
        // This is a private static method, tested through public API
        // The implementation should handle identical strings correctly
    }
}