using System.Text;
using System.Buffers.Binary;
using System.IO.Compression;
using Ludarium.Application;
using Ludarium.Domain;
using OpenMcdf;

namespace Ludarium.UnitTests;

public sealed class AnalysisTests
{
    [Theory]
    [InlineData("3DS/LIMBO/BLUEROMS.WS.html")]
    [InlineData("3DS/World of Goo/download.htm")]
    public void WebPagesAreSupportArtifactsRatherThanGames(string path)
    {
        var result = Assert.IsType<NonGamePath>(LibraryContentPolicy.IdentifyNonGamePath(path));
        Assert.Equal("NonGameSupport", result.Category);
        Assert.StartsWith("web-page:", result.Evidence);
    }
    [Theory]
    [InlineData("roms/Tools/Switch/prod.keys")]
    [InlineData("PC/.gameyfin/cache/cover.jpg")]
    [InlineData("Game/runtime/libSceAudioOut.prx")]
    [InlineData("roms/PS2/BIOS/scph39001.bin")]
    [InlineData("roms/Switch/keys/prod.keys")]
    [InlineData("PC/Game/manuals/manual.pdf")]
    [InlineData("roms/N64/Game/readme.txt")]
    public void NonGameDirectoriesAreDeterministicallyIdentified(string path)
    {
        Assert.NotNull(LibraryContentPolicy.IdentifyNonGamePath(path));
        Assert.NotNull(LibraryContentPolicy.IdentifyNonGamePath("PC/FMT-v23.23.2/FMT/FMT.exe"));
        Assert.NotNull(LibraryContentPolicy.IdentifyNonGamePath("PC/Steam/steam.exe"));
        Assert.NotNull(LibraryContentPolicy.IdentifyNonGamePath("PC/Game DLC Unlocker/tool.exe"));
        Assert.NotNull(LibraryContentPolicy.IdentifyNonGamePath("PC/Steam/steamapps/common/tool.dll"));
        Assert.NotNull(LibraryContentPolicy.IdentifyNonGamePath("roms/Tools/Emulators/retroarch.exe"));
    }

    [Theory]
    [InlineData("Super Mario 64 (USA) (Rev 1).z64", "Super Mario 64")]
    [InlineData("Asterix.and.Obelix.Mission.Babylon-DUPLEX", "Asterix and Obelix Mission Babylon")]
    [InlineData("Fallout 4 [FitGirl Repack]", "Fallout 4")]
    [InlineData("Metal Gear Solid (Disc 2)", "Metal Gear Solid")]
    [InlineData("0002 - Need for Speed - Underground 2 (USA).zip", "Need for Speed - Underground 2")]
    [InlineData("Animal Crossing- City Folk [RUUE01].wbfs", "Animal Crossing- City Folk")]
    [InlineData("Pokemon Diamond USA NDS-LGC.nds", "Pokemon Diamond")]
    [InlineData("Asterix and Obelix Mission Babylon PS5", "Asterix and Obelix Mission Babylon")]
    [InlineData("Assassins's Creed 4 - Black Flag", "Assassin's Creed 4 - Black Flag")]
    [InlineData("Call of Duty - Black Ops 6 PS5 iNTERNAL-PS5B", "Call of Duty - Black Ops 6")]
    [InlineData("Crash Bandicoot - The Wrath of Cortex (USA) (v1", "Crash Bandicoot - The Wrath of Cortex")]
    [InlineData("Crash Team Racing [U] [SCUS-94426]", "Crash Team Racing")]
    [InlineData("Burnout Legends", "Burnout Legends")]
    [InlineData("The Darkness", "The Darkness")]
    public void CanonicalTitlesRemovePackagingNoise(string raw, string expected)
    {
        Assert.Equal(expected, LibraryContentPolicy.CanonicalGameTitle(raw));
    }

