//! Passive, behavior-preserving diagnostic traces for FIFA 17's offline-season
//! entry flow.
//!
//! RE (2026-08-19, live memory) placed the "problem communicating with the FIFA
//! Ultimate Team servers" modal in the `futOfflineSeasonEntry` ActionScript's
//! season-load path. A first trace on the load completion `FUN_1800578e0`
//! (`0x578e0`) armed but NEVER fired on an entry attempt — so the modal is raised
//! before that callback runs. These traces log the actual CardsDLL season-native
//! call sequence (which functions the entry screen reaches, and in what order) so
//! we can see exactly where the flow stops/fails. Every trace is read-only: it
//! logs, then calls the original through a trampoline; it never alters control
//! flow. Targets are chosen so their copied prologues are position-independent
//! (no rip-relative / rel32 in the copied bytes).

use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering};

use windows_sys::Win32::System::Diagnostics::Debug::FlushInstructionCache;
use windows_sys::Win32::System::LibraryLoader::GetModuleHandleA;
use windows_sys::Win32::System::Memory::{
    VirtualAlloc, VirtualProtect, MEM_COMMIT, MEM_RESERVE, PAGE_EXECUTE_READ,
    PAGE_EXECUTE_READWRITE, PAGE_READWRITE,
};
use windows_sys::Win32::System::Threading::GetCurrentProcess;
use windows_sys::Win32::System::Diagnostics::Debug::{
    AddVectoredExceptionHandler, EXCEPTION_POINTERS,
};

use crate::sbc_trace::{
    absolute_jump, allocate_trampoline, readable_range, target_va, validate_cards_build,
};
use crate::write_log;

static REPORTS: AtomicUsize = AtomicUsize::new(0);
/// One-shot guard for the staging-only CACHE_PACKNAMES_FAILED -> SUCCESS bypass.
static BYPASS_DONE: AtomicBool = AtomicBool::new(false);

unsafe fn rd_i32(addr: usize) -> Option<i32> {
    readable_range(addr, 4).then(|| core::ptr::read_volatile(addr as *const i32))
}
unsafe fn rd_u8(addr: usize) -> Option<u8> {
    readable_range(addr, 1).then(|| core::ptr::read_volatile(addr as *const u8))
}
/// Read a NUL-terminated string safely (bounded, only reads mapped bytes).
unsafe fn rd_cstr(addr: usize, max: usize) -> String {
    if addr == 0 || !readable_range(addr, 1) {
        return String::from("<unreadable>");
    }
    let mut out = Vec::new();
    let mut i = 0;
    while i < max && readable_range(addr + i, 1) {
        let b = core::ptr::read_volatile((addr + i) as *const u8);
        if b == 0 {
            break;
        }
        out.push(b);
        i += 1;
    }
    String::from_utf8_lossy(&out).into_owned()
}

