/// EA App LSX protocol emulator (port 3216).
///
/// FIFA 23 opens two concurrent connections to port 3216 (one for EbisuSDK,
/// one for the login service).  We track up to 4 sockets in LSX_POOL with
/// independent state per connection.
use core::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Mutex;

// ─── per-connection slot ─────────────────────────────────────────────────────

struct LsxSlot {
    socket:  AtomicUsize,   // usize::MAX = empty
    state:   AtomicUsize,
    seed:    AtomicUsize,
    pending: Mutex<Option<Vec<u8>>>,
}

const MAX_LSX: usize = 4;

macro_rules! empty_slot {
    () => { LsxSlot {
        socket:  AtomicUsize::new(usize::MAX),
        state:   AtomicUsize::new(0),
        seed:    AtomicUsize::new(0),
        pending: Mutex::new(None),
    }};
}

static POOL: [LsxSlot; MAX_LSX] = [
    empty_slot!(), empty_slot!(), empty_slot!(), empty_slot!(),
];

fn find_slot(s: usize) -> Option<&'static LsxSlot> {
    POOL.iter().find(|sl| sl.socket.load(Ordering::Relaxed) == s)
}

// ─── public API ──────────────────────────────────────────────────────────────

pub fn set_lsx_socket(s: usize) {
    // Try to reuse an existing slot for this socket first
    if find_slot(s).is_some() { return; }
    // Find a free slot
    for sl in &POOL {
        if sl.socket.load(Ordering::Relaxed) == usize::MAX {
            sl.state.store(0, Ordering::Relaxed);
            sl.seed.store(0, Ordering::Relaxed);
            if let Ok(mut g) = sl.pending.lock() { *g = None; }
            sl.socket.store(s, Ordering::Relaxed);
            crate::write_log(&format!("lsx: socket registered s={s}\n"));
            return;
        }
    }
    // All slots full — evict the first one
    let sl = &POOL[0];
    sl.state.store(0, Ordering::Relaxed);
    sl.seed.store(0, Ordering::Relaxed);
    if let Ok(mut g) = sl.pending.lock() { *g = None; }
    sl.socket.store(s, Ordering::Relaxed);
    crate::write_log(&format!("lsx: socket registered s={s} (evicted old slot)\n"));
}

pub fn is_lsx(s: usize) -> bool {
    find_slot(s).is_some()
}

pub fn current_socket() -> usize {
    // Return any active LSX socket (used by select hook if needed)
    POOL.iter()
        .map(|sl| sl.socket.load(Ordering::Relaxed))
        .find(|&s| s != usize::MAX)
        .unwrap_or(usize::MAX)
}

const GREETING_KEY: &str = "cacf897a20b6d612ad0c05e011df52bb";
const AES_KEY: [u8; 16] = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15];

pub unsafe fn on_recv(s: usize, buf: *mut u8, len: i32) -> i32 {
    let sl = match find_slot(s) { Some(x) => x, None => return -1 };
    let state = sl.state.load(Ordering::Relaxed);
    crate::write_log(&format!("lsx: recv s={s} state={state}\n"));

    let payload: Vec<u8> = match state {
        0 => {
            let xml = format!(
                "<LSX>\r\n    <Event sender=\"EALS\">\r\n        <Challenge build=\"release\" key=\"{GREETING_KEY}\" version=\"10,5,30,15625\" />\r\n    </Event>\r\n</LSX>\0"
            );
            sl.state.store(1, Ordering::Relaxed);
            xml.into_bytes()
        }
        _ => {
            let mut guard = sl.pending.lock().unwrap_or_else(|e| e.into_inner());
            match guard.take() {
                Some(pb) => pb,
                None => {
                    // No pending data — return 0.
                    // For the state-1 probe recv (FIFA checking if there is more
                    // greeting data), 0 is the correct "no more data" signal and
                    // FIFA proceeds to send the ChallengeResponse.
                    return 0;
                }
            }
        }
    };

    let n = payload.len().min(len as usize);
    core::ptr::copy_nonoverlapping(payload.as_ptr(), buf, n);
    crate::write_log(&format!("lsx: recv -> {n} bytes\n"));
    n as i32
}