    [Fact]
    public void RomHeaderEvidenceNeverContainsDatabaseInvalidControlCharacters()
    {
        var header = new byte[0xC0];
        "TEST\0TITLE"u8.CopyTo(header.AsSpan(0xA0));
        header[0xB2] = 0x96;
        var result = ArtifactAnalysis.Classify("synthetic.gba", header);
        Assert.DoesNotContain(result.Evidence, item => item.Value.Any(char.IsControl));
    }
    [Fact]
    public async Task HashesAreStreamedAndMatchKnownVectors()
    {
        await using var stream = new MemoryStream("abc"u8.ToArray());
        var result = await ArtifactAnalysis.HashAsync(stream, true, CancellationToken.None);
        Assert.Equal("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", result.Sha256);
        Assert.Equal("a9993e364706816aba3e25717850c26c9cd0d89d", result.Sha1);
        Assert.Equal("c2412435", result.Crc32);
        Assert.Equal(3, result.BytesRead);
    }

    [Theory]
    [InlineData("game.nes", new byte[] { 0x4e, 0x45, 0x53, 0x1a }, MediaType.Rom, Confidence.Deterministic)]
    [InlineData("setup.exe", new byte[] { 0x4d, 0x5a }, MediaType.WindowsPackage, Confidence.Deterministic)]
    [InlineData("archive.zip", new byte[] { 0x50, 0x4b, 0x03, 0x04 }, MediaType.Archive, Confidence.Deterministic)]
    [InlineData("mystery.bin", new byte[] { 0x00 }, MediaType.Unknown, Confidence.None)]
    public void ClassificationUsesSignatureEvidence(string name, byte[] header, MediaType expected, Confidence confidence)
    {
        var result = ArtifactAnalysis.Classify(name, header);
        Assert.Equal(expected, result.MediaType); Assert.Equal(confidence, result.Confidence);
        Assert.Equal(expected != MediaType.Unknown, result.Supported);
    }

    [Fact]
    public void CueParserHandlesQuotedAndUnquotedReferences()
    {
        var refs = ArtifactAnalysis.ParseCueReferences("FILE \"Disc 1.bin\" BINARY\n FILE Disc2.bin BINARY");
        Assert.Equal(["Disc 1.bin", "Disc2.bin"], refs);
    }

    [Fact]
    public void M3uParserPreservesOrderAndIgnoresComments()
    {
        Assert.Equal(["Disc 2.cue", "Disc 1.cue"], ArtifactAnalysis.ParseM3uReferences("#EXTM3U\nDisc 2.cue\nDisc 1.cue"));
    }

    [Theory]
    [InlineData("../outside.bin", false)]
    [InlineData("tracks/disc.bin", true)]
    [InlineData("/absolute.bin", false)]
    public void DescriptorReferencesCannotEscapeRoot(string path, bool safe) => Assert.Equal(safe, ArtifactAnalysis.IsSafeRelativeReference(path));

    [Fact]
    public void ScanStateMachineRejectsInvalidTransitions()
    {
        var run = new ScanRun(Guid.NewGuid(), Guid.NewGuid(), ScanMode.Quick, ScanState.Queued, "Queued", 0, null, 0, null, null, false, DateTimeOffset.UtcNow);
        Assert.Equal(ScanState.Verifying, run.Transition(ScanState.Verifying, "Verify").State);
        Assert.Throws<InvalidOperationException>(() => run.Transition(ScanState.Completed, "Complete"));
    }

    [Fact]
    public void LibraryRequiresAbsolutePath() => Assert.Throws<ArgumentException>(() => LibraryRoot.Create("ROMs", "relative", LibraryKind.Rom));

    [Fact]
    public void PeInspectionReadsArchitectureWithoutExecutingImage()
    {
        using var stream = File.OpenRead(typeof(AnalysisTests).Assembly.Location);
        var result = WindowsPackageAnalysis.InspectPe(stream);
        Assert.True(result.IsManaged);
        Assert.True(result.Kind is "library" or "executable");
        Assert.NotEqual(Confidence.None, result.Confidence);
        Assert.Contains("ProductVersion", result.VersionInfo.Keys);
        Assert.Contains(result.Evidence, item => item.Kind == "pe.version.ProductVersion");
    }

    [Fact]
    public void NumberedInstallerPayloadGapsAreDetected() =>
        Assert.Equal([2], WindowsPackageAnalysis.MissingNumberedPayloads(["setup-1.bin", "setup-3.bin"]));

