pub mod user;

use rusqlite::params;
use lazy_static::lazy_static;
use jzon::{JsonValue, array, object};
use rand::RngExt;

use crate::router::global;
use crate::router::items;
use crate::router::card;
use crate::database::custom_song;
use crate::sql::SQLite;
use crate::include_file;

lazy_static! {
    static ref DATABASE: SQLite = SQLite::new("userdata.db", setup_tables);
    static ref NEW_USER: JsonValue = {
        let raw = crate::runtime::read_masterdata_file("userdata/new_user.json")
            .and_then(|b| String::from_utf8(b).ok())
            .unwrap_or_else(|| include_file!("src/router/userdata/new_user.json"));
        jzon::parse(&raw).unwrap()
    };
}

fn get_userdata_database() -> &'static SQLite {
    &DATABASE
}

fn setup_tables(conn: &rusqlite::Connection) {
    user::migration::setup_sql(conn).unwrap();
    conn.execute_batch("
CREATE TABLE IF NOT EXISTS tokens (
    user_id           BIGINT NOT NULL PRIMARY KEY,
    token             TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS userdata (
    user_id                  BIGINT NOT NULL PRIMARY KEY,
    userdata                 TEXT NOT NULL,
    friend_request_disabled  INT NOT NULL,
    protocol_version         INT NOT NULL DEFAULT 0
);
CREATE TABLE IF NOT EXISTS userhome (
    user_id          BIGINT NOT NULL PRIMARY KEY,
    userhome         TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS missions (
    user_id          BIGINT NOT NULL PRIMARY KEY,
    missions         TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS loginbonus (
    user_id          BIGINT NOT NULL PRIMARY KEY,
    loginbonus       TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS sifcards (
    user_id          BIGINT NOT NULL PRIMARY KEY,
    sifcards         TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS friends (
    user_id          BIGINT NOT NULL PRIMARY KEY,
    friends          TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS chats (
    user_id          BIGINT NOT NULL PRIMARY KEY,
    chats            TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS exchange (
    user_id          BIGINT NOT NULL PRIMARY KEY,
    exchange         TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS event (
    user_id          BIGINT NOT NULL PRIMARY KEY,
    event            TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS eventloginbonus (
    user_id          BIGINT NOT NULL PRIMARY KEY,
    eventloginbonus  TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS server_data (
    user_id          BIGINT NOT NULL PRIMARY KEY,
    server_data      TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS webui (
    user_id      BIGINT NOT NULL PRIMARY KEY,
    token        TEXT NOT NULL,
    last_login   BIGINT NOT NULL
);
INSERT OR IGNORE INTO exchange (user_id, exchange) SELECT user_id, '[]' FROM userdata;
    ").unwrap();


    let is_updated = conn.prepare("SELECT protocol_version FROM userdata LIMIT 1;").is_ok();
    if !is_updated {
        println!("Upgrading userdata table");
        conn.execute("ALTER TABLE userdata ADD COLUMN protocol_version INT NOT NULL DEFAULT 0;", []).unwrap();
    }
}

// maybe we will use this later
/*
pub fn downgrade_account_cards(user: &JsonValue) -> JsonValue {
    let mut rv = user.clone();

    let mut cards = array![];
    let mut ids = array![];
    for data in user["card_list"].members() {
        let id = data["master_card_id"].as_i64().unwrap_or(0);
        let downgraded = guest::proxy_card_id(id);
        // Whole characters share one downgrade, and the client can't hold the
        // same card twice
        if ids.contains(downgraded) {
            continue;
        }
        ids.push(downgraded).unwrap();
        let mut data = data.clone();
        if downgraded != id {
            data["id"] = downgraded.into();
            data["master_card_id"] = downgraded.into();
        }
        cards.push(data).unwrap();
    }
    rv["card_list"] = cards;

    for deck in rv["deck_list"].members_mut() {
        let mut used = array![];
        for slot in deck["main_card_ids"].members_mut() {
            let id = guest::proxy_card_id(slot.as_i64().unwrap_or(0));
            // Cards the downgrade merged away leave the slot empty
            if id == 0 || used.contains(id) {
                *slot = (0).into();
                continue;
            }
            used.push(id).unwrap();
            *slot = id.into();
        }
    }

    for key in ["favorite_master_card_id", "guest_smile_master_card_id", "guest_cool_master_card_id", "guest_pure_master_card_id"] {
        let id = rv["user"][key].as_i64().unwrap_or(0);
        rv["user"][key] = guest::proxy_card_id(id).into();
    }

    rv
}
*/

fn acc_exists(uid: i64) -> bool {
    DATABASE.lock_and_select("SELECT user_id FROM userdata WHERE user_id=?1", params!(uid)).is_ok()
}
fn get_key(auth_key: &str) -> i64 {
    let uid = get_uid(auth_key);
    let key = if uid == 0 {
        generate_uid()
    } else {
        uid
    };
    
    if !acc_exists(key) {
        create_acc(key, auth_key);
    }
    
    key
}

fn generate_uid() -> i64 {
    let mut rng = rand::rng();
    let random_number = rng.random_range(100_000_000_000_000..=999_999_999_999_999);
    //the chances of this...?
    if acc_exists(random_number) {
        return generate_uid();
    }
    
    random_number
}

fn add_user_to_database(uid: i64, user: JsonValue, user_home: JsonValue, user_missions: JsonValue, sif_cards: JsonValue) {
    let home = jzon::stringify(user_home.clone());
    let missions = jzon::stringify(user_missions.clone());
    let cards = jzon::stringify(sif_cards.clone());
    
    DATABASE.lock_and_exec("INSERT INTO userdata (user_id, userdata, friend_request_disabled, protocol_version) VALUES (?1, ?2, ?3, ?4)", params!(
        uid,
        jzon::stringify(user.clone()),
        user["user"]["friend_request_disabled"].as_i32().unwrap(),
        if card::account_has_custom_cards(&user) { card::PROTOCOL_VERSION } else { 0 }
    ));
    DATABASE.lock_and_exec("INSERT INTO userhome (user_id, userhome) VALUES (?1, ?2)", params!(
        uid,
        if user_home.is_empty() {include_file!("src/router/userdata/new_user_home.json")} else {home}
    ));
    DATABASE.lock_and_exec("INSERT INTO missions (user_id, missions) VALUES (?1, ?2)", params!(
        uid,
        if user_missions.is_empty() {include_file!("src/router/userdata/missions.json")} else {missions}
    ));
    DATABASE.lock_and_exec("INSERT INTO loginbonus (user_id, loginbonus) VALUES (?1, ?2)", params!(
        uid,
        format!(r#"{{"last_rewarded": 0, "bonus_list": [], "start_time": {}}}"#, global::timestamp())
    ));
    DATABASE.lock_and_exec("INSERT INTO sifcards (user_id, sifcards) VALUES (?1, ?2)", params!(
        uid,
        if sif_cards.is_empty() {"[]"} else {&cards}
    ));
    DATABASE.lock_and_exec("INSERT INTO friends (user_id, friends) VALUES (?1, ?2)", params!(
        uid,
        r#"{"friend_user_id_list":[],"request_user_id_list":[],"pending_user_id_list":[]}"#
    ));
    DATABASE.lock_and_exec("INSERT INTO event (user_id, event) VALUES (?1, ?2)", params!(
        uid,
        "{}"
    ));
    DATABASE.lock_and_exec("INSERT INTO eventloginbonus (user_id, eventloginbonus) VALUES (?1, ?2)", params!(
        uid,
        format!(r#"{{"last_rewarded": 0, "bonus_list": [], "start_time": {}}}"#, global::timestamp())
    ));
    DATABASE.lock_and_exec("INSERT INTO server_data (user_id, server_data) VALUES (?1, ?2)", params!(
        uid,
        format!(r#"{{"server_time_set":{},"server_time":1709272800}}"#, global::timestamp())
    ));
    DATABASE.lock_and_exec("INSERT INTO chats (user_id, chats) VALUES (?1, ?2)", params!(
        uid,
        "[]"
    ));
    DATABASE.lock_and_exec("INSERT INTO exchange (user_id, exchange) VALUES (?1, ?2)", params!(
        uid,
        "[]"
    ));
}

fn create_acc(uid: i64, login: &str) {
    let mut new_user = NEW_USER.clone();
    new_user["user"]["id"] = uid.into();
    new_user["stamina"]["last_updated_time"] = global::timestamp().into();
    
    add_user_to_database(uid, new_user, JsonValue::Null, JsonValue::Null, JsonValue::Null);
    
    DATABASE.lock_and_exec("DELETE FROM tokens WHERE token=?1", params!(login));
    DATABASE.lock_and_exec("INSERT INTO tokens (user_id, token) VALUES (?1, ?2)", params!(uid, login));
}

fn get_uid(token: &str) -> i64 {
    let data = DATABASE.lock_and_select("SELECT user_id FROM tokens WHERE token = ?1;", params!(token));
    if data.is_err() {
        return 0;
    }
    let data = data.unwrap();
    data.parse::<i64>().unwrap_or(0)
}

// Needed by gree
pub fn get_login_token(uid: i64) -> String {
    let data = DATABASE.lock_and_select("SELECT token FROM tokens WHERE user_id=?1", params!(uid));
    if data.is_err() {
        return String::new();
    }
    data.unwrap()
}

fn cleanup_account(user: &mut JsonValue) {
    user["gem"]["total"] = (user["gem"]["charge"].as_i64().unwrap() + user["gem"]["free"].as_i64().unwrap()).into();
    if user["master_music_ids"].len() != NEW_USER["master_music_ids"].len() {
        user["master_music_ids"] = NEW_USER["master_music_ids"].clone();
    }
    
    let mut to_remove = array![];
    let items = user["item_list"].clone();
    for (i, data) in user["item_list"].members_mut().enumerate() {
        if to_remove.contains(i) {
            continue;
        }
        if data["master_item_id"].as_i64().unwrap() != data["id"].as_i64().unwrap() {
            data["id"] = data["master_item_id"].clone();
        }
        for (j, data2) in items.members().enumerate() {
            if i == j {
                continue;
            }
            if data["master_item_id"].as_i64().unwrap() == data2["master_item_id"].as_i64().unwrap() {
                to_remove.push(j).unwrap();
                data["amount"] = (data["amount"].as_i64().unwrap() + data2["amount"].as_i64().unwrap()).into();
            }
        }
    }
    for (i, data) in to_remove.members().enumerate() {
        user["item_list"].array_remove(data.as_usize().unwrap() - i);
    }
}

fn get_data(auth_key: &str, row: &str) -> JsonValue {
    let key = get_key(auth_key);
    
    let result = DATABASE.lock_and_select(&format!("SELECT {} FROM {} WHERE user_id=?1", row, row), params!(key));
    
    jzon::parse(&result.unwrap()).unwrap()
}

// Deleted custom songs leave stale score/clear records behind. They're wiped
// lazily when the userdata is pulled: collect the user's own music-id-keyed
// rows in the custom range (official ids are never candidates) and drop the
// ones whose id no longer exists in the catalog. Custom ids are never reused,
// so the wipe is final. A song that still exists but isn't visible to this
// user is NOT wiped - existence is what's checked, not visibility
fn remove_deleted_custom_songs(user: &mut JsonValue) -> bool {
    // Feature off: never touch custom_songs.db, leave userdata untouched
    if crate::router::custom_song::disabled() {
        return false;
    }
    let mut candidates = array![];
    for key in ["live_list", "live_mission_list"] {
        for data in user[key].members() {
            let id = data["master_live_id"].as_i64().unwrap_or(0);
            if id >= custom_song::FIRST_MUSIC_ID && id <= custom_song::LAST_MUSIC_ID && !candidates.contains(id) {
                candidates.push(id).unwrap();
            }
        }
    }
    if candidates.is_empty() {
        return false;
    }
    let dead = custom_song::dead_music_ids(&candidates);
    if dead.is_empty() {
        return false;
    }
    for key in ["live_list", "live_mission_list"] {
        let mut i = 0;
        while i < user[key].len() {
            if dead.contains(user[key][i]["master_live_id"].as_i64().unwrap_or(0)) {
                user[key].array_remove(i);
            } else {
                i += 1;
            }
        }
    }
    true
}

pub fn get_acc(auth_key: &str) -> JsonValue {
    let mut user = get_data(auth_key, "userdata");
    cleanup_account(&mut user);
    let mut changed = remove_deleted_custom_songs(&mut user);

    if items::lp_modification(&mut user, 0, false) {
        changed = true;
    }
    if changed {
        save_data(auth_key, "userdata", user.clone());
    }
    user
}

pub fn get_acc_home(auth_key: &str) -> JsonValue {
    let mut user = get_data(auth_key, "userhome");
    user["home"]["pending_friend_count"] = get_acc_friends(auth_key)["pending_user_id_list"].len().into();
    
    user
}
pub fn get_acc_missions(auth_key: &str) -> JsonValue {
    get_data(auth_key, "missions")
}
pub fn get_acc_loginbonus(auth_key: &str) -> JsonValue {
    get_data(auth_key, "loginbonus")
}
pub fn get_acc_sif(auth_key: &str) -> JsonValue {
    get_data(auth_key, "sifcards")
}
pub fn get_acc_friends(auth_key: &str) -> JsonValue {
    get_data(auth_key, "friends")
}
pub fn get_server_data(auth_key: &str) -> JsonValue {
    get_data(auth_key, "server_data")
}
pub fn get_acc_chats(auth_key: &str) -> JsonValue {
    get_data(auth_key, "chats")
}
pub fn get_acc_exchange(auth_key: &str) -> JsonValue {
    get_data(auth_key, "exchange")
}
pub fn get_acc_event(auth_key: &str) -> JsonValue {
    let event = get_data(auth_key, "event");
    if event.is_empty() {
        return object!{};
    }
    event
}
pub fn get_acc_eventlogin(auth_key: &str) -> JsonValue {
    get_data(auth_key, "eventloginbonus")
}
pub fn get_protocol_version(auth_key: &str) -> u32 {
    DATABASE.lock_and_select("SELECT protocol_version FROM userdata WHERE user_id=?1", params!(get_key(auth_key))).unwrap_or_default().parse::<u32>().unwrap_or(0)
}

pub fn save_data(auth_key: &str, row: &str, data: JsonValue) {
    let key = get_key(auth_key);
    
    DATABASE.lock_and_exec(&format!("UPDATE {} SET {}=?1 WHERE user_id=?2", row, row), params!(jzon::stringify(data), key));
}

pub fn save_acc(auth_key: &str, data: JsonValue) {
    DATABASE.lock_and_exec("UPDATE userdata SET friend_request_disabled=?1 WHERE user_id=?2", params!(data["user"]["friend_request_disabled"].as_i32().unwrap(), get_key(auth_key)));
    save_data(auth_key, "userdata", data);
}
pub fn save_acc_home(auth_key: &str, data: JsonValue) {
    save_data(auth_key, "userhome", data);
}
pub fn save_acc_missions(auth_key: &str, data: JsonValue) {
    save_data(auth_key, "missions", data);
}
pub fn save_acc_loginbonus(auth_key: &str, data: JsonValue) {
    save_data(auth_key, "loginbonus", data);
}
pub fn save_acc_friends(auth_key: &str, data: JsonValue) {
    save_data(auth_key, "friends", data);
}
pub fn save_acc_event(auth_key: &str, data: JsonValue) {
    save_data(auth_key, "event", data);
}
pub fn save_acc_eventlogin(auth_key: &str, data: JsonValue) {
    save_data(auth_key, "eventloginbonus", data);
}
pub fn save_server_data(auth_key: &str, data: JsonValue) {
    save_data(auth_key, "server_data", data);
}
pub fn save_acc_chats(auth_key: &str, data: JsonValue) {
    save_data(auth_key, "chats", data);
}
pub fn save_acc_exchange(auth_key: &str, data: JsonValue) {
    save_data(auth_key, "exchange", data);
}

pub fn save_protocol_version(auth_key: &str, version: u32) {
    DATABASE.lock_and_exec("UPDATE userdata SET protocol_version=?1 WHERE user_id=?2 AND protocol_version<?1", params!(version as i64, get_key(auth_key)));
}
pub fn save_acc_sif(auth_key: &str, data: JsonValue) {
    save_data(auth_key, "sifcards", data);
}

pub fn get_name_and_rank(uid: i64) -> JsonValue {
    let login_token = get_login_token(uid);
    if login_token == String::new() {
        return object!{
            user_name: "",
            user_rank: 1
        }
    }
    let uid = get_uid(&login_token);
    if uid == 0 || !acc_exists(uid) {
        return object!{
            user_name: "",
            user_rank: 1
        }
    }
    let result = DATABASE.lock_and_select("SELECT userdata FROM userdata WHERE user_id=?1", params!(uid));
    let data = jzon::parse(&result.unwrap()).unwrap();
    
    object!{
        user_name: data["user"]["name"].clone(),
        user_rank: items::get_user_rank_data(data["user"]["exp"].as_i64().unwrap())["rank"].clone() //todo
    }
}

pub fn get_acc_from_uid(uid: i64) -> JsonValue {
    let login_token = get_login_token(uid);
    if login_token == String::new() {
        return object!{
            error: true
        }
    }
    let uid = get_uid(&login_token);
    if uid == 0 || !acc_exists(uid) {
        return object!{"error": true}
    }
    let result = DATABASE.lock_and_select("SELECT userdata FROM userdata WHERE user_id=?1", params!(uid));
    jzon::parse(&result.unwrap()).unwrap()
}

pub fn friend_request(uid: i64, requestor: i64) {
    let login_token = get_login_token(uid);
    if login_token == String::new() {
        return;
    }
    let uid = get_uid(&login_token);
    let friends = DATABASE.lock_and_select("SELECT friends FROM friends WHERE user_id=?1", params!(uid));
    let mut friends = jzon::parse(&friends.unwrap()).unwrap();
    if !friends["pending_user_id_list"].contains(requestor) && friends["pending_user_id_list"].len() < crate::router::friend::FRIEND_LIMIT {
        friends["pending_user_id_list"].push(requestor).unwrap();
        DATABASE.lock_and_exec("UPDATE friends SET friends=?1 WHERE user_id=?2", params!(jzon::stringify(friends), uid));
    }
}

pub fn friend_request_approve(uid: i64, requestor: i64, accepted: bool, key: &str) {
    let login_token = get_login_token(uid);
    if login_token == String::new() {
        return;
    }
    let uid = get_uid(&login_token);
    let friends = DATABASE.lock_and_select("SELECT friends FROM friends WHERE user_id=?1", params!(uid));
    let mut friends = jzon::parse(&friends.unwrap()).unwrap();
    let index = friends[key].members().position(|r| *r.to_string() == requestor.to_string());
    if index.is_some() {
        friends[key].array_remove(index.unwrap());
    }
    let index = friends["request_user_id_list"].members().position(|r| *r.to_string() == requestor.to_string());
    if index.is_some() {
        friends["request_user_id_list"].array_remove(index.unwrap());
    }
    if accepted && !friends["friend_user_id_list"].contains(requestor) && friends["friend_user_id_list"].len() < crate::router::friend::FRIEND_LIMIT {
        friends["friend_user_id_list"].push(requestor).unwrap();
    }
    DATABASE.lock_and_exec("UPDATE friends SET friends=?1 WHERE user_id=?2", params!(jzon::stringify(friends), uid));
}

pub fn friend_request_disabled(uid: i64) -> bool {
    let login_token = get_login_token(uid);
    if login_token == String::new() {
        return true;
    }
    let uid = get_uid(&login_token);
    let user = DATABASE.lock_and_select("SELECT userdata FROM userdata WHERE user_id=?1", params!(uid));
    let user = jzon::parse(&user.unwrap()).unwrap();
    user["user"]["friend_request_disabled"] == 1
}

pub fn friend_remove(uid: i64, requestor: i64) {
    let login_token = get_login_token(uid);
    if login_token == String::new() {
        return;
    }
    let uid = get_uid(&login_token);
    let friends = DATABASE.lock_and_select("SELECT friends FROM friends WHERE user_id=?1", params!(uid));
    let mut friends = jzon::parse(&friends.unwrap()).unwrap();
    let index = friends["friend_user_id_list"].members().position(|r| *r.to_string() == requestor.to_string());
    if index.is_some() {
        friends["friend_user_id_list"].array_remove(index.unwrap());
    }
    DATABASE.lock_and_exec("UPDATE friends SET friends=?1 WHERE user_id=?2", params!(jzon::stringify(friends), uid));
}

pub fn get_random_uids(count: i32) -> JsonValue {
    if count <= 0 {
        return array![];
    }
    DATABASE.lock_and_select_all(&format!("SELECT user_id FROM userdata WHERE friend_request_disabled=?1 ORDER BY RANDOM() LIMIT {}", count), params!(0)).unwrap()
}

fn create_webui_token() -> String {
    let token = global::create_token();
    if DATABASE.lock_and_select("SELECT user_id FROM webui WHERE token=?1", params!(token)).is_ok() {
        return create_webui_token();
    }
    token
}

pub fn webui_login(uid: i64, password: &str) -> Result<String, String> {
    let pass = DATABASE.lock_and_select("SELECT password FROM migration WHERE user_id=?1", params!(uid)).unwrap_or_default();
    if !user::migration::verify_password(password, &pass) {
        if acc_exists(uid) && pass.is_empty() {
            return Err(String::from("Migration token not set. Set token in game settings."));
        }
        return Err(String::from("User/password don't match"));
    }
    
    let new_token = create_webui_token();
    
    DATABASE.lock_and_exec("DELETE FROM webui WHERE user_id=?1", params!(uid));
    // This could overflow given enough time... though rusqlite doesnt currently support ToSql on a u64...... maybe someday
    DATABASE.lock_and_exec("INSERT INTO webui (user_id, token, last_login) VALUES (?1, ?2, ?3)", params!(uid, new_token, global::timestamp() as i64));
    Ok(new_token)
}

pub fn webui_import_user(user: JsonValue) -> Result<JsonValue, String> {
    let uid = user["userdata"]["user"]["id"].as_i64().unwrap();
    if acc_exists(uid) {
        return Err(String::from("User already exists"));
    }
    
    add_user_to_database(uid, user["userdata"].clone(), user["home"].clone(), user["missions"].clone(), user["sif_cards"].clone());
    
    let token = global::create_token();
    
    DATABASE.lock_and_exec("INSERT INTO tokens (user_id, token) VALUES (?1, ?2)", params!(uid, token));
    
    let token = user::migration::save_acc_transfer(uid, &user["password"].to_string());
    
    Ok(object!{
        uid: uid,
        migration_token: token
    })
}

pub fn webui_login_token(token: &str) -> Option<String> {
    let uid = DATABASE.lock_and_select("SELECT user_id FROM webui WHERE token=?1", params!(token)).unwrap_or_default();
    if uid == String::new() || token.is_empty() {
        return None;
    }
    let uid = uid.parse::<i64>().unwrap_or(0);
    if uid == 0 {
        return None;
    }
    let last_login = DATABASE.lock_and_select("SELECT last_login FROM webui WHERE user_id=?1", params!(uid)).unwrap_or_default().parse::<i64>().unwrap_or(0);
    let limit = 24 * 60 * 60; //1 day
    //Expired token
    if (global::timestamp() as i64) > last_login + limit {
        DATABASE.lock_and_exec("DELETE FROM webui WHERE user_id=?1", params!(uid));
        return None;
    }
    let login_token = DATABASE.lock_and_select("SELECT token FROM tokens WHERE user_id=?1", params!(uid)).unwrap_or_default();
    if login_token == String::new() {
        return None;
    }
    Some(login_token)
}

pub fn webui_get_user(token: &str) -> Option<JsonValue> {
    let login_token = webui_login_token(token)?;
    
    Some(object!{
        userdata: get_acc(&login_token),
        loginbonus: get_acc_loginbonus(&login_token),
        time: get_server_data(&login_token)["server_time"].clone()
    })
}

pub fn webui_start_loginbonus(bonus_id: i64, token: &str) -> JsonValue {
    let login_token = webui_login_token(token);
    if login_token.is_none() {
        return object!{
            result: "ERR",
            message: "Failed to validate token"
        };
    }
    let login_token = login_token.unwrap();
    let mut bonuses = get_acc_loginbonus(&login_token);
    if !global::start_login_bonus(bonus_id, &mut bonuses) {
        return object!{
            result: "ERR",
            message: "Login bonus ID is either already going or does not exist"
        };
    }
    save_acc_loginbonus(&login_token, bonuses);
    
    object!{
        result: "OK",
        id: bonus_id
    }
}

pub fn set_server_time(time: i64, token: &str) -> JsonValue {
    if time as u64 > global::timestamp() {
        return object!{
            result: "ERR",
            message: "Timestamp is in the future"
        };
    }
    let login_token = webui_login_token(token);
    if login_token.is_none() {
        return object!{
            result: "ERR",
            message: "Failed to validate token"
        };
    }
    let login_token = login_token.unwrap();
    let mut server_data = get_server_data(&login_token);
    server_data["server_time_set"] = global::timestamp().into();
    server_data["server_time"] = time.into();
    save_server_data(&login_token, server_data);
    
    object!{
        result: "OK"
    }
}

pub fn webui_logout(token: &str) {
    DATABASE.lock_and_exec("DELETE FROM webui WHERE token=?1", params!(token));
}

pub fn export_user(token: &str) -> Option<JsonValue> {
    let login_token = webui_login_token(token)?;

    Some(object!{
         userdata: jzon::stringify(get_acc(&login_token)),
         userhome: jzon::stringify(get_acc_home(&login_token)),
         missions: jzon::stringify(get_acc_missions(&login_token)),
         sifcards: jzon::stringify(get_acc_sif(&login_token))
    })
}

pub fn purge_accounts() -> usize {
    // If the user has no cards, its safe to assume its a dead account (imo). In the (rare) event this function is ran after a user started and before the account has characters, the server should create them a new account, and let them start the tutorial over.
    let dead_uids = DATABASE.lock_and_select_all("
    SELECT user_id
    FROM userdata
    WHERE (userdata LIKE ?1 AND userdata LIKE ?2 AND friend_request_disabled=1)
    OR (userdata LIKE ?3 AND friend_request_disabled=1)",
    params!(
        "%\"card_list\":[]%",
        "%Tutorial in progress%",
        "%tutorial_step\":60%" //For some reason, a majority of dead accounts in the tutorial are here....
    )).unwrap();
    for uid in dead_uids.members() {
        let user_id = uid.as_i64().unwrap();
        println!("Removing dead UID: {}", user_id);
        crate::database::gree::delete_uuid(user_id);
        DATABASE.lock_and_exec("DELETE FROM userdata WHERE user_id=?1", params!(user_id));
        DATABASE.lock_and_exec("DELETE FROM userhome WHERE user_id=?1", params!(user_id));
        DATABASE.lock_and_exec("DELETE FROM missions WHERE user_id=?1", params!(user_id));
        DATABASE.lock_and_exec("DELETE FROM loginbonus WHERE user_id=?1", params!(user_id));
        DATABASE.lock_and_exec("DELETE FROM sifcards WHERE user_id=?1", params!(user_id));
        DATABASE.lock_and_exec("DELETE FROM friends WHERE user_id=?1", params!(user_id));
        DATABASE.lock_and_exec("DELETE FROM chats WHERE user_id=?1", params!(user_id));
        DATABASE.lock_and_exec("DELETE FROM exchange WHERE user_id=?1", params!(user_id));
        DATABASE.lock_and_exec("DELETE FROM event WHERE user_id=?1", params!(user_id));
        DATABASE.lock_and_exec("DELETE FROM eventloginbonus WHERE user_id=?1", params!(user_id));
        DATABASE.lock_and_exec("DELETE FROM server_data WHERE user_id=?1", params!(user_id));
        DATABASE.lock_and_exec("DELETE FROM webui WHERE user_id=?1", params!(user_id));
        DATABASE.lock_and_exec("DELETE FROM tokens WHERE user_id=?1", params!(user_id));
        DATABASE.lock_and_exec("DELETE FROM migration WHERE user_id=?1", params!(user_id));
    }
    DATABASE.lock_and_exec("VACUUM", params!());
    crate::database::gree::setup();
    dead_uids.len()
}

#[cfg(test)]
mod tests {
    use super::*;

    // User plays a custom song -> the song is deleted -> the next userdata
    // pull serves data without the dead scores and the stored rows are gone
    #[test]
    fn deleted_custom_song_records_are_wiped_on_pull() {
        let _lock = crate::runtime::lock_test_data_path();

        let token = "userdata-test-token";
        let mut user = get_acc(token);

        let deleted_id = custom_song::next_music_id();
        custom_song::insert_song(deleted_id, 1, &object!{music_id: deleted_id}, "public", &array![], false);
        // Exists but isn't visible to this user - must survive the wipe
        let private_id = custom_song::next_music_id();
        custom_song::insert_song(private_id, 1, &object!{music_id: private_id}, "private", &array![], false);

        // 1100101 is a real stock live-id shape (7-digit, >= FIRST_MUSIC_ID): it
        // must survive the custom-song wipe, unlike an unrealistic sub-10000 id
        let stock_id = 1100101;
        for id in [stock_id, deleted_id, private_id] {
            user["live_list"].push(object!{
                master_live_id: id,
                level: 4,
                clear_count: 1,
                high_score: 123456,
                max_combo: 100
            }).unwrap();
            user["live_mission_list"].push(object!{
                master_live_id: id,
                clear_master_live_mission_ids: [1, 24]
            }).unwrap();
        }
        save_acc(token, user);

        // Both custom songs still exist: nothing gets wiped
        let user = get_acc(token);
        assert_eq!(user["live_list"].len(), 3);
        assert_eq!(user["live_mission_list"].len(), 3);

        custom_song::delete_song(deleted_id);

        // The next pull drops the dead id's records and only those
        let user = get_acc(token);
        assert!(!user["live_list"].members().any(|data| data["master_live_id"] == deleted_id));
        assert!(!user["live_mission_list"].members().any(|data| data["master_live_id"] == deleted_id));
        // Official records are untouchable, invisible-but-alive songs survive
        assert!(user["live_list"].members().any(|data| data["master_live_id"] == stock_id));
        assert!(user["live_list"].members().any(|data| data["master_live_id"] == private_id));
        assert_eq!(user["live_list"].len(), 2);
        assert_eq!(user["live_mission_list"].len(), 2);

        // The wipe persisted to the database, not just the served copy
        let stored = get_data(token, "userdata");
        assert!(!stored["live_list"].members().any(|data| data["master_live_id"] == deleted_id));
        assert!(!stored["live_mission_list"].members().any(|data| data["master_live_id"] == deleted_id));
    }
}