pub unsafe fn on_send(s: usize, buf: *const u8, len: i32) -> i32 {
    let sl = match find_slot(s) { Some(x) => x, None => return len };
    let state = sl.state.load(Ordering::Relaxed);
    let data = core::slice::from_raw_parts(buf, len as usize);
    let text = core::str::from_utf8(data).unwrap_or("(binary)");
    crate::write_log(&format!("lsx: send s={s} state={state} len={len} data={}\n",
        &text[..text.len().min(300)]));

    let response = match state {
        1 => handle_challenge(sl, data),
        st => handle_request(sl, data, st),
    };

    if let Some(payload) = response {
        let mut guard = sl.pending.lock().unwrap_or_else(|e| e.into_inner());
        *guard = Some(payload);
    }
    sl.state.fetch_add(1, Ordering::Relaxed);
    len
}

// ─── handshake ───────────────────────────────────────────────────────────────

fn handle_challenge(sl: &LsxSlot, raw: &[u8]) -> Option<Vec<u8>> {
    let text = core::str::from_utf8(raw).unwrap_or("").trim_end_matches('\0');
    let parts: Vec<&str> = text.split('"').collect();
    let id  = parts.get(3).copied().unwrap_or("1");
    let key = parts.get(7).copied().unwrap_or("");
    crate::write_log(&format!("lsx: challenge id={id} key={key}\n"));

    let our_response = make_challenge_response(key);
    let seed = compute_seed(&our_response);
    sl.seed.store(seed as usize, Ordering::Relaxed);
    crate::write_log(&format!("lsx: response={our_response} seed={seed}\n"));

    let xml = format!(
        "<LSX>\r\n    <Response id=\"{id}\" sender=\"EALS\">\r\n        <ChallengeAccepted response=\"{our_response}\" />\r\n    </Response>\r\n</LSX>\0"
    );
    Some(xml.into_bytes())
}

fn compute_seed(hex: &str) -> u16 {
    let b0 = u8::from_str_radix(&hex[..2.min(hex.len())], 16).unwrap_or(0);
    let b1 = u8::from_str_radix(&hex[2..4.min(hex.len())], 16).unwrap_or(0);
    ((b0 as u16) << 8) | (b1 as u16)
}

fn handle_request(sl: &LsxSlot, raw: &[u8], _state: usize) -> Option<Vec<u8>> {
    let seed = sl.seed.load(Ordering::Relaxed) as u16;
    let text = core::str::from_utf8(raw).unwrap_or("").trim_end_matches('\0');

    let decrypted = lsx_decrypt(text, seed);
    crate::write_log(&format!("lsx: request decrypted={}\n", &decrypted[..decrypted.len().min(300)]));

    let response_xml = dispatch_request(decrypted.trim());
    crate::write_log(&format!("lsx: response={}\n", &response_xml[..response_xml.len().min(300)]));

    let encrypted = lsx_encrypt(&response_xml, seed);
    let payload = format!("{encrypted}\0");
    Some(payload.into_bytes())
}

// ─── session dispatcher ───────────────────────────────────────────────────────

pub fn dispatch(xml: &str) -> String { dispatch_request(xml) }