    [Fact]
    public void MsiSummaryInformationIsReadWithoutInvokingWindowsInstaller()
    {
        var path = Path.Combine(Path.GetTempPath(), $"ludarium-{Guid.NewGuid():N}.msi");
        try
        {
            using (var root = RootStorage.Create(path))
            using (var summary = root.CreateStream("\u0005SummaryInformation"))
                summary.Write(CreateSummaryPropertySet((2, "Synthetic Installer"), (4, "Ludarium Tests"),
                    (7, "x64;1033"), (9, "{11111111-2222-3333-4444-555555555555}")));

            var result = WindowsPackageAnalysis.InspectMsiSummary(path);

            Assert.Equal("Synthetic Installer", result["Title"]);
            Assert.Equal("Ludarium Tests", result["Author"]);
            Assert.Equal("x64", result["Architecture"]);
            Assert.Equal("1033", result["Language"]);
            Assert.Equal("{11111111-2222-3333-4444-555555555555}", result["PackageCode"]);
        }
        finally { File.Delete(path); }
    }

    [Theory]
    [InlineData("game.z64", new byte[] { 0x80, 0x37, 0x12, 0x40 }, "n64")]
    [InlineData("game.v64", new byte[] { 0x37, 0x80, 0x40, 0x12 }, "n64")]
    [InlineData("game.n64", new byte[] { 0x40, 0x12, 0x37, 0x80 }, "n64")]
    [InlineData("game.gba", new byte[] { 0, 0, 0, 0, 0x24, 0xff, 0xae, 0x51 }, "gba")]
    public void RomHeadersOverrideExtensionHints(string name, byte[] header, string platform)
    {
        var result = ArtifactAnalysis.Classify(name, header);
        Assert.Equal(MediaType.Rom, result.MediaType);
        Assert.Equal(platform, result.Platform);
        Assert.Equal(Confidence.Deterministic, result.Confidence);
    }

    [Theory]
    [InlineData("game.cso", new byte[] { 0x43, 0x49, 0x53, 0x4f }, "psp", "PSP CSO")]
    [InlineData("game.nsp", new byte[] { 0x50, 0x46, 0x53, 0x30 }, "switch", "Switch PFS0")]
    public void ModernContainerSignaturesProvideDeterministicPlatformEvidence(string name, byte[] header,
        string platform, string signature)
    {
        var result = ArtifactAnalysis.Classify(name, header);

        Assert.Equal(MediaType.DiscImage, result.MediaType);
        Assert.Equal(platform, result.Platform);
        Assert.Equal(Confidence.Deterministic, result.Confidence);
        Assert.Contains(result.Evidence, item => item.Kind == "signature" && item.Value == signature);
    }

    [Fact]
    public void SwitchXciHeaderIsDetectedAtItsSpecifiedOffset()
    {
        var header = new byte[0x104];
        "HEAD"u8.CopyTo(header.AsSpan(0x100));

        var result = ArtifactAnalysis.Classify("game.xci", header);

        Assert.Equal("switch", result.Platform);
        Assert.Equal(Confidence.Deterministic, result.Confidence);
        Assert.Contains(result.Evidence, item => item.Value == "Switch XCI");

        var misplaced = ArtifactAnalysis.Classify("roms/PS2/game.xci", header, "ps2");
        Assert.Equal("switch", misplaced.Platform);
        Assert.Contains(misplaced.Evidence, item => item.Kind == "platform.conflict" &&
            item.Value == "directory:ps2;signature:switch");
    }

    [Theory]
    [InlineData("psx")]
    [InlineData("ps2")]
    [InlineData("psp")]
    public async Task Iso9660ContentsIdentifyPlayStationFamiliesWithoutDirectoryHints(string expectedPlatform)
    {
        await using var iso = new MemoryStream(CreatePlayStationIso(expectedPlatform));

        var result = await DiscImageAnalysis.InspectIsoAsync(iso, CancellationToken.None);

        Assert.Equal(expectedPlatform, result.Platform);
        Assert.Equal(Confidence.Deterministic, result.Confidence);
        Assert.Contains(result.Evidence, item => item.Kind == "disc.signature" && item.Value == "ISO9660-CD001");
        Assert.Contains(result.Evidence, item => item.Kind == "disc.platform" && item.Value.StartsWith(expectedPlatform + ":", StringComparison.Ordinal));
    }