/// Generic passive detour: overwrite the first `copy_len` bytes of `target` (which
/// MUST be whole, position-independent instructions) with an absolute jump to
/// `wrapper`; the wrapper calls the trampoline (copied prologue + jump back).
unsafe fn install_detour(
    base: usize,
    rva: usize,
    name: &str,
    copy_len: usize,
    signature: &[u8],
    wrapper: usize,
    trampoline_slot: &AtomicUsize,
) -> bool {
    let Some(target) = target_va(base, rva) else {
        write_log(&format!("SEASON_TRACE: {name}: VA overflow\n"));
        return false;
    };
    if !readable_range(target, copy_len)
        || core::slice::from_raw_parts(target as *const u8, copy_len) != signature
    {
        write_log(&format!(
            "SEASON_TRACE: {name}: prologue signature mismatch at {target:#x}; skip\n"
        ));
        return false;
    }
    let Some(trampoline) = allocate_trampoline(target, copy_len) else {
        write_log(&format!("SEASON_TRACE: {name}: trampoline alloc failed\n"));
        return false;
    };
    trampoline_slot.store(trampoline, Ordering::Release);
    let mut patch = [0x90u8; 24];
    let jump = absolute_jump(wrapper);
    patch[..jump.len()].copy_from_slice(&jump);
    let mut old = 0u32;
    if VirtualProtect(target as _, copy_len, PAGE_EXECUTE_READWRITE, &mut old) == 0 {
        write_log(&format!("SEASON_TRACE: {name}: VirtualProtect failed\n"));
        return false;
    }
    core::ptr::copy_nonoverlapping(patch.as_ptr(), target as *mut u8, copy_len);
    let flushed = FlushInstructionCache(GetCurrentProcess(), target as _, copy_len) != 0;
    let mut ignored = 0u32;
    VirtualProtect(target as _, copy_len, old, &mut ignored);
    if flushed {
        write_log(&format!(
            "SEASON_TRACE: {name}: installed at {target:#x} (tramp {trampoline:#x})\n"
        ));
        true
    } else {
        write_log(&format!("SEASON_TRACE: {name}: flush failed\n"));
        false
    }
}

fn log_call(name: &str, rcx: usize, rdx: usize, r8: usize) {
    let n = REPORTS.fetch_add(1, Ordering::Relaxed);
    if n < 64 {
        write_log(&format!(
            "SEASON_CALL: {name} rcx={rcx:#x} rdx={rdx:#x} r8={r8:#x}\n"
        ));
    }
}

/// Declare a passive 4-register-arg call trace. The wrapper is entered via the
/// abs-jump patched over the target prologue (original args in rcx/rdx/r8/r9,
/// caller's return address on the stack), logs, then tail-calls the original via
/// the trampoline. A 4-arg/usize-return signature safely covers these season
/// natives (<=4 integer args, void/int returns).
macro_rules! season_call_trace {
    ($wrap:ident, $tramp:ident, $name:literal) => {
        static $tramp: AtomicUsize = AtomicUsize::new(0);
        unsafe extern "system" fn $wrap(rcx: usize, rdx: usize, r8: usize, r9: usize) -> usize {
            log_call($name, rcx, rdx, r8);
            let t = $tramp.load(Ordering::Acquire);
            if t == 0 {
                return 0;
            }
            let original: unsafe extern "system" fn(usize, usize, usize, usize) -> usize =
                core::mem::transmute(t);
            original(rcx, rdx, r8, r9)
        }
    };
}

season_call_trace!(load_current_native_wrapper, LOAD_CURRENT_NATIVE_TRAMP, "LoadCurrentOfflineSeason_native");
season_call_trace!(start_season_native_wrapper, START_SEASON_NATIVE_TRAMP, "StartSeason_native");
season_call_trace!(get_info_native_wrapper, GET_INFO_NATIVE_TRAMP, "GetOfflineSeasonInfo_native");
// Real LoadOfflineSeasons native (FUN_18004ee10) — what _LoadCurrentSeason
// actually calls; hands the callback name to the manager's async slot 0x80.
season_call_trace!(load_offline_real_wrapper, LOAD_OFFLINE_REAL_TRAMP, "LoadOfflineSeasons_native(0x4ee10)");
// Async LoadOfflineSeasons impl (mgr slot 0x80, FUN_180057560): reads the season
// count and invokes the LoadSeasons_Complete AS callback.
season_call_trace!(load_offline_async_wrapper, LOAD_OFFLINE_ASYNC_TRAMP, "LoadOfflineSeasons_asyncimpl(0x57560)");