fn dispatch_request(xml: &str) -> String {
    let parts: Vec<&str> = xml.split('"').collect();
    let id = parts.get(3).copied().unwrap_or("1");
    let req_type = parts.get(4).copied().unwrap_or("");
    crate::write_log(&format!("lsx: dispatch id={id} type={req_type}\n"));

    match req_type {
        "><GetConfig version=" => get_config(id),
        "><GetAuthCode ClientId=" | "><GetAuthCode UserId=" => get_auth_code(id),
        "><GetInternetConnectedState version=" => get_internet_state(id),
        "><GetProfile index=" => get_profile(id),
        "><GetSetting SettingId=" => {
            let setting = parts.get(5).copied().unwrap_or("");
            get_setting(id, setting)
        }
        "><QueryEntitlements UserId=" => query_entitlements(id),
        "><RequestLicense UserId=" => request_license(id),
        "><QueryContent UserId=" => query_content(id),
        "><GetBlockList version=" => get_block_list(id),
        "><QueryFriends UserId=" => query_friends(id),
        "><QueryPresence UserId=" => query_presence(id),
        "><SetPresence UserId=" => set_presence(id),
        "><GetPresenceVisibility UserId=" => get_presence_visibility(id),
        "><GetWalletBalance UserId=" => get_wallet_balance(id),
        "><GetAllGameInfo version=" => get_all_game_info(id),
        _ => {
            crate::write_log(&format!("lsx: UNKNOWN type: {req_type}\n"));
            format!("<LSX><Response id=\"{id}\" sender=\"EbisuSDK\"><Ok /></Response></LSX>\0")
        }
    }
}

// ─── LSX response templates ───────────────────────────────────────────────────

