// Scalar corpus shared by C, Wasm, native x64, and native AArch64. Keep this
// free of aggregates the newer machine backends deliberately reject.

import Debug from Wax;
import StringBuilder from Wax;
import Math from Wax;

static class MachineState {
    public static uint32[] words = new uint32[521];
    public static float[] f32 = new float[7];
    public static double[] f64 = new double[7];
}

fn Hex(uint64 value, int32 digits) : string {
    StringBuilder builder = new StringBuilder();
    builder.AppendUInt64Hex(value, digits, true);
    return builder.ToString();
}

fn Mix(uint32 digest, uint32 value) : uint32 {
    return (digest ^ value) * 16777619u;
}

fn Mix64(uint32 digest, uint64 value) : uint32 {
    digest = Mix(digest, value as uint32);
    return Mix(digest, (value >> 32ul) as uint32);
}

api fn SeedProbeState(int32 salt) : int32 {
    uint32 rng = 2246822519u + (salt as uint32);
    for (int32 i = 0; i < MachineState.words.size; i++) {
        rng = rng * 747796405u + 2891336453u;
        MachineState.words[i] = rng ^ (rng >> ((rng & 15u) + 1u));
    }
    uint32[] f32Bits = new uint32[] { 0x7F800001u, 0x7FC00001u, 0xFFFFFFFFu, 0x00000001u, 0x007FFFFFu, 0x00800000u, 0x80000001u };
    uint64[] f64Bits = new uint64[] { 0x7FF0000000000001ul, 0x7FF8000000000001ul, 0xFFFFFFFFFFFFFFFFul, 0x0000000000000001ul, 0x000FFFFFFFFFFFFFul, 0x0010000000000000ul, 0x8000000000000001ul };
    for (int32 i = 0; i < MachineState.f32.size; i++) {
        MachineState.f32[i] = f32Bits[i].Reinterpret<float>();
        MachineState.f64[i] = f64Bits[i].Reinterpret<double>();
    }
    return 0;
}

api fn RunValueProbes() : int32 {
    uint32 digest = 2166136261u;
    for (int32 i = 0; i < MachineState.words.size; i++) {
        uint32 word = MachineState.words[i];
        digest = Mix(digest, word.Reinterpret<float>().Reinterpret<uint32>());
        digest = Mix(digest, word.Reinterpret<int32>().Reinterpret<uint32>());
    }
    for (int32 i = 0; i + 1 < MachineState.words.size; i = i + 2) {
        uint64 word = ((MachineState.words[i] as uint64) << 32ul) | (MachineState.words[i + 1] as uint64);
        digest = Mix64(digest, word.Reinterpret<double>().Reinterpret<uint64>());
        digest = Mix64(digest, word.Reinterpret<int64>().Reinterpret<uint64>());
    }
    for (int32 i = 0; i < MachineState.f32.size; i++) {
        digest = Mix(digest, MachineState.f32[i].Reinterpret<uint32>());
        digest = Mix64(digest, MachineState.f64[i].Reinterpret<uint64>());
    }

    float zero32 = (MachineState.words[7] - MachineState.words[7]) as float;
    double zero64 = (MachineState.words[8] - MachineState.words[8]) as double;
    float inf32 = 0x7F800000u.Reinterpret<float>();
    double inf64 = 0x7FF0000000000000ul.Reinterpret<double>();
    digest = Mix(digest, (zero32 / zero32).Reinterpret<uint32>());
    digest = Mix(digest, (inf32 - inf32).Reinterpret<uint32>());
    digest = Mix(digest, (inf32 * zero32).Reinterpret<uint32>());
    digest = Mix(digest, Math.Sqrt(-1.0f).Reinterpret<uint32>());
    digest = Mix64(digest, (zero64 / zero64).Reinterpret<uint64>());
    digest = Mix64(digest, (inf64 - inf64).Reinterpret<uint64>());
    digest = Mix64(digest, (inf64 * zero64).Reinterpret<uint64>());
    digest = Mix64(digest, Math.Sqrt(-1.0).Reinterpret<uint64>());
    digest = Mix64(digest, (MachineState.f32[0] as double).Reinterpret<uint64>());
    digest = Mix(digest, (MachineState.f64[0] as float).Reinterpret<uint32>());

    digest = Mix(digest, (MachineState.f32[3] * 0.5f).Reinterpret<uint32>());
    digest = Mix(digest, (MachineState.f32[4] + MachineState.f32[3]).Reinterpret<uint32>());
    digest = Mix(digest, (MachineState.f32[5] - MachineState.f32[3]).Reinterpret<uint32>());
    digest = Mix(digest, (MachineState.f32[6] * 0.5f).Reinterpret<uint32>());
    digest = Mix64(digest, (MachineState.f64[3] * 0.5).Reinterpret<uint64>());
    digest = Mix64(digest, (MachineState.f64[4] + MachineState.f64[3]).Reinterpret<uint64>());
    digest = Mix64(digest, (MachineState.f64[5] - MachineState.f64[3]).Reinterpret<uint64>());
    digest = Mix64(digest, (MachineState.f64[6] * 0.5).Reinterpret<uint64>());

    float fa = 0x3F800001u.Reinterpret<float>();
    float fb = 0x3F7FFFFEu.Reinterpret<float>();
    float fc = 0xBF800000u.Reinterpret<float>();
    digest = Mix(digest, (fa * fb + fc).Reinterpret<uint32>());
    double da = 0x3FF0000000000001ul.Reinterpret<double>();
    double db = 0x3FEFFFFFFFFFFFFEul.Reinterpret<double>();
    double dc = 0xBFF0000000000000ul.Reinterpret<double>();
    digest = Mix64(digest, (da * db + dc).Reinterpret<uint64>());

    Debug.Log("WAXDET machine.scalar.digest ${Hex(digest as uint64, 8)}");
    return 0;
}

api fn Main(string[] args) : int32 {
    if (args.size != 2 || args[1] != "values") { return 3; }
    SeedProbeState(args.size - 2);
    return RunValueProbes();
}