    [Fact]
    public async Task TruncatedOrGenericIsoNeverInventsAPlatform()
    {
        await using var truncated = new MemoryStream(new byte[1024]);
        Assert.Null((await DiscImageAnalysis.InspectIsoAsync(truncated, CancellationToken.None)).Platform);

        await using var generic = new MemoryStream(CreatePlayStationIso(null));
        var result = await DiscImageAnalysis.InspectIsoAsync(generic, CancellationToken.None);
        Assert.Null(result.Platform);
        Assert.Contains(result.Evidence, item => item.Kind == "disc.signature");
    }

    [Theory]
    [InlineData(false, "psp")]
    [InlineData(true, "psx")]
    public async Task PbpPayloadDeterministicallyDistinguishesPspHomebrewFromPsx(bool psx, string expected)
    {
        var bytes = new byte[96];
        "\0PBP"u8.CopyTo(bytes);
        BinaryPrimitives.WriteUInt32LittleEndian(bytes.AsSpan(4, 4), 0x00010000);
        var offsets = psx
            ? new uint[] { 40, 40, 40, 40, 40, 40, 40, 64 }
            : new uint[] { 40, 40, 40, 40, 40, 40, 40, 96 };
        for (var index = 0; index < offsets.Length; index++)
            BinaryPrimitives.WriteUInt32LittleEndian(bytes.AsSpan(8 + index * 4, 4), offsets[index]);
        if (psx) "PSISOIMG"u8.CopyTo(bytes.AsSpan(64));
        else new byte[] { 0x7f, (byte)'E', (byte)'L', (byte)'F' }.CopyTo(bytes.AsSpan(40));

        await using var stream = new MemoryStream(bytes);
        var result = await DiscImageAnalysis.InspectPbpAsync(stream, CancellationToken.None);

        Assert.Equal(expected, result.Platform);
        Assert.Equal(Confidence.Deterministic, result.Confidence);
        Assert.Contains(result.Evidence, item => item.Kind == "disc.signature" && item.Value == "PBP");
    }

    [Fact]
    public async Task ReproduciblePspHomebrewFixturePassesTheExactPbpInspector()
    {
        await using var compressed = File.OpenRead(Path.Combine(AppContext.BaseDirectory, "fixtures", "ludarium-psp-fixture.pbp.gz"));
        await using var gzip = new GZipStream(compressed, CompressionMode.Decompress);
        await using var fixture = new MemoryStream();
        await gzip.CopyToAsync(fixture);
        fixture.Position = 0;

        var result = await DiscImageAnalysis.InspectPbpAsync(fixture, CancellationToken.None);

        Assert.Equal(130008, fixture.Length);
        Assert.Equal("psp", result.Platform);
        Assert.Contains(result.Evidence, item => item.Kind == "disc.platform" && item.Value == "psp:PBP:ELF");
    }

    [Fact]
    public async Task PbpInspectorRejectsNonMonotonicOffsets()
    {
        var bytes = new byte[64];
        "\0PBP"u8.CopyTo(bytes);
        for (var index = 0; index < 8; index++)
            BinaryPrimitives.WriteUInt32LittleEndian(bytes.AsSpan(8 + index * 4, 4), (uint)(40 + index));
        BinaryPrimitives.WriteUInt32LittleEndian(bytes.AsSpan(24, 4), 39);

        await using var stream = new MemoryStream(bytes);
        var result = await DiscImageAnalysis.InspectPbpAsync(stream, CancellationToken.None);

        Assert.Null(result.Platform);
        Assert.Equal(Confidence.None, result.Confidence);
        Assert.Empty(result.Evidence);
    }

