using System.Net;
using System.Net.Http.Json;
using CampusErrand.Data;
using CampusErrand.Models;
using CampusErrand.Models.Dtos;
using FsCheck;
using FsCheck.Xunit;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;

namespace CampusErrand.Tests;

/// <summary>
/// Property 6: 服务入口列表排序与过滤
/// 对任意服务入口数据集合，前端获取接口应仅返回 IsEnabled=true 的记录，且按 SortOrder 升序排列。
/// **Feature: login-and-homepage, Property 6: 服务入口列表排序与过滤**
///
/// </summary>
public class ServiceEntryListPropertyTests : IDisposable
{
    private readonly List<WebApplicationFactory<Program>> _factories = [];

    private WebApplicationFactory<Program> CreateFactory(string dbName)
    {
        var factory = new WebApplicationFactory<Program>()
            .WithWebHostBuilder(builder =>
            {
                builder.ConfigureServices(services =>
                {
                    var efDescriptors = services
                        .Where(d =>
                            d.ServiceType.FullName?.Contains("EntityFrameworkCore") == true
                            || d.ServiceType == typeof(DbContextOptions<AppDbContext>)
                            || d.ServiceType == typeof(DbContextOptions)
                            || d.ImplementationType?.FullName?.Contains("EntityFrameworkCore") == true)
                        .ToList();
                    foreach (var d in efDescriptors) services.Remove(d);

                    services.AddDbContext<AppDbContext>(options =>
                        options.UseInMemoryDatabase(dbName));
                });
            });
        _factories.Add(factory);
        return factory;
    }

    /// <summary>
    /// 属性：前端服务入口接口仅返回已启用的记录，且按 SortOrder 升序排列
    /// </summary>
    [Property(MaxTest = 20)]
    public bool 前端服务入口接口仅返回启用记录且按排序权重升序(NonEmptyArray<byte> sortOrders, NonEmptyArray<bool> enabledFlags)
    {
        var dbName = $"se_list_{Guid.NewGuid()}";
        using var factory = CreateFactory(dbName);

        // 准备测试数据
        using (var scope = factory.Services.CreateScope())
        {
            var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
            var count = Math.Min(sortOrders.Get.Length, enabledFlags.Get.Length);
            for (int i = 0; i < count; i++)
            {
                db.ServiceEntries.Add(new ServiceEntry
                {
                    Name = $"服务{i}",
                    IconUrl = $"https://img.example.com/icon{i}.png",
                    PagePath = $"/pages/service{i}/index",
                    SortOrder = sortOrders.Get[i],
                    IsEnabled = enabledFlags.Get[i]
                });
            }
            db.SaveChanges();
        }

        // 调用前端接口
        var client = factory.CreateClient();
        var response = client.GetAsync("/api/service-entries").Result;
        if (response.StatusCode != HttpStatusCode.OK) return false;

        var entries = response.Content.ReadFromJsonAsync<List<ServiceEntryResponse>>().Result!;

        // 验证：所有返回的服务入口都是启用的
        if (entries.Any(e => !e.IsEnabled)) return false;

        // 验证：按 SortOrder 升序排列
        for (int i = 1; i < entries.Count; i++)
        {
            if (entries[i].SortOrder < entries[i - 1].SortOrder) return false;
        }

        // 验证：返回数量等于启用的服务入口数量
        var count2 = Math.Min(sortOrders.Get.Length, enabledFlags.Get.Length);
        var expectedEnabledCount = enabledFlags.Get.Take(count2).Count(f => f);
        return entries.Count == expectedEnabledCount;
    }

    public void Dispose()
    {
        foreach (var f in _factories) f.Dispose();
        _factories.Clear();
    }
}