#include "core/controller_identity.h"
#include "profile/controller_profile.h"
#include "controller_profile_legacy_fixtures.h"

#include <cstdlib>
#include <cstring>
#include <iostream>

namespace {

uint8_t encoded_database[CONTROLLER_PROFILE_DATABASE_ENCODED_SIZE]{};
ControllerProfileDatabase database{};
ControllerProfileDatabase decoded_database{};

void require(bool condition, const char* message) {
    if (!condition) {
        std::cerr << message << '\n';
        std::exit(1);
    }
}

ControllerIdentity identity(uint8_t suffix) {
    ControllerIdentity value{};
    value.stable = true;
    value.transport = ControllerTransport::kClassic;
    value.address[5] = suffix;
    value.vendor_id = 0x057e;
    value.product_id = static_cast<uint16_t>(0x2000u + suffix);
    return value;
}

bool read_encoded_database(void*, size_t offset, uint8_t* output,
                           size_t size) {
    if (offset > sizeof(encoded_database) ||
        size > sizeof(encoded_database) - offset) {
        return false;
    }
    memcpy(output, &encoded_database[offset], size);
    return true;
}

void test_pair_identity_wire_and_member_validation() {
    ControllerIdentity left = identity(1);
    left.transport = ControllerTransport::kBle;
    left.product_id = 0x2067;
    const uint8_t left_address[6] = {0x10, 0x11, 0x12, 0x13, 0x14, 0x15};
    memcpy(left.address, left_address, sizeof(left_address));
    ControllerIdentity right = left;
    right.product_id = 0x2066;
    right.address_type = 1;
    right.address[0] = 0xc0;
    ControllerIdentity pair{};
    uint8_t encoded[CONTROLLER_IDENTITY_ENCODED_SIZE]{};
    const uint8_t expected[14] = {
        5, 3, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
        0xc0, 0x11, 0x12, 0x13, 0x14, 0x15};
    require(controller_identity_make_joycon_pair(left, right, &pair) &&
                controller_identity_encode(pair, encoded, sizeof(encoded)) &&
                memcmp(encoded, expected, sizeof(expected)) == 0,
            "pair identity did not encode both typed members");
    ControllerIdentity decoded{};
    ControllerIdentity decoded_left{};
    ControllerIdentity decoded_right{};
    require(controller_identity_decode(encoded, sizeof(encoded), &decoded) &&
                controller_identity_equal(pair, decoded) &&
                controller_identity_joycon_pair_members(
                    decoded, &decoded_left, &decoded_right) &&
                controller_identity_equal(left, decoded_left) &&
                controller_identity_equal(right, decoded_right),
            "pair identity round trip lost a member or its model");
    decoded.partner_address[5] ^= 1;
    require(!controller_identity_equal(pair, decoded),
            "pair equality ignored the right address");
    for (uint8_t flags = 0; flags < 16; ++flags) {
        if (flags == 1 || flags == 5) {
            continue;
        }
        memcpy(encoded, expected, sizeof(encoded));
        encoded[0] = flags;
        require(!controller_identity_decode(encoded, sizeof(encoded), &decoded),
                "pair decoder accepted unstable, reserved, or nonstatic flags");
    }
    require(!controller_identity_make_joycon_pair(right, left, &decoded),
            "pair helper accepted reversed models");
    right.product_id = 0x2069;
    require(!controller_identity_make_joycon_pair(left, right, &decoded),
            "pair helper accepted a non-Joy-Con member");
    right.product_id = 0x2066;
    right.address_type = 2;
    require(!controller_identity_make_joycon_pair(left, right, &decoded),
            "pair helper accepted a noncanonical identity address type");
    right.address_type = left.address_type;
    memcpy(right.address, left.address, sizeof(right.address));
    require(!controller_identity_make_joycon_pair(left, right, &decoded),
            "pair helper accepted one physical typed address twice");
    left.address[0] = right.address[0] = 0xc0;
    right.address_type = 1;
    require(controller_identity_make_joycon_pair(left, right, &decoded),
            "pair helper conflated public and static-random address namespaces");
    left.partner_address[0] = 1;
    require(!controller_identity_encode(left, encoded, sizeof(encoded)) &&
                !controller_identity_make_joycon_pair(left, right, &decoded),
            "ordinary member accepted stray partner fields");
    left.partner_address[0] = 0;
    const uint8_t ordinary[14] = {
        1, 2, 0, 0, 0xc0, 0x11, 0x12, 0x13, 0x14, 0x15,
        0x7e, 0x05, 0x67, 0x20};
    require(controller_identity_encode(left, encoded, sizeof(encoded)) &&
                memcmp(encoded, ordinary, sizeof(encoded)) == 0 &&
                controller_identity_decode(encoded, sizeof(encoded), &decoded) &&
                controller_identity_equal(left, decoded),
            "ordinary identity wire encoding changed");
    const uint8_t global[14]{};
    require(controller_identity_encode(controller_identity_global(), encoded,
                                       sizeof(encoded)) &&
                memcmp(encoded, global, sizeof(encoded)) == 0,
            "global identity wire encoding changed");
}

void test_profile_wire_schema() {
    const ControllerProfile profile =
        controller_profile_default(controller_identity_global(), 0);
    uint8_t encoded[CONTROLLER_PROFILE_ENCODED_SIZE]{};
    require(controller_profile_encode(profile, encoded, sizeof(encoded)),
            "default profile did not encode");
    require(encoded[0] == 7 && encoded[1] == 0 &&
                encoded[2] == 0x80 && encoded[3] == 1,
            "profile header is not little-endian v7/384");
    for (uint8_t index = 0;
         index < CONTROLLER_PROFILE_LOGICAL_BUTTON_COUNT; ++index) {
        require(encoded[4 + index] == index,
                "default direct mapping is not identity");
    }
    require(encoded[26] == 0xff && encoded[27] == 0x7f &&
                encoded[30] == 0,
            "default stick encoding changed");
    require(encoded[54] == 0xff && encoded[55] == 0xff &&
                encoded[58] ==
                    static_cast<uint8_t>(
                        CONTROLLER_PROFILE_DEFAULT_DIGITAL_THRESHOLD) &&
                encoded[59] ==
                    static_cast<uint8_t>(
                        CONTROLLER_PROFILE_DEFAULT_DIGITAL_THRESHOLD >> 8),
            "default trigger encoding changed");
    require(encoded[60] == CONTROLLER_PROFILE_LEFT_TRIGGER_CONTROL &&
                encoded[61] == 0 &&
                encoded[70] == CONTROLLER_PROFILE_RIGHT_TRIGGER_CONTROL &&
                encoded[71] == 0,
            "default trigger mappings are not identity");
    require(encoded[72] == 0xff && encoded[73] == 0xff &&
                encoded[74] == 3 && encoded[75] == 0 &&
                encoded[78] == 0 && encoded[79] == 0,
            "default rumble or action encoding changed");
    require(encoded[96] == 0 && encoded[97] == 0 &&
                encoded[98] == 0x7c && encoded[99] == 0 &&
                encoded[100] == 0 && encoded[101] == 0,
            "default sparse macro descriptor changed");

    ControllerProfile decoded{};
    require(controller_profile_decode(encoded, sizeof(encoded), &decoded),
            "default profile did not decode");
    ControllerProfile action_profile = profile;
    action_profile.switching_chord =
        (1u << CONTROLLER_PROFILE_LEFT_TRIGGER_CONTROL) |
        (1u << static_cast<uint8_t>(
            ControllerProfileLogicalButton::kSouth));
    action_profile.motion_toggle_chord =
        (1u << CONTROLLER_PROFILE_RIGHT_TRIGGER_CONTROL);
    action_profile.macros[0].trigger_mask =
        (1u << CONTROLLER_PROFILE_LEFT_TRIGGER_CONTROL) |
        (1u << CONTROLLER_PROFILE_RIGHT_TRIGGER_CONTROL);
    action_profile.macros[0].cancel_control =
        CONTROLLER_PROFILE_LEFT_TRIGGER_CONTROL;
    action_profile.macros[0].first_step = 0;
    action_profile.macros[0].step_count = 1;
    action_profile.macro_step_count = 1;
    action_profile.macro_steps[0].override_flags =
        kControllerProfileOverrideButtons;
    for (uint8_t macro_index = 1;
         macro_index < CONTROLLER_PROFILE_MACRO_COUNT; ++macro_index) {
        action_profile.macros[macro_index].first_step = 1;
    }
    action_profile.macro_steps[0].duration_ms = 25;
    action_profile.macro_steps[0].output_button_mask = 1;
    uint8_t action_encoded[CONTROLLER_PROFILE_ENCODED_SIZE]{};
    require(controller_profile_encode(
                action_profile, action_encoded, sizeof(action_encoded)),
            "sparse action profile did not encode");
    require(action_encoded[75] == 0x21,
            "sparse action extension encoding changed");
    require(action_encoded[96] == 0 &&
                action_encoded[97] == 0 &&
                action_encoded[98] == 0x43,
            "sparse macro binding encoding changed");
    require(action_encoded[100] == 1 &&
                action_encoded[101] == 5,
            "sparse macro step bounds changed");
    require(controller_profile_decode(
                action_encoded, sizeof(action_encoded), &decoded),
            "sparse action profile did not decode");
    require(decoded.switching_chord ==
                    action_profile.switching_chord &&
                decoded.motion_toggle_chord ==
                    action_profile.motion_toggle_chord &&
                decoded.macros[0].trigger_mask ==
                    action_profile.macros[0].trigger_mask &&
                decoded.macros[0].cancel_control ==
                    action_profile.macros[0].cancel_control &&
                decoded.macros[0].step_count == 1,
            "sparse trigger-backed macro did not round-trip");
    encoded[252] = 1;
    require(!controller_profile_decode(encoded, sizeof(encoded), &decoded),
            "nonzero reserved profile byte was accepted");

    ControllerProfile invalid = profile;
    invalid.button_map[0] = CONTROLLER_PROFILE_FIRST_EXTRA_CONTROL;
    require(!controller_profile_validate(invalid),
            "invalid direct output was accepted");
    invalid = profile;
    invalid.sticks[0].inner_deadzone =
        invalid.sticks[0].outer_saturation;
    require(!controller_profile_validate(invalid),
            "empty stick range was accepted");
    ControllerProfile boundary = profile;
    boundary.triggers[0].lower_deadzone = 30000;
    boundary.triggers[0].upper_saturation = 40000;
    boundary.triggers[0].digital_threshold = 0;
    uint8_t boundary_encoded[CONTROLLER_PROFILE_ENCODED_SIZE]{};
    require(controller_profile_encode(boundary, boundary_encoded,
                                      sizeof(boundary_encoded)) &&
                controller_profile_decode(boundary_encoded,
                                          sizeof(boundary_encoded),
                                          &decoded) &&
                decoded.triggers[0].digital_threshold == 0,
            "current profile rejected zero transformed trigger threshold");
    boundary.triggers[0].digital_threshold = UINT16_MAX;
    require(controller_profile_encode(boundary, boundary_encoded,
                                      sizeof(boundary_encoded)) &&
                controller_profile_decode(boundary_encoded,
                                          sizeof(boundary_encoded),
                                          &decoded) &&
                decoded.triggers[0].digital_threshold == UINT16_MAX,
            "current profile rejected maximum transformed trigger threshold");
    invalid = profile;
    invalid.triggers[0].lower_deadzone =
        invalid.triggers[0].upper_saturation;
    require(!controller_profile_validate(invalid),
            "empty raw trigger range was accepted");
    invalid.triggers[0].lower_deadzone = UINT16_MAX;
    invalid.triggers[0].upper_saturation = UINT16_MAX - 1;
    require(!controller_profile_validate(invalid),
            "reversed raw trigger range was accepted");
    invalid = profile;
    invalid.turbo_modes[0] =
        static_cast<ControllerProfileTurboMode>(4);
    require(!controller_profile_validate(invalid),
            "invalid Turbo mode was accepted");
    invalid = profile;
    invalid.macros[0].first_step = 0;
    invalid.macros[0].step_count = 1;
    invalid.macro_step_count = 1;
    invalid.macro_steps[0].duration_ms =
        CONTROLLER_PROFILE_MAX_WAIT_MS + 1;
    require(!controller_profile_validate(invalid),
            "unbounded macro wait was accepted");
    invalid.macro_steps[0].duration_ms =
        CONTROLLER_PROFILE_MAX_WAIT_MS;
    invalid.macros[1].first_step = 0;
    require(!controller_profile_validate(invalid),
            "noncanonical shared macro pool was accepted");
}

void test_legacy_profile_migration() {
    ControllerProfile migrated{};
    require(controller_profile_decode(
                kLegacyDefaultProfile, sizeof(kLegacyDefaultProfile),
                &migrated),
            "legacy default profile did not decode");
    require(migrated.triggers[0].digital_threshold ==
                    CONTROLLER_PROFILE_DEFAULT_DIGITAL_THRESHOLD &&
                migrated.triggers[1].digital_threshold ==
                    CONTROLLER_PROFILE_DEFAULT_DIGITAL_THRESHOLD,
            "legacy inherited thresholds were not migrated");

    uint8_t encoded[CONTROLLER_PROFILE_ENCODED_SIZE]{};
    require(controller_profile_encode(migrated, encoded, sizeof(encoded)),
            "migrated default profile did not encode");
    require(migrated.macros[0].step_count == 0 &&
                migrated.macro_step_count == 0,
            "legacy end marker was not removed during migration");
    require(encoded[0] == CONTROLLER_PROFILE_SCHEMA_VERSION &&
                encoded[58] ==
                    static_cast<uint8_t>(
                        CONTROLLER_PROFILE_DEFAULT_DIGITAL_THRESHOLD) &&
                encoded[59] ==
                    static_cast<uint8_t>(
                        CONTROLLER_PROFILE_DEFAULT_DIGITAL_THRESHOLD >> 8) &&
                encoded[68] ==
                    static_cast<uint8_t>(
                        CONTROLLER_PROFILE_DEFAULT_DIGITAL_THRESHOLD) &&
                encoded[69] ==
                    static_cast<uint8_t>(
                        CONTROLLER_PROFILE_DEFAULT_DIGITAL_THRESHOLD >> 8) &&
                encoded[60] == CONTROLLER_PROFILE_LEFT_TRIGGER_CONTROL &&
                encoded[70] == CONTROLLER_PROFILE_RIGHT_TRIGGER_CONTROL,
            "migrated default profile did not encode as the current schema");

    require(controller_profile_decode(
                kLegacyNarrowRawRangeProfile,
                sizeof(kLegacyNarrowRawRangeProfile), &migrated),
            "legacy narrow-raw-range profile did not decode");
    require(migrated.triggers[0].lower_deadzone == 30000 &&
                migrated.triggers[0].upper_saturation == 40000 &&
                migrated.triggers[0].digital_threshold ==
                    CONTROLLER_PROFILE_DEFAULT_DIGITAL_THRESHOLD &&
                migrated.triggers[1].lower_deadzone == 30000 &&
                migrated.triggers[1].upper_saturation == 40000 &&
                migrated.triggers[1].digital_threshold ==
                    CONTROLLER_PROFILE_DEFAULT_DIGITAL_THRESHOLD,
            "legacy narrow raw range or inherited threshold was not migrated");
    require(controller_profile_encode(migrated, encoded, sizeof(encoded)),
            "migrated narrow-raw-range profile did not encode");

    require(controller_profile_decode(
                kLegacyCustomThresholdProfile,
                sizeof(kLegacyCustomThresholdProfile), &migrated),
            "legacy custom-threshold profile did not decode");
    require(migrated.triggers[0].digital_threshold == 0x1234 &&
                migrated.triggers[1].digital_threshold == 0xabcd,
            "legacy custom thresholds were not preserved");
    require(migrated.triggers[0].output ==
                    CONTROLLER_PROFILE_LEFT_TRIGGER_CONTROL &&
                migrated.triggers[1].output ==
                    CONTROLLER_PROFILE_RIGHT_TRIGGER_CONTROL,
            "legacy trigger identity mappings were not restored");
    require(controller_profile_encode(migrated, encoded, sizeof(encoded)),
            "legacy custom-threshold profile did not re-encode");
    const uint8_t legacy_macro_trigger =
        kLegacyCustomThresholdProfile[78];
    const uint32_t expected_macro_trigger =
        legacy_macro_trigger < CONTROLLER_PROFILE_LOGICAL_BUTTON_COUNT
            ? static_cast<uint32_t>(1u << legacy_macro_trigger)
            : 0;
    require(migrated.macros[0].trigger_mask ==
                    expected_macro_trigger &&
                migrated.macros[0].cancel_control ==
                    kLegacyCustomThresholdProfile[79],
            "legacy macro trigger was not migrated to descriptor zero");

    uint8_t previous_encoded[CONTROLLER_PROFILE_LEGACY_ENCODED_SIZE]{};
    memcpy(previous_encoded, kLegacyDefaultProfile,
           sizeof(previous_encoded));
    previous_encoded[0] = static_cast<uint8_t>(
        CONTROLLER_PROFILE_TRIGGER_THRESHOLD_SCHEMA_VERSION);
    previous_encoded[58] = static_cast<uint8_t>(
        CONTROLLER_PROFILE_DEFAULT_DIGITAL_THRESHOLD);
    previous_encoded[59] = static_cast<uint8_t>(
        CONTROLLER_PROFILE_DEFAULT_DIGITAL_THRESHOLD >> 8);
    previous_encoded[68] = static_cast<uint8_t>(
        CONTROLLER_PROFILE_DEFAULT_DIGITAL_THRESHOLD);
    previous_encoded[69] = static_cast<uint8_t>(
        CONTROLLER_PROFILE_DEFAULT_DIGITAL_THRESHOLD >> 8);
    previous_encoded[78] = static_cast<uint8_t>(
        ControllerProfileLogicalButton::kSouth);
    previous_encoded[79] = static_cast<uint8_t>(
        ControllerProfileLogicalButton::kCapture);
    require(controller_profile_decode(
                previous_encoded, sizeof(previous_encoded), &migrated) &&
                migrated.triggers[0].output ==
                    CONTROLLER_PROFILE_LEFT_TRIGGER_CONTROL &&
                migrated.triggers[1].output ==
                    CONTROLLER_PROFILE_RIGHT_TRIGGER_CONTROL &&
                migrated.macros[0].trigger_mask ==
                    static_cast<uint32_t>(
                        1u << static_cast<uint8_t>(
                            ControllerProfileLogicalButton::kSouth)) &&
                migrated.macros[0].cancel_control ==
                    static_cast<uint8_t>(
                        ControllerProfileLogicalButton::kCapture) &&
                migrated.motion_toggle_chord == 0,
            "v2 profile controls did not migrate to the current schema");
    previous_encoded[80] = 2;
    previous_encoded[100] = 0;
    previous_encoded[101] = kControllerProfileOverrideButtons;
    previous_encoded[102] = 25;
    previous_encoded[104] = 1;
    require(controller_profile_decode(
                previous_encoded, sizeof(previous_encoded), &migrated) &&
                migrated.macros[0].step_count == 1 &&
                migrated.macro_steps[0].output_button_mask == 1,
            "legacy nonempty macro did not migrate into shared pool");

    ControllerProfile current =
        controller_profile_default(controller_identity_global(), 0);
    current.triggers[0].digital_threshold = 0x8000;
    require(controller_profile_encode(current, encoded, sizeof(encoded)) &&
                controller_profile_decode(encoded, sizeof(encoded),
                                          &migrated) &&
                migrated.triggers[0].digital_threshold == 0x8000,
            "v2 custom threshold matching the legacy default was migrated");
}

void test_database_round_trip_and_capacity() {
    controller_profile_database_default(&database);
    for (uint8_t index = 0;
         index < CONTROLLER_PROFILE_STABLE_IDENTITY_CAPACITY; ++index) {
        ControllerProfileDatabaseEntry* entry = nullptr;
        require(controller_profile_database_ensure(
                    &database, identity(static_cast<uint8_t>(index + 1)),
                    &entry) == ControllerProfileDatabaseResult::kOk &&
                    entry != nullptr,
                "stable identity was not added");
        entry->active_profile = index % CONTROLLER_PROFILE_COUNT;
    }
    ControllerProfileDatabaseEntry* rejected = nullptr;
    require(controller_profile_database_ensure(
                &database, identity(99), &rejected) ==
                ControllerProfileDatabaseResult::kFull,
            "seventeenth stable identity was not rejected");
    require(controller_profile_database_find(database, identity(1)) !=
                nullptr,
            "full-table rejection evicted an existing identity");

    for (size_t offset = 0; offset < sizeof(encoded_database);
         offset += CONTROLLER_PROFILE_ENCODED_SIZE) {
        const size_t size = sizeof(encoded_database) - offset <
                                    CONTROLLER_PROFILE_ENCODED_SIZE
                                ? sizeof(encoded_database) - offset
                                : CONTROLLER_PROFILE_ENCODED_SIZE;
        require(controller_profile_database_encode_range(
                    database, offset, &encoded_database[offset], size),
                "database range did not encode");
    }
    require(encoded_database[4] ==
                    CONTROLLER_PROFILE_DATABASE_SCHEMA_VERSION &&
                encoded_database[5] == 0,
            "database encoder did not emit v3");
    require(controller_profile_database_decode(
                read_encoded_database, nullptr, &decoded_database),
            "database did not decode");
    require(controller_profile_database_find(
                decoded_database, identity(16)) != nullptr,
            "last database identity did not round trip");

    encoded_database[12] = 1;
    require(!controller_profile_database_decode(
                read_encoded_database, nullptr, &decoded_database),
            "nonzero database header reservation was accepted");
}

void test_set_b_sparse_extension_and_migration() {
    ControllerProfile profile =
        controller_profile_default(controller_identity_global(), 0);
    profile.shortcuts.modifier = 16;
    profile.shortcuts.selectors[0] = 0;
    profile.shortcuts.selectors[7] = 15;
    profile.shift.mode = ControllerProfileShiftMode::kToggle;
    profile.shift.modifier = 17;
    profile.shift.button_map[0] = CONTROLLER_PROFILE_NO_BUTTON;
    profile.turbo_modes[15] = ControllerProfileTurboMode::kBurst;
    profile.turbo_defaults = {30, 99, 255};
    profile.turbo_override_mask = (1u << 2) | (1u << 15);
    profile.turbo_overrides[2] = {1, 1, 1};
    profile.turbo_overrides[15] = {23, 37, 17};
    profile.turbo_overrides[0] = {0, 0, 0};
    profile.macros[0] = {1, 0xff, 0, 8, ControllerProfileMacroMode::kRepeat, 255};
    profile.macro_step_count = 8;
    for (uint8_t macro = 1; macro < CONTROLLER_PROFILE_MACRO_COUNT; ++macro) {
        profile.macros[macro].first_step = 8;
        profile.macros[macro].mode = static_cast<ControllerProfileMacroMode>(macro - 1);
    }
    for (uint8_t step = 0; step < 8; ++step) {
        profile.macro_steps[step] = {31, 25, 1, -2, 3, -4, 5, 0x1234, 0xabcd};
    }
    uint8_t encoded[CONTROLLER_PROFILE_ENCODED_SIZE]{};
    ControllerProfile decoded{};
    require(controller_profile_encode(profile, encoded, sizeof(encoded)) &&
                controller_profile_decode(encoded, sizeof(encoded), &decoded),
            "full sparse stream and Set B extension did not round trip");
    require(encoded[254] == 0xcd && encoded[255] == 0xab &&
                encoded[256] == 16 && encoded[264] == 15 &&
                encoded[265] == 2 && encoded[266] == 17 &&
                encoded[267] == 0xff && encoded[283] == 30 &&
                encoded[286] == 4 && encoded[287] == 0x80 &&
                encoded[288] == 1 && encoded[291] == 23 &&
                encoded[336] == 3 && encoded[337] == 255,
            "Set B fields overlap macro data or use wrong sparse ordering");
    require(decoded.turbo_overrides[15].duty_percent == 37 &&
                decoded.macros[0].repeat_count == 255 &&
                decoded.shortcuts.selectors[7] == 15,
            "Set B extension settings were not decoded");
    for (size_t offset = 294; offset < 336; ++offset) {
        require(encoded[offset] == 0, "absent override was not canonical zero");
    }
    encoded[294] = 1;
    require(!controller_profile_decode(encoded, sizeof(encoded), &decoded),
            "nonzero sparse Turbo padding was accepted");
    encoded[294] = 0;
    encoded[383] = 1;
    require(!controller_profile_decode(encoded, sizeof(encoded), &decoded),
            "nonzero extension reservation was accepted");
    encoded[383] = 0;
    encoded[337] = 0;
    require(!controller_profile_decode(encoded, sizeof(encoded), &decoded),
            "zero macro repeat count was accepted");
    encoded[337] = 255;
    uint8_t legacy[CONTROLLER_PROFILE_LEGACY_ENCODED_SIZE]{};
    memcpy(legacy, encoded, sizeof(legacy));
    legacy[0] = 5;
    legacy[2] = 0;
    legacy[95] = 2;
    require(controller_profile_decode(legacy, sizeof(legacy), &decoded) &&
                decoded.macros[0].step_count == 8 &&
                decoded.macro_steps[7].right_trigger == 0xabcd &&
                decoded.macros[0].mode == ControllerProfileMacroMode::kOnce &&
                decoded.shortcuts.modifier == CONTROLLER_PROFILE_NO_BUTTON &&
                decoded.turbo_override_mask == 0,
            "schema5 full136-byte macro stream did not migrate");
    require(controller_profile_encode(decoded, encoded, sizeof(encoded)) &&
                memcmp(&legacy[4], &encoded[4], sizeof(legacy) - 4) == 0,
            "schema5 migration changed existing profile data");
    legacy[0] = 6;
    require(!controller_profile_decode(legacy, sizeof(legacy), &decoded),
            "schema6 accepted a legacy-sized payload");
    profile.shortcuts.selectors[7] = 0;
    require(!controller_profile_validate(profile), "duplicate shortcut was accepted");
    profile.shortcuts.selectors[7] = 15;
    profile.shift.button_map[0] = 16;
    require(!controller_profile_validate(profile), "analog Shift output was accepted");
    profile.shift.button_map[0] = 0;
    profile.turbo_overrides[2].rate_hz = 31;
    require(!controller_profile_validate(profile), "out-of-range Turbo rate was accepted");
    profile.turbo_overrides[2].rate_hz = 1;
    for (uint8_t step = 0; step < 8; ++step) {
        profile.macro_steps[step].duration_ms = 0;
    }
    require(!controller_profile_validate(profile), "zero-duration looping macro was accepted");
    profile.macros[0].mode = ControllerProfileMacroMode::kOnce;
    require(controller_profile_validate(profile), "zero-duration once macro was rejected");
}

void test_legacy_database_strides() {
    for (uint8_t version = 1; version <= 2; ++version) {
        const uint8_t count = version == 1 ? 4 : 8;
        const size_t entry_size = 16 + count * 256;
        const size_t entries_offset = 32 + count * 256;
        const size_t total_size = entries_offset + 16 * entry_size;
        memset(encoded_database, 0, sizeof(encoded_database));
        memcpy(encoded_database, "SPDB", 4);
        encoded_database[4] = version;
        encoded_database[6] = static_cast<uint8_t>(total_size);
        encoded_database[7] = static_cast<uint8_t>(total_size >> 8);
        encoded_database[8] = 16;
        encoded_database[9] = count;
        encoded_database[10] = count - 1;
        encoded_database[11] = 1;
        for (uint8_t index = 0; index < count; ++index) {
            memcpy(&encoded_database[32 + index * 256], kLegacyDefaultProfile, 256);
        }
        const size_t last_entry = entries_offset + 15 * entry_size;
        require(controller_identity_encode(identity(16), &encoded_database[last_entry], 14),
                "legacy database identity did not encode");
        encoded_database[last_entry + 14] = count - 1;
        encoded_database[last_entry + 15] = 1;
        for (uint8_t index = 0; index < count; ++index) {
            memcpy(&encoded_database[last_entry + 16 + index * 256],
                   kLegacyCustomThresholdProfile, 256);
        }
        require(controller_profile_database_decode(
                    read_encoded_database, nullptr, &decoded_database),
                "legacy database strides were not preserved");
        const ControllerProfileDatabaseEntry* entry =
            controller_profile_database_find(decoded_database, identity(16));
        require(entry != nullptr && entry->active_profile == count - 1 &&
                    entry->profiles[count - 1].triggers[1].digital_threshold == 0xabcd,
                "last legacy bank profile was read from the wrong offset");
        if (count == 4) {
            require(entry->profiles[7].triggers[0].digital_threshold ==
                        CONTROLLER_PROFILE_DEFAULT_DIGITAL_THRESHOLD,
                    "new profile slots were not defaulted during migration");
        }
        encoded_database[4] = 3;
        require(!controller_profile_database_decode(
                    read_encoded_database, nullptr, &decoded_database),
                "current database version accepted legacy strides");
    }
}

void test_schema6_migration_preserves_every_setting() {
    ControllerProfile profile{};
    uint8_t upgraded[CONTROLLER_PROFILE_ENCODED_SIZE]{};
    require(controller_profile_decode(kLegacySchema6Profile,
                                      sizeof(kLegacySchema6Profile), &profile) &&
                controller_profile_encode(profile, upgraded, sizeof(upgraded)),
            "schema6 profile could not upgrade");
    require(memcmp(upgraded + 2, kLegacySchema6Profile + 2, 342) == 0,
            "schema6 migration changed an existing encoded setting");
    for (uint8_t index = 0; index < CONTROLLER_PROFILE_EXTRA_BUTTON_COUNT; ++index) {
        require(profile.extra_button_map[index] == CONTROLLER_PROFILE_NO_BUTTON &&
                    profile.shift.extra_button_map[index] == CONTROLLER_PROFILE_NO_BUTTON,
                "schema6 padding became an extra-button mapping");
    }
    ControllerProfile reloaded{};
    uint8_t round_trip[CONTROLLER_PROFILE_ENCODED_SIZE]{};
    require(controller_profile_decode(upgraded, sizeof(upgraded), &reloaded) &&
                controller_profile_encode(reloaded, round_trip, sizeof(round_trip)) &&
                memcmp(upgraded, round_trip, sizeof(upgraded)) == 0,
            "upgraded schema6 profile was not stable after reload");

    const uint16_t extra_field_offsets[] = {344, 351, 358, 362, 363};
    for (uint16_t offset : extra_field_offsets) {
        uint8_t invalid[sizeof(kLegacySchema6Profile)]{};
        memcpy(invalid, kLegacySchema6Profile, sizeof(invalid));
        invalid[offset] = 1;
        require(!controller_profile_decode(invalid, sizeof(invalid), &reloaded),
                "schema6 interpreted an extra-control field in reserved padding");
    }
    const uint16_t source_offsets[] = {256, 266};
    for (uint16_t offset : source_offsets) {
        uint8_t invalid[sizeof(kLegacySchema6Profile)]{};
        memcpy(invalid, kLegacySchema6Profile, sizeof(invalid));
        invalid[offset] = CONTROLLER_PROFILE_FIRST_EXTRA_CONTROL;
        require(!controller_profile_decode(invalid, sizeof(invalid), &reloaded),
                "schema6 admitted an extra-control modifier");
    }
    uint8_t invalid[sizeof(kLegacySchema6Profile)]{};
    memcpy(invalid, kLegacySchema6Profile, sizeof(invalid));
    invalid[98] = (CONTROLLER_PROFILE_FIRST_EXTRA_CONTROL << 2) | 1;
    require(!controller_profile_decode(invalid, sizeof(invalid), &reloaded),
            "schema6 admitted an extra-control macro cancellation");
}

void test_extra_control_schema_round_trip_and_output_limits() {
    ControllerProfile profile{};
    require(controller_profile_decode(kLegacySchema6Profile,
                                      sizeof(kLegacySchema6Profile), &profile),
            "extra-control fixture did not decode");
    const uint8_t extra_map[] = {0, 16, 17, 12, 13, 14, 15};
    const uint8_t shifted_map[] = {15, 14, 13, 12, 3, 2, 0xff};
    memcpy(profile.extra_button_map, extra_map, sizeof(extra_map));
    memcpy(profile.shift.extra_button_map, shifted_map, sizeof(shifted_map));
    profile.shortcuts.modifier = 18;
    profile.shift.modifier = 24;
    profile.switching_chord |= 0x55u << 18;
    profile.motion_toggle_chord |= 0x2au << 18;
    for (uint8_t index = 0; index < CONTROLLER_PROFILE_MACRO_COUNT; ++index) {
        profile.macros[index].trigger_mask |= (1u << index) << 18;
        profile.macros[index].cancel_control = 24 - index;
    }
    uint8_t encoded[CONTROLLER_PROFILE_ENCODED_SIZE]{};
    ControllerProfile decoded{};
    require(controller_profile_encode(profile, encoded, sizeof(encoded)) &&
                controller_profile_decode(encoded, sizeof(encoded), &decoded),
            "extra-control profile did not round-trip");
    require(memcmp(encoded + 344, extra_map, sizeof(extra_map)) == 0 &&
                memcmp(encoded + 351, shifted_map, sizeof(shifted_map)) == 0 &&
                encoded[358] == 1 && encoded[359] == 2 &&
                encoded[360] == 4 && encoded[361] == 8 &&
                encoded[362] == 0x55 && encoded[363] == 0x2a,
            "extra-control fields do not use the schema7 extension layout");
    uint8_t round_trip[CONTROLLER_PROFILE_ENCODED_SIZE]{};
    require(controller_profile_encode(decoded, round_trip, sizeof(round_trip)) &&
                memcmp(encoded, round_trip, sizeof(encoded)) == 0,
            "extra controls lost masks, mappings, or modifiers on reload");
    for (uint16_t offset = 358; offset < 364; ++offset) {
        encoded[offset] |= 0x80;
        require(!controller_profile_decode(encoded, sizeof(encoded), &decoded),
                "out-of-range extra-control mask was accepted");
        encoded[offset] &= 0x7f;
    }
    profile.extra_button_map[0] = 18;
    require(!controller_profile_validate(profile),
            "extra input was accepted as a console output destination");
    profile.extra_button_map[0] = 0;
    profile.triggers[0].output = 18;
    require(!controller_profile_validate(profile),
            "analog trigger was allowed to route into a source-only control");
    profile.triggers[0].output = 0;
    profile.shift.extra_button_map[0] = 16;
    require(!controller_profile_validate(profile),
            "Shift extra mapping admitted an analog destination");
}

}  // namespace
int main() {
    test_pair_identity_wire_and_member_validation();
    test_profile_wire_schema();
    test_legacy_profile_migration();
    test_database_round_trip_and_capacity();
    test_set_b_sparse_extension_and_migration();
    test_legacy_database_strides();
    test_schema6_migration_preserves_every_setting();
    test_extra_control_schema_round_trip_and_output_limits();
    return 0;
}