use rocket::form::Form;
use rocket::http::Status;
use rocket::response::status;

use base64::{Engine as _, engine::general_purpose};

use sqlx::Type;
use sqlx::{Encode, Sqlite, query_builder::QueryBuilder, Execute};

use crate::helpers;
use crate::db;

#[derive(Debug, sqlx::FromRow)]
struct DynQuery {
    id: i64,
    name: String,
    user_id: i64,
    description: String,
    original: Option<i32>,
    game_version: i32,
    requested_stars: Option<i32>,
    version: i32,
    song_id: i32,
    length: i32,
    objects: i32,
    coins: i32,
    has_ldm: i32,
    two_player: i32,
    downloads: i32,
    likes: i32,
    difficulty: Option<i64>,
    community_difficulty: Option<i64>,
    demon_difficulty: Option<i64>,
    stars: Option<i32>,
    featured: i32,
    epic: i32,
    rated_coins: i32,
    user_username: String,
    user_udid: Option<String>,
    user_account_id: Option<i64>,
    user_registered: i32,
    editor_time: i32,
    editor_time_copies: i32
}

#[derive(FromForm)]
pub struct FormGetLevels {
    page: Option<i64>,
    str: Option<String>,

    accountID: Option<i64>,
    gjp: Option<String>,
    gjp2: Option<String>,
    password: Option<String>,
    
    // we have to escape here
    r#type: Option<i32>,
    featured: Option<i32>,
    original: Option<i32>,
    coins: Option<i32>,
    epic: Option<i32>,
    uncompleted: Option<i32>,
    onlyCompleted: Option<i32>,
    completedLevels: Option<String>,
    song: Option<i32>,
    customSong: Option<i32>,
    twoPlayer: Option<i32>,
    star: Option<i32>,
    noStar: Option<i32>,
    gauntlet: Option<i32>,
    len: Option<i32>,
    diff: Option<String>,
    demonFilter: Option<i32>,
    local: Option<i32>
}