// LoadCurrentOfflineSeason IMPL (manager slot 0x20): registers the load callbacks
// and starts the async op. param_1=manager, param_2=state byte, param_3=seasonId
// string ptr. Logs those, then calls the original.
static LOAD_CURRENT_IMPL_TRAMP: AtomicUsize = AtomicUsize::new(0);
unsafe extern "system" fn load_current_impl_wrapper(
    param_1: usize,
    param_2: usize,
    param_3: usize,
    param_4: usize,
) -> usize {
    let n = REPORTS.fetch_add(1, Ordering::Relaxed);
    if n < 64 {
        // param_3 -> C string season id (best-effort read of first bytes).
        let sid = if param_3 != 0 && readable_range(param_3, 8) {
            let p = *(param_3 as *const usize);
            if p != 0 && readable_range(p, 8) {
                *(p as *const u64)
            } else {
                0
            }
        } else {
            0
        };
        write_log(&format!(
            "SEASON_CALL: LoadCurrentOfflineSeason_impl mgr={param_1:#x} stateByte={param_2:#x} sidPtr={param_3:#x} sidHead={sid:#x}\n"
        ));
    }
    let t = LOAD_CURRENT_IMPL_TRAMP.load(Ordering::Acquire);
    if t == 0 {
        return 0;
    }
    let original: unsafe extern "system" fn(usize, usize, usize, usize) -> usize =
        core::mem::transmute(t);
    original(param_1, param_2, param_3, param_4)
}

// Completion callback FUN_1800578e0 (0x578e0). Kept from the first pass to confirm
// whether it ever fires; logs the result fields it branches on.
static COMPLETION_TRAMP: AtomicUsize = AtomicUsize::new(0);
unsafe extern "system" fn completion_wrapper(ctx: usize, result: usize, r8: usize, r9: usize) -> usize {
    let n = REPORTS.fetch_add(1, Ordering::Relaxed);
    if n < 64 {
        let status = rd_i32(result + 0x1c);
        let state = rd_u8(result + 0x68);
        let season_id = rd_i32(result + 0x5c);
        write_log(&format!(
            "SEASON_LOAD_COMPLETE: ctx={ctx:#x} result={result:#x} status(+0x1c)={} state(+0x68)={} seasonId(+0x5c)={}\n",
            status.map(|x| x.to_string()).unwrap_or_else(|| "??".into()),
            state.map(|x| x.to_string()).unwrap_or_else(|| "??".into()),
            season_id.map(|x| x.to_string()).unwrap_or_else(|| "??".into()),
        ));
    }
    let t = COMPLETION_TRAMP.load(Ordering::Acquire);
    if t == 0 {
        return 0;
    }
    let original: unsafe extern "system" fn(usize, usize, usize, usize) -> usize =
        core::mem::transmute(t);
    original(ctx, result, r8, r9)
}

// GetUsersOfflineDivision native FUN_18004eb50 (registration FUN_18004e3f0 proved
// this binding — it is NOT LoadOfflineSeasons). Called from _InitializeScreen for
// the division display, sync. Its prologue holds a rip-relative `MOV RCX,[rip+disp]`,
// so it needs the relocating installer below.
season_call_trace!(get_users_division_wrapper, GET_USERS_DIVISION_TRAMP, "GetUsersOfflineDivision_native(0x4eb50)");

