use crate::Value;
use crate::utils::request_url;

pub fn main(args: &Vec<String>) {
    struct Package {
        name: String,
        dependancies: Vec<String>,
        parent: String,
    }
    // Check length of arguments
    let args_length = args.len();

    if args_length < 3 {
        // If there is no third param, return
        println!("no package specified")
    } else {
        // Get package as variable
        let package: &str = args[2].as_str();

        // Get package info
        let package_info_decoded: Value = get_pkg_info(package);

        // Check pacakge exists
        if check_package_exists(&package_info_decoded) == true {
            // Nice user facing nonsense
            println!("package {} found", &package);

            // Get dependancies as a weird value type
            let results_vector: &Vec<Value> = package_info_decoded["results"].as_array().unwrap();
            let deps: &Vec<Value> = results_vector[0]["Depends"].as_array().unwrap();
        } else {
            // If there are no results
            println!("No such package")
        }

        fn make_url(package: &str) -> String {
            let url: String = format!("https://aur.archlinux.org/rpc/v5/info/{}", package);
            return url;
        }

        fn get_pkg_info(package: &str) -> Value {
            // Make package url
            let url: String = make_url(package);

            // Get json returned from api
            let package_info: String = match request_url(&url) {
                Ok(s) => s,
                Err(e) => panic!("shit... {e:?}"),
            };

            // Decode into ""usable"" data
            let package_info_decoded: Value = serde_json::from_str(&package_info).unwrap();
            return package_info_decoded;
        }

        fn check_package_exists(package_info: &Value) -> bool {
            // Check if the package exists
            let resultcount: i64 = package_info["resultcount"].as_i64().unwrap();
            if resultcount > 0 {
                return true;
            } else {
                return false;
            }
        }

        fn get_deps_as_string(deps: &Vec<Value>) -> Vec<String> {
            let mut output: Vec<String> = vec![];
            for dependancy in deps {
                let dependancy_name: &str = dependancy.as_str().unwrap();
                output.push(String::from(dependancy_name))
            }
            return output;
        }
    }
}