    [Fact]
    public void NintendoDsHeaderProvidesSemanticEvidence()
    {
        var header = new byte[0x160];
        Encoding.ASCII.GetBytes("SYNTHETIC DS").CopyTo(header, 0);
        Encoding.ASCII.GetBytes("ALPE").CopyTo(header, 12);
        Encoding.ASCII.GetBytes("01").CopyTo(header, 16);
        header[18] = 0; header[30] = 2;
        new byte[] { 0x24, 0xff, 0xae, 0x51 }.CopyTo(header, 0xC0);

        var result = ArtifactAnalysis.Classify("unknown.bin", header);

        Assert.Equal("nds", result.Platform);
        Assert.Equal(Confidence.Deterministic, result.Confidence);
        Assert.Contains(result.Evidence, item => item.Kind == "rom.title" && item.Value == "SYNTHETIC DS");
        Assert.Contains(result.Evidence, item => item.Kind == "rom.gameCode" && item.Value == "ALPE");
        Assert.Contains(result.Evidence, item => item.Kind == "rom.region" && item.Value == "usa");
    }

    [Theory]
    [InlineData(0x7FC0)]
    [InlineData(0x81C0)]
    public void SnesHeadersWithAndWithoutCopierPrefixAreDetected(int headerOffset)
    {
        var header = new byte[headerOffset + 0x20];
        Encoding.ASCII.GetBytes("SYNTHETIC SNES").CopyTo(header, headerOffset);
        header[headerOffset + 0x15] = 0x20;
        header[headerOffset + 0x19] = 1;
        BitConverter.GetBytes((ushort)0xEDCB).CopyTo(header, headerOffset + 0x1C);
        BitConverter.GetBytes((ushort)0x1234).CopyTo(header, headerOffset + 0x1E);

        var result = ArtifactAnalysis.Classify("cartridge.dat", header);

        Assert.Equal(MediaType.Rom, result.MediaType);
        Assert.Equal("snes", result.Platform);
        Assert.Contains(result.Evidence, item => item.Kind == "rom.title" && item.Value == "SYNTHETIC SNES");
    }

    [Fact]
    public void InvalidSnesChecksumDoesNotCreateFalseSignature()
    {
        var header = new byte[0x8000];
        header[0x7FD5] = 0x20;
        Assert.Equal(MediaType.Unknown, ArtifactAnalysis.Classify("unknown.dat", header).MediaType);
    }

    [Theory]
    [InlineData("Games", "/library/games", "PC/Example/setup.bin", "windows")]
    [InlineData("Games", "/library/games", "roms/3ds/Example/game.3ds", "3ds")]
    [InlineData("Games", "/library/games", "roms/PS1/Example/disc.cue", "psx")]
    [InlineData("Games", "/library/games", "roms/ngc/Example/game.rvz", "gamecube")]
    [InlineData("PS4 Games", "/library/ps4", "Example/game.pkg", "ps4")]
    [InlineData("PS5 Games", "/library/ps5", "Example/game.pkg", "ps5")]
    public void PlatformHintsFollowConfiguredDirectoryTaxonomy(string libraryName, string libraryPath, string relativePath, string expected) =>
        Assert.Equal(expected, ArtifactAnalysis.InferPlatformHint(libraryName, libraryPath, relativePath));

    [Fact]
    public void DirectoryHintClassifiesPlatformWithoutOverridingDeterministicFormatEvidence()
    {
        var hinted = ArtifactAnalysis.Classify("roms/PS2/game.iso", ReadOnlySpan<byte>.Empty, "ps2");
        Assert.Equal("ps2", hinted.Platform);
        Assert.Contains(hinted.Evidence, evidence => evidence.Kind == "directory.platform" && evidence.Value == "ps2");

        var signatureWins = ArtifactAnalysis.Classify("roms/PS2/misplaced.nes", new byte[] { 0x4e, 0x45, 0x53, 0x1a }, "ps2");
        Assert.Equal("nes", signatureWins.Platform);

        var multipartVolume = ArtifactAnalysis.Classify("PS5-Release/part.v64", ReadOnlySpan<byte>.Empty, "ps5");
        Assert.Equal("ps5", multipartVolume.Platform);
        Assert.Equal(MediaType.Unknown, multipartVolume.MediaType);
        Assert.Contains(multipartVolume.Evidence, evidence => evidence.Kind == "platform.conflict");
    }