#[post("/getGJLevels20.php", data = "<input>")]
pub async fn get_levels(input: Form<FormGetLevels>) -> status::Custom<&'static str> {
    let mut connection = db::establish_sqlite_conn().await;

    let mut can_see_unlisted = false;

    // WHERE [...]
    let mut query_params: Vec<&str> = vec![];
    // Use this for binding on `query_params`
    let mut query_params_bind: Vec<Box<dyn ToString + Send>> = vec![];
    // ORDER BY [...]
    let mut order = "levels.created_at DESC";

    let page_offset = input.page.unwrap_or(0) * 10;

    let search_query = input.str.clone().unwrap_or("".to_string());

    if !search_query.is_empty() && input.r#type != Some(5) && input.r#type != Some(10) && input.r#type != Some(19) {
        match search_query.parse::<i64>() {
            Ok(id) => {
                can_see_unlisted = true;
                query_params.push("levels.id = ?");
                query_params_bind.push(Box::new(id))
            },
            Err(_) => {
                query_params.push("levels.name LIKE ?");
                query_params_bind.push(Box::new(search_query.clone() + "%"));
            }
        }
    }

    if let Some(1) = input.featured {
        query_params.push("featured = 1");
    }
    if let Some(1) = input.original {
        query_params.push("original IS NULL");
    }
    if let Some(1) = input.coins {
        query_params.push("rated_coins = 1 AND levels.coins != 0");
    }
    if let Some(1) = input.epic {
        query_params.push("epic = 1");
    }
    if let Some(1) = input.uncompleted {
        match input.completedLevels.clone() {
            Some(completed_levels) => {
                let clean_levels: Vec<i64> = completed_levels[1..completed_levels.len() - 1].split(',')
                    .map(|s| s.parse::<i64>().expect("failed to parse i64"))
                    .collect();
                let levels_str = clean_levels.iter().map(|n| n.to_string()).collect::<Vec<String>>().join(", ");
                query_params.push("levels.id NOT IN (?)");
                query_params_bind.push(Box::new(levels_str));
            },
            None => return status::Custom(Status::Ok, "-1")
        }
    }
    if let Some(1) = input.onlyCompleted {
        match input.completedLevels.clone() {
            Some(completed_levels) => {
                let clean_levels: Vec<i64> = completed_levels[1..completed_levels.len() - 1].split(',')
                    .map(|s| s.parse::<i64>().expect("failed to parse i64"))
                    .collect();
                let levels_str = clean_levels.iter().map(|n| n.to_string()).collect::<Vec<String>>().join(", ");
                query_params.push("levels.id IN (?)");
                query_params_bind.push(Box::new(levels_str));
            },
            None => return status::Custom(Status::Ok, "-1")
        }
    }
    if let Some(song_id) = input.song {
        if let Some(custom_song) = input.customSong {
            query_params.push("song_id = ?");
            query_params_bind.push(Box::new(custom_song));
        } else {
            query_params.push("song_id = ?");
            query_params_bind.push(Box::new(song_id));
        }
    }
    if let Some(1) = input.twoPlayer {
        query_params.push("two_player = 1");
    }
    if let Some(1) = input.star {
        query_params.push("levels.stars IS NOT NULL");
    }
    if let Some(1) = input.noStar {
        query_params.push("levels.stars IS NULL");
    }
    if let Some(_gauntlet_id) = input.gauntlet {
        unimplemented!("no gauntlet support")
    }
    if let Some(len) = input.len {
        query_params.push("levels.length = ?");
        query_params_bind.push(Box::new(len));
    }
    if let Some(diff) = input.diff.clone() {
        if diff != "-" {
            match diff.as_str() {
                "-1" => {
                    query_params.push("difficulty IS NULL AND community_difficulty IS NULL"); // NA
                },
                "-2" => match input.demonFilter {
                    Some(demon_filter) => {
                        match demon_filter {
                            1 => {
                                query_params.push("demon_difficulty = ?");
                                query_params_bind.push(Box::new(helpers::difficulty::DemonDifficulty::Easy.to_demon_difficulty()));
                            },
                            2 => {
                                query_params.push("demon_difficulty = ?");
                                query_params_bind.push(Box::new(helpers::difficulty::DemonDifficulty::Medium.to_demon_difficulty()));
                            },
                            3 => {
                                query_params.push("demon_difficulty = ?");
                                query_params_bind.push(Box::new(helpers::difficulty::DemonDifficulty::Hard.to_demon_difficulty()));
                            },
                            4 => {
                                query_params.push("demon_difficulty = ?");
                                query_params_bind.push(Box::new(helpers::difficulty::DemonDifficulty::Insane.to_demon_difficulty()));
                            },
                            5 => {
                                query_params.push("demon_difficulty = ?");
                                query_params_bind.push(Box::new(helpers::difficulty::DemonDifficulty::Extreme.to_demon_difficulty()));
                            },
                            _ => panic!("invalid demon filter!")
                        }
                        query_params.push("difficulty = ? OR (difficulty IS NULL AND community_difficulty = ?)");
                        query_params_bind.push(Box::new(helpers::difficulty::LevelDifficulty::Demon.to_star_difficulty()));
                        query_params_bind.push(Box::new(helpers::difficulty::LevelDifficulty::Demon.to_star_difficulty()));
                    },
                    None => panic!("demon filter option with no demon filter argument")
                },
                "-3" => {
                    query_params.push("difficulty = ? OR (difficulty IS NULL AND community_difficulty = ?)");
                    query_params_bind.push(Box::new(helpers::difficulty::LevelDifficulty::Auto.to_star_difficulty()));
                    query_params_bind.push(Box::new(helpers::difficulty::LevelDifficulty::Auto.to_star_difficulty()));
                },
                // easy, normal, hard, harder, insane 
                _ => {
                    let clean_diffs: Vec<i32> = diff.split(',')
                        .map(|v| v.parse::<i32>().expect("couldnt parse i32"))
                        .collect();
                    let diffs_str = clean_diffs.iter().map(|n| n.to_string()).collect::<Vec<String>>().join(", ");
                    query_params.push("difficulty IN (?) OR (difficulty IS NULL AND community_difficulty IN (?))");
                    query_params_bind.push(Box::new(diffs_str.clone()));
                    query_params_bind.push(Box::new(diffs_str));
                }
            }
        }
    }

    if let Some(search_type) = input.r#type {
        match search_type {
            // downloads
            1 => {
                order = "levels.downloads DESC";
            },
            // likes
            2 => {
                order = "levels.likes DESC";
            },
            // trending
            3 => {
                unimplemented!("no trending sort :(");
            },
            // recent
            4 => {
                unimplemented!("no recent sort :(")
                // count query order doesnt matter
            }
            // creator levels
            5 => {
                if let Some(1) = input.local {
                    if let Some(input_account_id) = input.accountID {
                        let (user_id_val, _account_id_val): (i64, i64);
                        
                        match helpers::accounts::auth(input_account_id, input.password.clone(), input.gjp.clone(), input.gjp2.clone()).await {
                            Ok((user_id_val_auth, account_id_val_auth)) => {
                                user_id_val = user_id_val_auth;
                                _account_id_val = account_id_val_auth;
                            },
                            Err(_) => return status::Custom(Status::Ok, "-1")
                        };

                        if user_id_val == search_query.parse::<i64>().expect("couldnt convert query input to i64") {
                            can_see_unlisted = true;
                            query_params.push("levels.user_id = ?");
                            query_params_bind.push(Box::new(user_id_val));
                        } else {
                            return status::Custom(Status::Ok, "-1")
                        }
                    }
                }
                if let None = input.local {
                    let user_id_val = search_query.parse::<i64>().expect("couldnt convert query input to i64");

                    query_params.push("levels.user_id = ?");
                    query_params_bind.push(Box::new(user_id_val));
                }
            }
            // featured
            // 17 is gdworld
            6 | 17 => {
                query_params.push("featured = 1");
            },
            // epic / HoF
            16 => {
                query_params.push("epic = 1");
            },
            // magic
            7 => {
                query_params.push("objects > 4000");
            },
            // map packs 🙄😶
            10 | 19 => {
                unimplemented!("no map packs yet buddy")
            },
            // rated
            11 => {
                query_params.push("levels.stars IS NOT NULL");
            },
            // followed
            12 => {
                unimplemented!("no followed yet (i actually *could* implement this, but you cant follow yet so its useless)")
            },
            // friends
            13 => {
                unimplemented!("no friends")
            },
            // daily
            21 => {
                unimplemented!("no daily")
            },
            // weekly
            22 => {
                unimplemented!("no weekly")
            },
            // event (honestly idk what this is i think it got leaked from 2.2 or something)
            23 => {
                unimplemented!("no event")
            },
            // default sort
            // 15 is gdworld
            0 | 15 | _ => {
                order = "likes DESC";
            },
        }
    }

    if !can_see_unlisted {
        query_params.push("unlisted = 0");
    }

    let where_str = format!("WHERE ({})", query_params.join(" AND "));
    let query_base = format!("FROM levels JOIN users ON levels.user_id = users.id {} ORDER BY {}", where_str, order);

    let mut query_builder: QueryBuilder<Sqlite> = QueryBuilder::new(&format!("SELECT levels.id, levels.name, users.id as user_id, levels.description, levels.original, levels.game_version, levels.requested_stars, levels.version, levels.song_id, levels.length, levels.objects, levels.coins, levels.has_ldm, levels.two_player, levels.downloads, levels.likes, levels.difficulty, levels.community_difficulty, levels.demon_difficulty, levels.stars, levels.featured, levels.epic, levels.rated_coins, users.username as user_username, users.udid as user_udid, users.account_id as user_account_id, users.registered as user_registered, editor_time, editor_time_copies {}", query_base));
    let mut query = query_builder.build_query_as::<DynQuery>();

    for param in query_params_bind {
        query = query.bind(param.to_string());
    }

    let mut results: Vec<String> = vec![];
    let mut users: Vec<String> = vec![];
    let mut songs: Vec<String> = vec![];

    let mut hash_data: Vec<(i64, i32, bool)> = vec![];

    let count: i64 = sqlx::query_scalar(&format!("SELECT COUNT(*) {}", query_base))
        .fetch_one(&mut connection)
        .await
        .expect("error getting level count");

    // for goop in {
    //     query
    //         .fetch_all(&mut connection)
    //         .await
    //         .expect("error loading levels")
    // } {
    //     println!("lvl id: {:?}", goop.id);
    //     println!("user id: {:?}", goop.user_id);
    // }

    for result in {
        query
            .fetch_all(&mut connection)
            .await
            .expect("error loading levels")
    } {
        let set_difficulty = result.difficulty.map(helpers::difficulty::LevelDifficulty::new);
        let community_difficulty = result.community_difficulty.map(helpers::difficulty::LevelDifficulty::new);
        let difficulty = set_difficulty.or(community_difficulty);
        let demon_difficulty = result.demon_difficulty.map(helpers::difficulty::DemonDifficulty::new);
    
        results.push(helpers::format::format(hashmap! {
            1 => result.id.to_string(),
            2 => result.name,
            3 => general_purpose::URL_SAFE.encode(result.description),
            5 => result.version.to_string(),
            6 => result.user_id.to_string(),
            // this argument is weird. its the "difficulty divisor"
            // used to be vote count but yeah
            8 => 10.to_string(),
            9 => (match difficulty {
                Some(diff) => diff.to_star_difficulty(),
                None => 0
            } * 10).to_string(),
            10 => result.downloads.to_string(),
            12 => (if result.song_id < 50 { result.song_id } else { 0 }).to_string(),
            13 => result.game_version.to_string(),
            14 => result.likes.to_string(),
            16 => (-result.likes).to_string(),
            15 => result.length.to_string(),
            17 => match difficulty {
                Some(diff) => {
                    if diff == helpers::difficulty::LevelDifficulty::Demon {
                        1
                    } else {
                        0
                    }
                },
                None => 0
            }.to_string(),
            18 => (if let Some(stars) = result.stars { stars } else { 0 }).to_string(),
            19 => result.featured.to_string(),
            25 => match difficulty {
                Some(diff) => {
                    if diff == helpers::difficulty::LevelDifficulty::Auto {
                        1
                    } else {
                        0
                    }
                },
                None => 0
            }.to_string(),
            30 => (if let Some(original) = result.original { original } else { 0 }).to_string(),
            31 => result.two_player.to_string(),
            35 => (if result.song_id >= 50 { result.song_id } else { 0 }).to_string(),
            37 => result.coins.to_string(),
            38 => result.rated_coins.to_string(),
            39 => (if let Some(requested_stars) = result.requested_stars { requested_stars } else { 0 }).to_string(),
            40 => result.has_ldm.to_string(),
            42 => result.epic.to_string(),
            43 => match demon_difficulty {
                Some(diff) => {
                    diff
                },
                None => helpers::difficulty::DemonDifficulty::Hard
            }.to_demon_difficulty().to_string(),
            45 => result.objects.to_string(),
            46 => result.editor_time.to_string(),
            47 => result.editor_time_copies.to_string()
        }));

        users.push(format!("{}:{}:{}", result.user_id, result.user_username, {
            if result.user_registered == 1 {
                result.user_account_id.expect("wtf? registered user with no account id.").to_string()
            } else {
                result.user_udid.expect("wtf? unregistered user with no udid.")
            }
        }));

        hash_data.push((
            result.id,
            { if let Some(stars) = result.stars {
                stars
            } else {
                0
            }},
            { if let 1 = result.rated_coins {
                true
            } else {
                false
            }}
        ));
    }

    let search_meta = format!("{}:{}:{}", count, page_offset, 10);

    let response = vec![results.join("|"), users.join("|"), songs.join("|"), search_meta, helpers::encryption::gen_multi(hash_data)].join("#");

    return status::Custom(Status::Ok, Box::leak(response.into_boxed_str()))
}