fn get_config(id: &str) -> String {
    format!(r#"<LSX>
    <Response id="{id}" sender="EbisuSDK">
        <GetConfigResponse>
            <Service Facility="SDK" Name="EbisuSDK" />
            <Service Facility="PROFILE" Name="EbisuSDK" />
            <Service Facility="PRESENCE" Name="XMPP" />
            <Service Facility="FRIENDS" Name="XMPP" />
            <Service Facility="COMMERCE" Name="Commerce" />
            <Service Facility="RECENTPLAYER" Name="EbisuSDK" />
            <Service Facility="IGO" Name="EbisuSDK" />
            <Service Facility="MISC" Name="EbisuSDK" />
            <Service Facility="LOGIN" Name="EALS" />
            <Service Facility="UTILITY" Name="Utility" />
            <Service Facility="XMPP" Name="XMPP" />
            <Service Facility="CHAT" Name="XMPP" />
            <Service Facility="IGO_EVENT" Name="EbisuSDK" />
            <Service Facility="EALS_EVENTS" Name="EALS" />
            <Service Facility="LOGIN_EVENT" Name="EbisuSDK" />
            <Service Facility="INVITE_EVENT" Name="XMPP" />
            <Service Facility="PROFILE_EVENT" Name="EbisuSDK" />
            <Service Facility="PRESENCE_EVENT" Name="XMPP" />
            <Service Facility="FRIENDS_EVENT" Name="XMPP" />
            <Service Facility="COMMERCE_EVENT" Name="Commerce" />
            <Service Facility="CHAT_EVENT" Name="XMPP" />
            <Service Facility="DOWNLOAD_EVENT" Name="EbisuSDK" />
            <Service Facility="PERMISSION" Name="EbisuSDK" />
            <Service Facility="RESOURCES" Name="EbisuSDK" />
            <Service Facility="BLOCKED_USERS" Name="EbisuSDK" />
            <Service Facility="BLOCKED_USER_EVENT" Name="EbisuSDK" />
            <Service Facility="GET_USERID" Name="EbisuSDK" />
            <Service Facility="ONLINE_STATUS_EVENT" Name="EbisuSDK" />
            <Service Facility="ACHIEVEMENT" Name="EbisuSDK" />
            <Service Facility="ACHIEVEMENT_EVENT" Name="EbisuSDK" />
            <Service Facility="BROADCAST_EVENT" Name="EbisuSDK" />
            <Service Facility="PROGRESSIVE_INSTALLATION" Name="PI" />
            <Service Facility="PROGRESSIVE_INSTALLATION_EVENT" Name="PI" />
            <Service Facility="CONTENT" Name="EbisuSDK" />
        </GetConfigResponse>
    </Response>
</LSX>"#)
}

fn get_auth_code(id: &str) -> String {
    format!(r#"<LSX>
    <Response id="{id}" sender="Utility">
        <AuthCode value="OpenFUT_fake_auth_code_v1" />
    </Response>
</LSX>"#)
}

fn get_internet_state(id: &str) -> String {
    format!(r#"<LSX>
    <Response id="{id}" sender="Utility">
        <InternetConnectedState connected="1" />
    </Response>
</LSX>"#)
}

fn get_profile(id: &str) -> String {
    format!(r#"<LSX>
  <Response id="{id}" sender="EbisuSDK">
    <GetProfileResponse PersonaId="1000000000001" Persona="OpenFUT_Player" Country="US" GeoCountry="US"
        UserIndex="0" IsTrialSubscriber="false" AvatarId="1"
        IsUnderAge="false" IsSubscriber="false" IsSteamSubscriber="false" SubscriberLevel="2"
        CommerceCurrency="USD" UserId="2000000000001" CommerceCountry="US" />
  </Response>
</LSX>"#)
}

fn get_setting(id: &str, setting: &str) -> String {
    let value = match setting { "ENVIRONMENT" => "production", _ => "false" };
    format!(r#"<LSX>
    <Response id="{id}" sender="EbisuSDK">
        <GetSettingResponse Setting="{value}" />
    </Response>
</LSX>"#)
}

fn query_entitlements(id: &str) -> String {
    format!(r#"<LSX>
    <Response id="{id}" sender="Commerce">
        <QueryEntitlementsResponse>
            <Entitlements ItemId="Origin.OFR.50.0004658" Type="ONLINE_ACCESS"
                EntitlementId="1021747550001" EntitlementTag="ONLINE_ACCESS"
                Group="FIFA23PC" ResourceId="" UseCount="0"
                Expiration="0000-00-00T00:00:00" GrantDate="2022-09-30T00:00:00"
                LastModifiedDate="2022-09-30T00:00:00" Version="0" />
            <Entitlements ItemId="Origin.OFR.50.0004658" Type="DEFAULT"
                EntitlementId="1021747550002" EntitlementTag="ONLINE_ACCESS"
                Group="FIFA23PC" ResourceId="" UseCount="0"
                Expiration="0000-00-00T00:00:00" GrantDate="2022-09-30T00:00:00"
                LastModifiedDate="2022-09-30T00:00:00" Version="0" />
        </QueryEntitlementsResponse>
    </Response>
</LSX>"#)
}

fn request_license(id: &str) -> String {
    format!(r#"<LSX>
    <Response sender="EbisuSDK" id="{id}">
        <RequestLicenseResponse License="OpenFUT_fake_license_v1" />
    </Response>
</LSX>"#)
}

fn query_content(id: &str) -> String {
    format!(r#"<LSX>
    <Response id="{id}" sender="EbisuSDK">
        <QueryContentResponse>
            <Content Gamestate="READY_TO_PLAY" progressValue="0"
                contentID="Origin.OFR.50.0004658"
                installedVersion="1.0.0.0" availableVersion="1.0.0.0"
                displayName="FIFA 23" />
        </QueryContentResponse>
    </Response>
</LSX>"#)
}

fn get_block_list(id: &str) -> String {
    format!(r#"<LSX><Response id="{id}" sender="EbisuSDK"><GetBlockListResponse /></Response></LSX>"#)
}

fn query_friends(id: &str) -> String {
    format!(r#"<LSX><Response id="{id}" sender="XMPP"><QueryFriendsResponse /></Response></LSX>"#)
}

fn query_presence(id: &str) -> String {
    format!(r#"<LSX><Response id="{id}" sender="XMPP"><QueryPresenceResponse UserId="2000000000001" PersonaId="1000000000001" /></Response></LSX>"#)
}

fn set_presence(id: &str) -> String {
    format!(r#"<LSX><Response id="{id}" sender="XMPP"><SetPresenceResponse /></Response></LSX>"#)
}

fn get_presence_visibility(id: &str) -> String {
    format!(r#"<LSX><Response id="{id}" sender="EbisuSDK"><GetPresenceVisibilityResponse Visibility="FRIENDS" /></Response></LSX>"#)
}

fn get_wallet_balance(id: &str) -> String {
    format!(r#"<LSX><Response id="{id}" sender="Commerce"><GetWalletBalanceResponse Balance="0" Currency="USD" /></Response></LSX>"#)
}

fn get_all_game_info(id: &str) -> String {
    format!(r#"<LSX><Response id="{id}" sender="EbisuSDK"><GetAllGameInfoResponse /></Response></LSX>"#)
}

// ─── AES-128-ECB (pure Rust) ──────────────────────────────────────────────────

#[rustfmt::skip]
const SBOX: [u8; 256] = [
    0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
    0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
    0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
    0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
    0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
    0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
    0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
    0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
    0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
    0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
    0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
    0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
    0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
    0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
    0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
    0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16,
];

fn xtime(a: u8) -> u8 { if a & 0x80 != 0 { (a << 1) ^ 0x1b } else { a << 1 } }
fn mul(mut a: u8, mut b: u8) -> u8 {
    let mut r = 0u8;
    while b > 0 { if b & 1 != 0 { r ^= a; } a = xtime(a); b >>= 1; }
    r
}

fn sub_bytes(s: &mut [u8; 16]) { for b in s.iter_mut() { *b = SBOX[*b as usize]; } }
fn shift_rows(s: &mut [u8; 16]) {
    let t = s[1]; s[1]=s[5]; s[5]=s[9]; s[9]=s[13]; s[13]=t;
    s.swap(2,10); s.swap(6,14);
    let t = s[15]; s[15]=s[11]; s[11]=s[7]; s[7]=s[3]; s[3]=t;
}
fn mix_col(s: &mut [u8; 16], c: usize) {
    let (a,b,c2,d) = (s[c],s[c+4],s[c+8],s[c+12]);
    s[c]    = mul(2,a)^mul(3,b)^c2^d;
    s[c+4]  = a^mul(2,b)^mul(3,c2)^d;
    s[c+8]  = a^b^mul(2,c2)^mul(3,d);
    s[c+12] = mul(3,a)^b^c2^mul(2,d);
}
fn mix_columns(s: &mut [u8; 16]) { for c in 0..4 { mix_col(s,c); } }
fn add_round_key(s: &mut [u8; 16], rk: &[u8; 16]) { for i in 0..16 { s[i] ^= rk[i]; } }

fn expand_key(key: &[u8; 16]) -> [[u8; 16]; 11] {
    let rcon: [u8; 10] = [0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36];
    let mut w = [[0u8; 4]; 44];
    for i in 0..4 { w[i] = [key[4*i],key[4*i+1],key[4*i+2],key[4*i+3]]; }
    for i in 4..44 {
        let mut t = w[i-1];
        if i % 4 == 0 {
            t.rotate_left(1);
            for b in &mut t { *b = SBOX[*b as usize]; }
            t[0] ^= rcon[i/4-1];
        }
        w[i] = [w[i-4][0]^t[0], w[i-4][1]^t[1], w[i-4][2]^t[2], w[i-4][3]^t[3]];
    }
    let mut rk = [[0u8; 16]; 11];
    for r in 0..11 { for c in 0..4 { rk[r][4*c..4*c+4].copy_from_slice(&w[r*4+c]); } }
    rk
}

fn aes_block_encrypt(block: &[u8; 16], rk: &[[u8; 16]; 11]) -> [u8; 16] {
    let mut s = *block;
    add_round_key(&mut s, &rk[0]);
    for r in 1..10 { sub_bytes(&mut s); shift_rows(&mut s); mix_columns(&mut s); add_round_key(&mut s, &rk[r]); }
    sub_bytes(&mut s); shift_rows(&mut s); add_round_key(&mut s, &rk[10]);
    s
}

fn aes_ecb_pkcs7_encrypt(key: &[u8; 16], plaintext: &[u8]) -> Vec<u8> {
    let rk = expand_key(key);
    let pad = 16 - (plaintext.len() % 16);
    let mut padded = plaintext.to_vec();
    padded.resize(plaintext.len() + pad, pad as u8);
    let mut out = Vec::with_capacity(padded.len());
    for chunk in padded.chunks(16) {
        let mut b = [0u8; 16]; b.copy_from_slice(chunk);
        out.extend_from_slice(&aes_block_encrypt(&b, &rk));
    }
    out
}

#[rustfmt::skip]
const INV_SBOX: [u8; 256] = [
    0x52,0x09,0x6a,0xd5,0x30,0x36,0xa5,0x38,0xbf,0x40,0xa3,0x9e,0x81,0xf3,0xd7,0xfb,
    0x7c,0xe3,0x39,0x82,0x9b,0x2f,0xff,0x87,0x34,0x8e,0x43,0x44,0xc4,0xde,0xe9,0xcb,
    0x54,0x7b,0x94,0x32,0xa6,0xc2,0x23,0x3d,0xee,0x4c,0x95,0x0b,0x42,0xfa,0xc3,0x4e,
    0x08,0x2e,0xa1,0x66,0x28,0xd9,0x24,0xb2,0x76,0x5b,0xa2,0x49,0x6d,0x8b,0xd1,0x25,
    0x72,0xf8,0xf6,0x64,0x86,0x68,0x98,0x16,0xd4,0xa4,0x5c,0xcc,0x5d,0x65,0xb6,0x92,
    0x6c,0x70,0x48,0x50,0xfd,0xed,0xb9,0xda,0x5e,0x15,0x46,0x57,0xa7,0x8d,0x9d,0x84,
    0x90,0xd8,0xab,0x00,0x8c,0xbc,0xd3,0x0a,0xf7,0xe4,0x58,0x05,0xb8,0xb3,0x45,0x06,
    0xd0,0x2c,0x1e,0x8f,0xca,0x3f,0x0f,0x02,0xc1,0xaf,0xbd,0x03,0x01,0x13,0x8a,0x6b,
    0x3a,0x91,0x11,0x41,0x4f,0x67,0xdc,0xea,0x97,0xf2,0xcf,0xce,0xf0,0xb4,0xe6,0x73,
    0x96,0xac,0x74,0x22,0xe7,0xad,0x35,0x85,0xe2,0xf9,0x37,0xe8,0x1c,0x75,0xdf,0x6e,
    0x47,0xf1,0x1a,0x71,0x1d,0x29,0xc5,0x89,0x6f,0xb7,0x62,0x0e,0xaa,0x18,0xbe,0x1b,
    0xfc,0x56,0x3e,0x4b,0xc6,0xd2,0x79,0x20,0x9a,0xdb,0xc0,0xfe,0x78,0xcd,0x5a,0xf4,
    0x1f,0xdd,0xa8,0x33,0x88,0x07,0xc7,0x31,0xb1,0x12,0x10,0x59,0x27,0x80,0xec,0x5f,
    0x60,0x51,0x7f,0xa9,0x19,0xb5,0x4a,0x0d,0x2d,0xe5,0x7a,0x9f,0x93,0xc9,0x9c,0xef,
    0xa0,0xe0,0x3b,0x4d,0xae,0x2a,0xf5,0xb0,0xc8,0xeb,0xbb,0x3c,0x83,0x53,0x99,0x61,
    0x17,0x2b,0x04,0x7e,0xba,0x77,0xd6,0x26,0xe1,0x69,0x14,0x63,0x55,0x21,0x0c,0x7d,
];

fn inv_sub_bytes(s: &mut [u8; 16]) { for b in s.iter_mut() { *b = INV_SBOX[*b as usize]; } }
fn inv_shift_rows(s: &mut [u8; 16]) {
    let t = s[13]; s[13]=s[9]; s[9]=s[5]; s[5]=s[1]; s[1]=t;
    s.swap(2,10); s.swap(6,14);
    let t = s[3]; s[3]=s[7]; s[7]=s[11]; s[11]=s[15]; s[15]=t;
}
fn inv_mix_col(s: &mut [u8; 16], c: usize) {
    let (a,b,c2,d) = (s[c],s[c+4],s[c+8],s[c+12]);
    s[c]    = mul(0x0e,a)^mul(0x0b,b)^mul(0x0d,c2)^mul(0x09,d);
    s[c+4]  = mul(0x09,a)^mul(0x0e,b)^mul(0x0b,c2)^mul(0x0d,d);
    s[c+8]  = mul(0x0d,a)^mul(0x09,b)^mul(0x0e,c2)^mul(0x0b,d);
    s[c+12] = mul(0x0b,a)^mul(0x0d,b)^mul(0x09,c2)^mul(0x0e,d);
}
fn inv_mix_columns(s: &mut [u8; 16]) { for c in 0..4 { inv_mix_col(s,c); } }

fn aes_ecb_decrypt_nopad(key: &[u8; 16], data: &[u8]) -> Vec<u8> {
    let rk = expand_key(key);
    let mut out = Vec::with_capacity(data.len());
    for chunk in data.chunks(16) {
        if chunk.len() < 16 { break; }
        let mut b = [0u8; 16]; b.copy_from_slice(chunk);
        add_round_key(&mut b, &rk[10]);
        inv_shift_rows(&mut b); inv_sub_bytes(&mut b);
        for r in (1..10).rev() {
            add_round_key(&mut b, &rk[r]);
            inv_mix_columns(&mut b); inv_shift_rows(&mut b); inv_sub_bytes(&mut b);
        }
        add_round_key(&mut b, &rk[0]);
        out.extend_from_slice(&b);
    }
    if let Some(&pad) = out.last() {
        let pad = pad as usize;
        if pad <= 16 && out.len() >= pad { out.truncate(out.len() - pad); }
    }
    out
}

// ─── CRandom ─────────────────────────────────────────────────────────────────

struct CRandom { seed: u32 }
impl CRandom {
    fn new() -> Self { Self { seed: 0 } }
    fn seed_with(&mut self, s: u32) { self.seed = s; }
    fn rand(&mut self) -> u32 {
        self.seed = self.seed.wrapping_mul(214013).wrapping_add(2531011);
        (self.seed >> 16) & 0xFFFF
    }
}

fn get_lsx_key(seed: u16) -> [u8; 16] {
    let mut rng = CRandom::new();
    rng.seed_with(7);
    let next = rng.rand();
    rng.seed_with(next.wrapping_add(seed as u32));
    let mut k = [0u8; 16];
    for b in &mut k { *b = rng.rand() as u8; }
    k
}

// ─── session encrypt/decrypt ─────────────────────────────────────────────────

fn hex_to_bytes(s: &str) -> Vec<u8> {
    let s: String = s.chars().filter(|c| c.is_ascii_hexdigit()).collect();
    if s.len() % 2 != 0 { return Vec::new(); }
    (0..s.len()/2).filter_map(|i| u8::from_str_radix(&s[2*i..2*i+2], 16).ok()).collect()
}

fn bytes_to_hex(b: &[u8]) -> String {
    b.iter().map(|x| format!("{x:02x}")).collect()
}

pub fn lsx_decrypt(hex_data: &str, seed: u16) -> String {
    let key = get_lsx_key(seed);
    let ct = hex_to_bytes(hex_data);
    if ct.is_empty() { return String::new(); }
    let plain = aes_ecb_decrypt_nopad(&key, &ct);
    String::from_utf8_lossy(&plain).trim_matches('\0').to_string()
}

pub fn lsx_encrypt(text: &str, seed: u16) -> String {
    let key = get_lsx_key(seed);
    bytes_to_hex(&aes_ecb_pkcs7_encrypt(&key, text.as_bytes()))
}

pub fn make_challenge_response(key: &str) -> String {
    bytes_to_hex(&aes_ecb_pkcs7_encrypt(&AES_KEY, key.as_bytes()))
}