    private static byte[] CreateSummaryPropertySet(params (int Id, string Value)[] properties)
    {
        var encoded = properties.Select(property =>
        {
            var value = Encoding.Latin1.GetBytes(property.Value + '\0');
            var length = 8 + value.Length;
            var padded = (length + 3) & ~3;
            var bytes = new byte[padded];
            BitConverter.GetBytes(30).CopyTo(bytes, 0);
            BitConverter.GetBytes(value.Length).CopyTo(bytes, 4);
            value.CopyTo(bytes, 8);
            return (property.Id, Bytes: bytes);
        }).ToArray();
        var sectionOffset = 48;
        var valuesOffset = 8 + encoded.Length * 8;
        var sectionSize = valuesOffset + encoded.Sum(item => item.Bytes.Length);
        var result = new byte[sectionOffset + sectionSize];
        BitConverter.GetBytes((ushort)0xfffe).CopyTo(result, 0);
        BitConverter.GetBytes(1).CopyTo(result, 24);
        BitConverter.GetBytes(sectionOffset).CopyTo(result, 44);
        BitConverter.GetBytes(sectionSize).CopyTo(result, sectionOffset);
        BitConverter.GetBytes(encoded.Length).CopyTo(result, sectionOffset + 4);
        var cursor = valuesOffset;
        for (var index = 0; index < encoded.Length; index++)
        {
            BitConverter.GetBytes(encoded[index].Id).CopyTo(result, sectionOffset + 8 + index * 8);
            BitConverter.GetBytes(cursor).CopyTo(result, sectionOffset + 12 + index * 8);
            encoded[index].Bytes.CopyTo(result, sectionOffset + cursor);
            cursor += encoded[index].Bytes.Length;
        }
        return result;
    }

    private static byte[] CreatePlayStationIso(string? platform)
    {
        const int sector = 2048;
        const int rootLba = 20;
        const int configLba = 22;
        var image = new byte[24 * sector];
        var pvd = image.AsSpan(16 * sector, sector);
        pvd[0] = 1;
        "CD001"u8.CopyTo(pvd[1..]);
        pvd[6] = 1;

        var directory = image.AsSpan(rootLba * sector, sector);
        var directoryLength = 0;
        if (platform is "psp")
        {
            directoryLength += WriteIsoRecord(directory[directoryLength..], 21, sector, "PSP_GAME");
            directoryLength += WriteIsoRecord(directory[directoryLength..], 23, 32, "UMD_DATA.BIN;1");
        }
        else if (platform is "psx" or "ps2")
        {
            var config = platform == "ps2" ? "BOOT2 = cdrom0:\\\\SLUS_000.00;1\r\n" : "BOOT = cdrom:\\\\SCUS_000.00;1\r\n";
            var configBytes = Encoding.ASCII.GetBytes(config);
            configBytes.CopyTo(image, configLba * sector);
            directoryLength += WriteIsoRecord(directory[directoryLength..], configLba, configBytes.Length, "SYSTEM.CNF;1");
        }
        else
        {
            directoryLength += WriteIsoRecord(directory, 23, 16, "README.TXT;1");
        }
        WriteIsoRecord(pvd[156..], rootLba, directoryLength, "\0");
        return image;
    }

    private static int WriteIsoRecord(Span<byte> destination, int extent, int dataLength, string name)
    {
        var nameBytes = Encoding.ASCII.GetBytes(name);
        var length = 33 + nameBytes.Length + (nameBytes.Length % 2 == 0 ? 1 : 0);
        destination[..length].Clear();
        destination[0] = (byte)length;
        BitConverter.GetBytes(extent).CopyTo(destination[2..]);
        BitConverter.GetBytes(BinaryPrimitives.ReverseEndianness(extent)).CopyTo(destination[6..]);
        BitConverter.GetBytes(dataLength).CopyTo(destination[10..]);
        BitConverter.GetBytes(BinaryPrimitives.ReverseEndianness(dataLength)).CopyTo(destination[14..]);
        destination[25] = 0;
        destination[28] = 1;
        destination[31] = 1;
        destination[32] = (byte)nameBytes.Length;
        nameBytes.CopyTo(destination[33..]);
        return length;
    }
}