using System.Reflection;
using Api.SeaHavenIndustries.Controllers;
using Data.SeaHavenIndustries;
using FluentAssertions;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using SeaHaven.DataServices.Implementation;
using SeaHaven.Services.Implementation;
using Xunit;

namespace Api.SeaHavenIndustries.Tests;

public class ArchitectureTests
{
    private static readonly Assembly ApiAssembly = typeof(VendorPortalController).Assembly;
    private static readonly Assembly ServicesAssembly = typeof(VendorService).Assembly;
    private static readonly Assembly DataServicesAssembly = typeof(VendorDataService).Assembly;

    private const string ServiceImplementationNamespace = "SeaHaven.Services.Implementation";
    private const string DataServiceImplementationNamespace = "SeaHaven.DataServices.Implementation";

    private static IEnumerable<Type> ApiControllers =>
        ApiAssembly.GetTypes()
            .Where(t => t.IsClass && !t.IsAbstract && typeof(ControllerBase).IsAssignableFrom(t));

    private static IEnumerable<Type> BusinessServiceImplementations =>
        ServicesAssembly.GetTypes()
            .Where(t => t.IsClass && !t.IsAbstract && !t.IsGenericType)
            .Where(t => t.GetInterfaces().Any(i => i.Name == "I" + t.Name));

    private static bool IsConcrete(Type type) => type.IsClass && !type.IsAbstract && !type.IsInterface;

    private static bool IsDbContext(Type type) => typeof(DbContext).IsAssignableFrom(type);

    private static bool IsConcreteServiceImplementation(Type type) =>
        type.Namespace == ServiceImplementationNamespace && IsConcrete(type);

    private static bool IsConcreteDataService(Type type) =>
        type.Namespace == DataServiceImplementationNamespace && IsConcrete(type);

    private static IEnumerable<ParameterInfo> ParametersOf(IEnumerable<Type> types) =>
        types.SelectMany(t => t.GetConstructors().SelectMany(c => c.GetParameters()));

    [Fact]
    public void Controllers_DoNotInject_DbContext_ConcreteDataServices_Or_ConcreteServiceImplementations()
    {
        ApiControllers.Should().NotBeEmpty("the API must expose controllers for this invariant to be meaningful");

        var violations = ParametersOf(ApiControllers)
            .Where(p => IsDbContext(p.ParameterType)
                        || IsConcreteDataService(p.ParameterType)
                        || IsConcreteServiceImplementation(p.ParameterType))
            .Select(p => $"{p.Member.DeclaringType!.Name} depends on {p.ParameterType.FullName} ({p.Name})")
            .ToList();

        violations.Should().BeEmpty(
            "controllers must depend only on interfaces/abstractions, never on DbContext, concrete data services, or concrete service implementations");
    }

    [Fact]
    public void BusinessServices_DoNotInject_DbContext_Or_IConfiguration()
    {
        BusinessServiceImplementations.Should().NotBeEmpty(
            "business services must be discovered for this invariant to be meaningful");

        var violations = ParametersOf(BusinessServiceImplementations)
            .Where(p => IsDbContext(p.ParameterType)
                        || typeof(IConfiguration).IsAssignableFrom(p.ParameterType))
            .Select(p => $"{p.Member.DeclaringType!.Name} depends on {p.ParameterType.FullName} ({p.Name})")
            .ToList();

        violations.Should().BeEmpty(
            "business services must depend on data-service interfaces and typed options, never on DbContext or IConfiguration");
    }

    [Fact]
    public void BusinessServices_DependOnInterfaces_NotConcreteServiceOrDataServiceImplementations()
    {
        // Guards the feature-specific interface boundary: a business service must
        // depend on I{Feature}DataService / I{Feature}Service abstractions, never on
        // concrete service or data-service implementations (no generic-repository
        // theater and no coupling to persistence implementations).
        BusinessServiceImplementations.Should().NotBeEmpty(
            "business services must be discovered for this invariant to be meaningful");

        var violations = ParametersOf(BusinessServiceImplementations)
            .Where(p => IsConcreteServiceImplementation(p.ParameterType)
                        || IsConcreteDataService(p.ParameterType))
            .Select(p => $"{p.Member.DeclaringType!.Name} depends on {p.ParameterType.FullName} ({p.Name})")
            .ToList();

        violations.Should().BeEmpty(
            "business services must depend on interfaces (I{Feature}Service / I{Feature}DataService), "
            + "never on concrete service or data-service implementations");
    }
}