using System;
using System.Collections.Generic;
using System.IO;
using System.Text.Json;

namespace StellaOps.Reachability.FixtureTests.PatchOracle;

/// <summary>
/// Loads patch-oracle definitions from fixture files.
/// </summary>
public sealed class PatchOracleLoader
{
    private static readonly JsonSerializerOptions JsonOptions = new()
    {
        PropertyNameCaseInsensitive = true,
        ReadCommentHandling = JsonCommentHandling.Skip,
        AllowTrailingCommas = true
    };

    private readonly string _fixtureRoot;

    public PatchOracleLoader(string fixtureRoot)
    {
        _fixtureRoot = fixtureRoot ?? throw new ArgumentNullException(nameof(fixtureRoot));
    }

    /// <summary>
    /// Loads the oracle index from INDEX.json.
    /// </summary>
    public PatchOracleIndex LoadIndex()
    {
        var indexPath = Path.Combine(_fixtureRoot, "INDEX.json");
        if (!File.Exists(indexPath))
        {
            throw new FileNotFoundException($"Patch-oracle INDEX.json not found at {indexPath}");
        }

        var json = File.ReadAllText(indexPath);
        return JsonSerializer.Deserialize<PatchOracleIndex>(json, JsonOptions)
            ?? throw new InvalidOperationException("Failed to deserialize patch-oracle index");
    }

    /// <summary>
    /// Loads an oracle definition by its ID.
    /// </summary>
    public PatchOracleDefinition LoadOracle(string oracleId)
    {
        var index = LoadIndex();
        var entry = index.Oracles
            .FirstOrDefault(o => string.Equals(o.Id, oracleId, StringComparison.Ordinal))
            ?? throw new KeyNotFoundException($"Oracle '{oracleId}' not found in index");

        return LoadOracleFromPath(entry.Path);
    }

    /// <summary>
    /// Loads an oracle definition from a relative path.
    /// </summary>
    public PatchOracleDefinition LoadOracleFromPath(string relativePath)
    {
        var fullPath = Path.Combine(_fixtureRoot, relativePath);
        if (!File.Exists(fullPath))
        {
            throw new FileNotFoundException($"Oracle file not found at {fullPath}");
        }

        var json = File.ReadAllText(fullPath);
        return JsonSerializer.Deserialize<PatchOracleDefinition>(json, JsonOptions)
            ?? throw new InvalidOperationException($"Failed to deserialize oracle from {fullPath}");
    }

    /// <summary>
    /// Loads all oracles for a specific case.
    /// </summary>
    public IEnumerable<PatchOracleDefinition> LoadOraclesForCase(string caseRef)
    {
        var index = LoadIndex();
        foreach (var entry in index.Oracles.Where(o => string.Equals(o.CaseRef, caseRef, StringComparison.Ordinal)))
        {
            yield return LoadOracleFromPath(entry.Path);
        }
    }

    /// <summary>
    /// Loads all available oracles.
    /// </summary>
    public IEnumerable<PatchOracleDefinition> LoadAllOracles()
    {
        var index = LoadIndex();
        foreach (var entry in index.Oracles)
        {
            yield return LoadOracleFromPath(entry.Path);
        }
    }

    /// <summary>
    /// Enumerates all oracle entries without loading full definitions.
    /// </summary>
    public IEnumerable<PatchOracleIndexEntry> EnumerateOracles()
    {
        var index = LoadIndex();
        return index.Oracles;
    }

    /// <summary>
    /// Checks if the oracle index exists.
    /// </summary>
    public bool IndexExists()
    {
        return File.Exists(Path.Combine(_fixtureRoot, "INDEX.json"));
    }
}