/// Find a free page within ~±1.5 GiB of `base`, so a rip-relative disp32 into
/// CardsDLL data still fits after we relocate a copied prologue into it.
unsafe fn alloc_near(base: usize, size: usize) -> Option<usize> {
    const GRAN: usize = 0x10000;
    let mut step = GRAN;
    while step < 0x6000_0000 {
        for signed in [step as isize, -(step as isize)] {
            let cand = base.wrapping_add(signed as usize) & !(GRAN - 1);
            if cand == 0 {
                continue;
            }
            let p = VirtualAlloc(cand as _, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
            if !p.is_null() {
                return Some(p as usize);
            }
        }
        step += GRAN;
    }
    None
}

/// Passive detour for a target whose copied prologue contains a single
/// rip-relative operand (disp32 at `disp_off`, instruction ending at `insn_end`,
/// both within the copied bytes). The trampoline is allocated near `base` and the
/// disp32 is relocated so it resolves to the same absolute address. Read-only.
#[allow(clippy::too_many_arguments)]
unsafe fn install_detour_reloc(
    base: usize,
    rva: usize,
    name: &str,
    copy_len: usize,
    signature: &[u8],
    disp_off: usize,
    insn_end: usize,
    wrapper: usize,
    trampoline_slot: &AtomicUsize,
) -> bool {
    let Some(target) = target_va(base, rva) else {
        write_log(&format!("SEASON_TRACE: {name}: VA overflow\n"));
        return false;
    };
    if !readable_range(target, copy_len)
        || core::slice::from_raw_parts(target as *const u8, copy_len) != signature
    {
        write_log(&format!(
            "SEASON_TRACE: {name}: prologue signature mismatch at {target:#x}; skip\n"
        ));
        return false;
    }
    let jump = absolute_jump(wrapper);
    let tramp_len = copy_len + jump.len();
    let Some(tramp) = alloc_near(base, tramp_len) else {
        write_log(&format!("SEASON_TRACE: {name}: near trampoline alloc failed\n"));
        return false;
    };
    core::ptr::copy_nonoverlapping(target as *const u8, tramp as *mut u8, copy_len);
    // Relocate the rip-relative disp32 to keep the same absolute target.
    let orig_disp = core::ptr::read_unaligned((target + disp_off) as *const i32) as i64;
    let abs_target = target as i64 + insn_end as i64 + orig_disp;
    let new_disp = abs_target - (tramp as i64 + insn_end as i64);
    if new_disp < i32::MIN as i64 || new_disp > i32::MAX as i64 {
        write_log(&format!("SEASON_TRACE: {name}: reloc out of range ({new_disp:#x})\n"));
        return false;
    }
    core::ptr::write_unaligned((tramp + disp_off) as *mut i32, new_disp as i32);
    let back = absolute_jump(target + copy_len);
    core::ptr::copy_nonoverlapping(back.as_ptr(), (tramp + copy_len) as *mut u8, back.len());
    let mut old = 0u32;
    if VirtualProtect(tramp as _, tramp_len, PAGE_EXECUTE_READ, &mut old) == 0 {
        write_log(&format!("SEASON_TRACE: {name}: trampoline protect failed\n"));
        return false;
    }
    FlushInstructionCache(GetCurrentProcess(), tramp as _, tramp_len);
    trampoline_slot.store(tramp, Ordering::Release);
    let mut patch = [0x90u8; 24];
    patch[..jump.len()].copy_from_slice(&jump);
    let mut prot = 0u32;
    if VirtualProtect(target as _, copy_len, PAGE_EXECUTE_READWRITE, &mut prot) == 0 {
        write_log(&format!("SEASON_TRACE: {name}: VirtualProtect failed\n"));
        return false;
    }
    core::ptr::copy_nonoverlapping(patch.as_ptr(), target as *mut u8, copy_len);
    let flushed = FlushInstructionCache(GetCurrentProcess(), target as _, copy_len) != 0;
    let mut ignored = 0u32;
    VirtualProtect(target as _, copy_len, prot, &mut ignored);
    if flushed {
        write_log(&format!(
            "SEASON_TRACE: {name}: installed(reloc) at {target:#x} (tramp {tramp:#x})\n"
        ));
        true
    } else {
        write_log(&format!("SEASON_TRACE: {name}: flush failed\n"));
        false
    }
}

// FutCompetitionServiceImpl::LoadOfflineSeasons FINAL completion (FUN_1800ffe90):
// delivers the result to the AS callback LoadSeasons_Complete via
// FUN_18019fb30->slot0x20(vm,"_global",cbref, "SUCCESS" | errString). param_1 = the
// completion ctx (cbref at +0x18), param_2 = result obj (byte0=ok flag; +8 = error
// string ptr when byte0==0). Logs the EXACT status string delivered. Passive.
static FINAL_COMPLETION_TRAMP: AtomicUsize = AtomicUsize::new(0);
unsafe extern "system" fn final_completion_wrapper(ctx: usize, result: usize, r8: usize, r9: usize) -> usize {
    // Read the delivered status: byte0==0 => failure with an error string at +8.
    let flag = rd_u8(result);
    let errstr = if flag == Some(0) {
        let p = if readable_range(result + 8, 8) {
            core::ptr::read_volatile((result + 8) as *const usize)
        } else {
            0
        };
        rd_cstr(p, 96)
    } else {
        String::new()
    };
    let n = REPORTS.fetch_add(1, Ordering::Relaxed);
    if n < 64 {
        let cbref = if readable_range(ctx + 0x18, 8) {
            core::ptr::read_volatile((ctx + 0x18) as *const usize)
        } else {
            0
        };
        let kind = match flag {
            Some(0) => "ERROR",
            Some(_) => "SUCCESS",
            None => "??",
        };
        let shown = if flag == Some(0) { errstr.as_str() } else { "SUCCESS" };
        write_log(&format!(
            "SEASONS_LOAD_CALLBACK: final kind={kind} result={shown:?} flag={flag:?} ctx={ctx:#x} cbref={cbref:#x}\n"
        ));
    }
    // Base-supply experiment: the CACHE_PACKNAMES failure is expected to be fixed
    // by the WEBFILE base-supply (the real file now downloads), so the guarded
    // success-forcing bypass is DISABLED — a recurring CACHE_PACKNAMES here means
    // the base-supply did not take effect and MUST NOT be masked.
    if flag == Some(0) && errstr.contains("CACHE_PACKNAMES") && !BYPASS_DONE.swap(true, Ordering::AcqRel) {
        write_log("SEASONS_BYPASS: DISABLED (base-supply active); CACHE_PACKNAMES not masked\n");
    }
    let t = FINAL_COMPLETION_TRAMP.load(Ordering::Acquire);
    if t == 0 {
        return 0;
    }
    let original: unsafe extern "system" fn(usize, usize, usize, usize) -> usize =
        core::mem::transmute(t);
    original(ctx, result, r8, r9)
}

// LoadOfflineSeasons STAGE-1 async completion (FUN_180106240): fails with
// "CACHE_PACKNAMES_FAILED" when result==0 or *(i32)(result+0x1c)!=0; else chains
// the next async stage. Logs whether the first async stage succeeded. Passive.
static STAGE1_COMPLETION_TRAMP: AtomicUsize = AtomicUsize::new(0);
unsafe extern "system" fn stage1_completion_wrapper(param1: usize, result: usize, r8: usize, r9: usize) -> usize {
    let n = REPORTS.fetch_add(1, Ordering::Relaxed);
    if n < 64 {
        if result == 0 {
            write_log("SEASONS_STAGE1: result=NULL -> CACHE_PACKNAMES_FAILED\n");
        } else {
            let status = rd_i32(result + 0x1c);
            let verdict = if status == Some(0) { "ok(chain next)" } else { "CACHE_PACKNAMES_FAILED" };
            write_log(&format!(
                "SEASONS_STAGE1: result={result:#x} status(+0x1c)={} -> {verdict}\n",
                status.map(|x| x.to_string()).unwrap_or_else(|| "??".into()),
            ));
        }
    }
    let t = STAGE1_COMPLETION_TRAMP.load(Ordering::Acquire);
    if t == 0 {
        return 0;
    }
    let original: unsafe extern "system" fn(usize, usize, usize, usize) -> usize =
        core::mem::transmute(t);
    original(param1, result, r8, r9)
}

// WEBFILE_DL download start FUN_18017ff90(url, ctx): param_1 (rcx) is the C-string
// URL of the pack-names / cards-tournament-list web file. Its prologue has a
// rip-relative `MOV R8,[DAT_1802e6580]`, so it uses the relocating installer
// (disp32 at copied offset 7, instruction end 11).
//
// BASE-SUPPLY (staging experiment): the client's RS4::ServerSettings CDN base
// (DAT_1802e6408+0x30) is EMPTY in the emulator — FUN_180124270 only sets it when
// the OSDK getter slot0x3f8 is non-empty, and it has no default (unlike the API
// base). So every FUT WEBFILE url arrives here as a BARE relative path and 999s
// (client sentinel). We supply the missing intended `<CDN>/fut/` prefix pointing
// at the staging content server so the REAL file downloads and parses. This is a
// data-supply, NOT a success-forcing bypass; absolute urls (containing "://",
// e.g. the "http://sbc/..." tile route) pass through untouched.
const STAGING_FUT_BASE: &str = "http://10.10.0.120:8110/fut/";
static URL_CAPTURE_TRAMP: AtomicUsize = AtomicUsize::new(0);
unsafe extern "system" fn url_capture_wrapper(rcx: usize, rdx: usize, r8: usize, r9: usize) -> usize {
    let orig = rd_cstr(rcx, 256);
    let mut arg_rcx = rcx;
    // Owned buffer that stays alive across the original() call below. The caller
    // frees its own url buffer immediately after FUN_18017ff90 returns, so the
    // client copies the url synchronously during the call — a local buffer is
    // sufficient and nothing is leaked.
    let mut full: Vec<u8> = Vec::new();
    if !orig.is_empty() && !orig.contains("://") {
        full.extend_from_slice(STAGING_FUT_BASE.as_bytes());
        full.extend_from_slice(orig.trim_start_matches('/').as_bytes());
        full.push(0); // NUL terminator for the C-string
        arg_rcx = full.as_ptr() as usize;
    }
    let n = REPORTS.fetch_add(1, Ordering::Relaxed);
    if n < 64 {
        if arg_rcx != rcx {
            write_log(&format!(
                "SEASONS_WEBFILE_URL: orig={orig:?} rewritten={:?}\n",
                rd_cstr(arg_rcx, 256)
            ));
        } else {
            write_log(&format!("SEASONS_WEBFILE_URL: url={orig:?} (unchanged)\n"));
        }
    }
    let t = URL_CAPTURE_TRAMP.load(Ordering::Acquire);
    if t == 0 {
        return 0;
    }
    let original: unsafe extern "system" fn(usize, usize, usize, usize) -> usize =
        core::mem::transmute(t);
    let ret = original(arg_rcx, rdx, r8, r9);
    drop(full); // ensure the url buffer outlives the download-start call
    ret
}

// ───────────────────────── crash locator (VEH) ──────────────────────────────
// A vectored exception handler that logs the faulting code/address/module for
// fatal exceptions, then lets the crash proceed (EXCEPTION_CONTINUE_SEARCH). It
// pinpoints the StartSeason crash: whether it is a CardsDLL season-data
// null-deref (fixable by supplying matches/opponents) or an engine/other fault.
static CARDS_BASE: AtomicUsize = AtomicUsize::new(0);
static CARDS_SIZE: AtomicUsize = AtomicUsize::new(0);
static CRASH_LOGS: AtomicUsize = AtomicUsize::new(0);
const EXCEPTION_CONTINUE_SEARCH: i32 = 0;

/// OptionalHeader.SizeOfImage from the module's PE headers (fallback 64 MiB).
unsafe fn cards_image_size(base: usize) -> usize {
    if !readable_range(base + 0x3c, 4) {
        return 0x0400_0000;
    }
    let e_lfanew = core::ptr::read_volatile((base + 0x3c) as *const u32) as usize;
    let so_off = base + e_lfanew + 0x50; // NT header + OptionalHeader.SizeOfImage
    if !readable_range(so_off, 4) {
        return 0x0400_0000;
    }
    core::ptr::read_volatile(so_off as *const u32) as usize
}

unsafe extern "system" fn crash_logger(info: *mut EXCEPTION_POINTERS) -> i32 {
    if info.is_null() {
        return EXCEPTION_CONTINUE_SEARCH;
    }
    let rec = (*info).ExceptionRecord;
    if rec.is_null() {
        return EXCEPTION_CONTINUE_SEARCH;
    }
    let code = (*rec).ExceptionCode as u32;
    // Only fatal codes; skip the many benign first-chance SEH exceptions.
    let interesting = matches!(
        code,
        0xC000_0005 // access violation
            | 0xC000_001D // illegal instruction
            | 0xC000_0094 // integer divide by zero
            | 0xC000_00FD // stack overflow
            | 0xC000_0025 // noncontinuable exception
    );
    if !interesting || CRASH_LOGS.fetch_add(1, Ordering::Relaxed) >= 8 {
        return EXCEPTION_CONTINUE_SEARCH;
    }
    let addr = (*rec).ExceptionAddress as usize;
    let base = CARDS_BASE.load(Ordering::Acquire);
    let size = CARDS_SIZE.load(Ordering::Acquire);
    let module = if base != 0 && addr >= base && addr < base + size {
        format!("CardsDLL+{:#x}", addr - base)
    } else {
        "other".to_string()
    };
    let (kind, fault) = if code == 0xC000_0005 && (*rec).NumberParameters >= 2 {
        let op = (*rec).ExceptionInformation[0];
        let fa = (*rec).ExceptionInformation[1];
        let k = match op {
            0 => "read",
            1 => "write",
            8 => "exec",
            _ => "?",
        };
        (k, fa)
    } else {
        ("", 0usize)
    };
    write_log(&format!(
        "SEASON_CRASH: code={code:#010x} at={addr:#x} module={module} access={kind} fault_addr={fault:#x}\n"
    ));
    EXCEPTION_CONTINUE_SEARCH
}

unsafe fn worker() {
    let mut base = 0usize;
    for _ in 0..600u32 {
        base = GetModuleHandleA(c"CardsDLL_Win64_retail.dll".as_ptr().cast()) as usize;
        if base != 0 {
            break;
        }
        std::thread::sleep(std::time::Duration::from_millis(500));
    }
    if base == 0 || !validate_cards_build(base) {
        write_log("SEASON_TRACE: CardsDLL unavailable/invalid; season trace inactive\n");
        return;
    }
    CARDS_BASE.store(base, Ordering::Release);
    CARDS_SIZE.store(cards_image_size(base), Ordering::Release);
    AddVectoredExceptionHandler(1, Some(crash_logger));
    write_log("SEASON_TRACE: crash logger (VEH) armed\n");
    // (rva, name, copy_len, signature, wrapper, trampoline slot)
    install_detour(
        base, 0x4eb70, "LoadCurrentOfflineSeason_native", 15,
        &[0x40, 0x57, 0x48, 0x83, 0xec, 0x60, 0x48, 0xc7, 0x44, 0x24, 0x20, 0xfe, 0xff, 0xff, 0xff],
        load_current_native_wrapper as *const () as usize, &LOAD_CURRENT_NATIVE_TRAMP,
    );
    install_detour(
        base, 0x4f340, "StartSeason_native", 15,
        &[0x40, 0x57, 0x48, 0x83, 0xec, 0x60, 0x48, 0xc7, 0x44, 0x24, 0x20, 0xfe, 0xff, 0xff, 0xff],
        start_season_native_wrapper as *const () as usize, &START_SEASON_NATIVE_TRAMP,
    );
    install_detour(
        base, 0x4e850, "GetOfflineSeasonInfo_native", 15,
        &[0x48, 0x89, 0x5c, 0x24, 0x08, 0x48, 0x89, 0x6c, 0x24, 0x10, 0x48, 0x89, 0x74, 0x24, 0x18],
        get_info_native_wrapper as *const () as usize, &GET_INFO_NATIVE_TRAMP,
    );
    install_detour(
        base, 0x57230, "LoadCurrentOfflineSeason_impl", 19,
        &[0x48, 0x8b, 0xc4, 0x57, 0x48, 0x81, 0xec, 0x80, 0x00, 0x00, 0x00, 0x48, 0xc7, 0x40, 0x98, 0xfe, 0xff, 0xff, 0xff],
        load_current_impl_wrapper as *const () as usize, &LOAD_CURRENT_IMPL_TRAMP,
    );
    install_detour(
        base, 0x578e0, "LoadCurrentOfflineSeason_completion", 16,
        &[0x48, 0x8b, 0xc4, 0x57, 0x48, 0x83, 0xec, 0x70, 0x48, 0xc7, 0x40, 0xd0, 0xfe, 0xff, 0xff, 0xff],
        completion_wrapper as *const () as usize, &COMPLETION_TRAMP,
    );
    install_detour_reloc(
        base, 0x4eb50, "GetUsersOfflineDivision_native", 14,
        &[0x48, 0x83, 0xec, 0x28, 0x48, 0x8b, 0x0d, 0x75, 0x18, 0x29, 0x00, 0x48, 0x8b, 0x01],
        7, 11,
        get_users_division_wrapper as *const () as usize, &GET_USERS_DIVISION_TRAMP,
    );
    install_detour(
        base, 0x4ee10, "LoadOfflineSeasons_native", 15,
        &[0x40, 0x57, 0x48, 0x83, 0xec, 0x60, 0x48, 0xc7, 0x44, 0x24, 0x20, 0xfe, 0xff, 0xff, 0xff],
        load_offline_real_wrapper as *const () as usize, &LOAD_OFFLINE_REAL_TRAMP,
    );
    install_detour(
        base, 0x57560, "LoadOfflineSeasons_asyncimpl", 17,
        &[0x40, 0x55, 0x56, 0x57, 0x48, 0x83, 0xec, 0x30, 0x48, 0xc7, 0x44, 0x24, 0x20, 0xfe, 0xff, 0xff, 0xff],
        load_offline_async_wrapper as *const () as usize, &LOAD_OFFLINE_ASYNC_TRAMP,
    );
    install_detour(
        base, 0xffe90, "LoadOfflineSeasons_final_completion", 16,
        &[0x48, 0x89, 0x5c, 0x24, 0x08, 0x57, 0x48, 0x83, 0xec, 0x30, 0x80, 0x3a, 0x00, 0x48, 0x8b, 0xda],
        final_completion_wrapper as *const () as usize, &FINAL_COMPLETION_TRAMP,
    );
    install_detour(
        base, 0x106240, "LoadOfflineSeasons_stage1_completion", 15,
        &[0x48, 0x8b, 0xc4, 0x55, 0x48, 0x8d, 0x68, 0xa1, 0x48, 0x81, 0xec, 0xc0, 0x00, 0x00, 0x00],
        stage1_completion_wrapper as *const () as usize, &STAGE1_COMPLETION_TRAMP,
    );
    install_detour_reloc(
        base, 0x17ff90, "start_webfile_dl_url", 14,
        &[0x48, 0x83, 0xec, 0x38, 0x4c, 0x8b, 0x05, 0xe5, 0x65, 0x16, 0x00, 0x4c, 0x8b, 0xd1],
        7, 11,
        url_capture_wrapper as *const () as usize, &URL_CAPTURE_TRAMP,
    );
    write_log("SEASON_TRACE: all season-native traces armed\n");
}

/// Arm the passive season-flow diagnostics on a deferred thread (CardsDLL is not
/// yet loaded at DllMain time). Read-only: never changes game behavior.
pub(crate) fn install() {
    write_log("SEASON_TRACE: requested; deferred signature validation starting\n");
    std::thread::spawn(|| unsafe { worker() });
}