using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using GermanApp.Domain.Entities;
using GermanApp.Infrastructure.Data.DbContext;
using GermanApp.Infrastructure.Data.Repositories;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.ChangeTracking;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;

namespace GermanApp.Tests.Unit.Infrastructure.Data.Repositories;

[TestClass]
public class StoryRepositoryTests
{
    private StorySegment CreateSegment(int id, int levelId, int? lessonId, int order)
    {
        var segment = StorySegment.Create(levelId, lessonId, "Content", order, "Title", "Theme");
        typeof(StorySegment).GetProperty("Id")?.SetValue(segment, id);
        return segment;
    }

    [TestMethod]
    public async Task AddAsync_WithNewSegment_AddsToDbSet()
    {
        // Arrange
        var segment = CreateSegment(0, 1, 1, 1);
        var mockDbSet = new Mock<DbSet<StorySegment>>();
        var options = new DbContextOptions<AppDbContext>();
        var mockContext = new Mock<AppDbContext>(options);

        mockDbSet.Setup(d => d.AddAsync(segment, It.IsAny<CancellationToken>()))
            .Returns(ValueTask.FromResult((EntityEntry<StorySegment>?)null));
        mockContext.Setup(c => c.StorySegments).Returns(mockDbSet.Object);
        mockContext.Setup(c => c.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        var repository = new StoryRepository(mockContext.Object);

        // Act
        var result = await repository.AddAsync(segment);

        // Assert
        Assert.IsNotNull(result);
        mockDbSet.Verify(d => d.AddAsync(segment, It.IsAny<CancellationToken>()), Times.Once);
        mockContext.Verify(c => c.SaveChangesAsync(It.IsAny<CancellationToken>()), Times.Once);
    }

    [TestMethod]
    public async Task UpdateAsync_WithExistingSegment_UpdatesDbSet()
    {
        // Arrange
        var segment = CreateSegment(1, 1, 1, 1);
        var mockDbSet = new Mock<DbSet<StorySegment>>();
        var options = new DbContextOptions<AppDbContext>();
        var mockContext = new Mock<AppDbContext>(options);

        mockContext.Setup(c => c.StorySegments).Returns(mockDbSet.Object);
        mockContext.Setup(c => c.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        var repository = new StoryRepository(mockContext.Object);

        // Act
        await repository.UpdateAsync(segment);

        // Assert
        mockDbSet.Verify(d => d.Update(segment), Times.Once);
        mockContext.Verify(c => c.SaveChangesAsync(It.IsAny<CancellationToken>()), Times.Once);
    }

    [TestMethod]
    public async Task DeleteAsync_WithExistingId_RemovesFromDbSet()
    {
        // Arrange
        var segment = CreateSegment(1, 1, 1, 1);
        var mockDbSet = new Mock<DbSet<StorySegment>>();
        var options = new DbContextOptions<AppDbContext>();
        var mockContext = new Mock<AppDbContext>(options);

        mockDbSet.Setup(d => d.FindAsync(new object[] { 1 }, It.IsAny<CancellationToken>()))
            .ReturnsAsync(segment);
        mockContext.Setup(c => c.StorySegments).Returns(mockDbSet.Object);
        mockContext.Setup(c => c.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        var repository = new StoryRepository(mockContext.Object);

        // Act
        await repository.DeleteAsync(1);

        // Assert
        mockDbSet.Verify(d => d.Remove(segment), Times.Once);
        mockContext.Verify(c => c.SaveChangesAsync(It.IsAny<CancellationToken>()), Times.Once);
    }

    [TestMethod]
    public async Task DeleteAsync_WithNonExistingId_DoesNotThrow()
    {
        // Arrange
        var mockDbSet = new Mock<DbSet<StorySegment>>();
        var options = new DbContextOptions<AppDbContext>();
        var mockContext = new Mock<AppDbContext>(options);

        mockDbSet.Setup(d => d.FindAsync(new object[] { 999 }, It.IsAny<CancellationToken>()))
            .ReturnsAsync((StorySegment?)null);
        mockContext.Setup(c => c.StorySegments).Returns(mockDbSet.Object);
        mockContext.Setup(c => c.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        var repository = new StoryRepository(mockContext.Object);

        // Act & Assert (should not throw)
        await repository.DeleteAsync(999);
        mockDbSet.Verify(d => d.Remove(It.IsAny<StorySegment>()), Times.Never);
    }
}