mapfixer/src/main.rs

use std::io::{Read, Seek};
use clap::{Args, Parser, Subcommand};
use anyhow::Result as AResult;

#[derive(Parser)]
#[command(author, version, about, long_about = None)]
#[command(propagate_version = true)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    Download(MapList),
    DownloadTextures(PathBufList),
    ConvertTextures,
    Extract(PathBufList),
    Interactive,
    Replace,
    Scan,
    UnzipAll,
    Upload,
}

#[derive(Args)]
struct PathBufList {
    paths:Vec<std::path::PathBuf>
}

#[derive(Args)]
struct MapList {
    maps: Vec<u64>,
}

fn class_is_a(class: &str, superclass: &str) -> bool {
    if class==superclass {
        return true
    }
    let class_descriptor=rbx_reflection_database::get().classes.get(class);
    if let Some(descriptor) = &class_descriptor {
        if let Some(class_super) = &descriptor.superclass {
            return class_is_a(&class_super, superclass)
        }
    }
    return false
}
fn recursive_collect_superclass(objects: &mut std::vec::Vec<rbx_dom_weak::types::Ref>,dom: &rbx_dom_weak::WeakDom, instance: &rbx_dom_weak::Instance, superclass: &str){
    for &referent in instance.children() {
        if let Some(c) = dom.get_by_ref(referent) {
            if class_is_a(c.class.as_str(), superclass) {
                objects.push(c.referent());//copy ref
            }
            recursive_collect_superclass(objects,dom,c,superclass);
        }
    }
}
fn get_full_name(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance) -> String{
    let mut full_name=instance.name.clone();
    let mut pref=instance.parent();
    while let Some(parent)=dom.get_by_ref(pref){
        full_name.insert(0, '.');
        full_name.insert_str(0, &parent.name);
        pref=parent.parent();
    }
    full_name
}

//download
    //download list of maps to maps/unprocessed
//scan (scripts)
    //iter maps/unprocessed
    //passing moves to maps/verified
    //failing moves to maps/blocked
//replace (edits & deletions)
    //iter maps/blocked
    //replace scripts and put in maps/unprocessed
//upload
    //iter maps/verified
    //interactively print DisplayName/Creator and ask for target upload ids
//interactive
    //iter maps/unprocessed
    //for each unique script, load it into the file current.lua and have it open in sublime text
    //I can edit the file and it will edit it in place
    //I pass/fail(with comment)/allow each script

fn get_script_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
    let mut scripts = std::vec::Vec::new();
    recursive_collect_superclass(&mut scripts, dom, dom.root(),"LuaSourceContainer");
    scripts
}
fn get_texture_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
    let mut objects = std::vec::Vec::new();
    recursive_collect_superclass(&mut objects, dom, dom.root(),"Decal");
    //get ids
    //clear vec
    //next class
    objects
}

enum ReaderType<'a, R:Read+Seek>{
    GZip(flate2::read::GzDecoder<&'a mut R>),
    Raw(&'a mut R),
}

fn maybe_gzip_decode<R:Read+Seek>(input:&mut R)->AResult<ReaderType<R>>{
    let mut first_2=[0u8;2];
    if let (Ok(()),Ok(()))=(std::io::Read::read_exact(input, &mut first_2),std::io::Seek::rewind(input)){
        match &first_2{
            b"\x1f\x8b"=>Ok(ReaderType::GZip(flate2::read::GzDecoder::new(input))),
            _=>Ok(ReaderType::Raw(input)),
        }
    }else{
        Err(anyhow::Error::msg("failed to peek"))
    }
}

fn load_dom<R:Read+Seek>(input:&mut R)->AResult<rbx_dom_weak::WeakDom>{
    let mut first_8=[0u8;8];
    if let (Ok(()),Ok(()))=(std::io::Read::read_exact(input, &mut first_8),std::io::Seek::rewind(input)){
        match &first_8[0..4]{
            b"<rob"=>{
                match &first_8[4..8]{
                    b"lox!"=>return rbx_binary::from_reader(input).map_err(anyhow::Error::msg),
                    b"lox "=>return rbx_xml::from_reader(input,rbx_xml::DecodeOptions::default()).map_err(anyhow::Error::msg),
                    other=>Err(anyhow::Error::msg(format!("Unknown Roblox file type {:?}",other))),
                }
            },
            _=>Err(anyhow::Error::msg("unsupported file type")),
        }
    }else{
        Err(anyhow::Error::msg("peek failed"))
    }
}

fn get_dom<R:Read+Seek>(input:&mut R)->AResult<rbx_dom_weak::WeakDom>{
    match maybe_gzip_decode(input){
        Ok(ReaderType::GZip(mut readable)) => {
            //gzip
            let mut extracted:Vec<u8>=Vec::new();
            readable.read_to_end(&mut extracted)?;
            Ok(load_dom(&mut std::io::Cursor::new(extracted))?)
        },
        Ok(ReaderType::Raw(readable)) => Ok(load_dom(readable)?),
        Err(e) => Err(e)?,
    }
}

fn get_id() -> AResult<u32>{
    match std::fs::read_to_string("id"){
        Ok(id_file)=>Ok(id_file.parse::<u32>()?),
        Err(e) => match e.kind() {
            std::io::ErrorKind::NotFound => Ok(0),//implicitly take on id=0
            _ => Err(e)?,
        }
    }
}

fn get_set_from_file(file:&str) -> AResult<std::collections::HashSet<String>>{
    let mut set=std::collections::HashSet::<String>::new();
    for entry in std::fs::read_dir(file)? {
        set.insert(std::fs::read_to_string(entry?.path())?);
    }
    Ok(set)
}

fn get_allowed_set() -> AResult<std::collections::HashSet<String>>{
    get_set_from_file("scripts/allowed")
}

fn get_blocked() -> AResult<std::collections::HashSet<String>>{
    get_set_from_file("scripts/blocked")
}

fn get_allowed_map() -> AResult<std::collections::HashMap::<u32,String>>{
    let mut allowed_map = std::collections::HashMap::<u32,String>::new();
    for entry in std::fs::read_dir("scripts/allowed")? {
        let entry=entry?;
        allowed_map.insert(entry.path().file_stem().unwrap().to_str().unwrap().parse::<u32>()?,std::fs::read_to_string(entry.path())?);
    }
    Ok(allowed_map)
}

fn get_replace_map() -> AResult<std::collections::HashMap::<String,u32>>{
    let mut replace = std::collections::HashMap::<String,u32>::new();
    for entry in std::fs::read_dir("scripts/replace")? {
        let entry=entry?;
        replace.insert(std::fs::read_to_string(entry.path())?,entry.path().file_stem().unwrap().to_str().unwrap().parse::<u32>()?);
    }
    Ok(replace)
}

fn check_source_illegal_keywords(source:&String)->bool{
    source.find("getfenv").is_some()||source.find("require").is_some()
}

fn find_first_child_class<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&'a rbx_dom_weak::Instance,name:&'a str,class:&'a str) -> Option<&'a rbx_dom_weak::Instance> {
    for &referent in instance.children() {
        if let Some(c) = dom.get_by_ref(referent) {
            if c.name==name&&class_is_a(c.class.as_str(),class) {
                return Some(c);
            }
        }
    }
    None
}

fn get_mapinfo(dom:&rbx_dom_weak::WeakDom) -> AResult<(String,String,String)>{
    let workspace_children=dom.root().children();
    if workspace_children.len()!=1{
        return Err(anyhow::Error::msg("there can only be one model"));
    }
    if let Some(model_instance) = dom.get_by_ref(workspace_children[0]) {
        if let (Some(creator),Some(displayname))=(find_first_child_class(dom, model_instance, "Creator", "StringValue"),find_first_child_class(dom, model_instance, "DisplayName", "StringValue")){
            if let (
                Some(rbx_dom_weak::types::Variant::String(creator_string)),
                Some(rbx_dom_weak::types::Variant::String(displayname_string))
            )=(
                creator.properties.get("Value"),
                displayname.properties.get("Value")
            ){
                return Ok((model_instance.name.clone(),creator_string.clone(),displayname_string.clone()));
            }
        }
    }
    return Err(anyhow::Error::msg("no stuff in map"));
}

fn download(map_list: Vec<u64>) -> AResult<()>{
    let header=format!("Cookie: .ROBLOSECURITY={}",std::env::var("RBXCOOKIE")?);
    let shared_args=&[
        "-q",
        "--header",
        header.as_str(),
        "-O",
    ];
    let processes_result:Result<Vec<_>, _>=map_list.iter().map(|map_id|{
        std::process::Command::new("wget")
        .args(shared_args)
        .arg(format!("maps/unprocessed/{}.rbxm",map_id))
        .arg(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",map_id))
        .spawn()
    }).collect();
    //naively wait for all because idk how to make an async progress bar lmao
    for child in processes_result?{
        let output=child.wait_with_output()?;
        println!("map exit_success:{}",output.status.success());
    }
    Ok(())
}

struct RobloxAssetId(u64);
struct RobloxAssetIdParseErr;
impl std::str::FromStr for RobloxAssetId {
    type Err=RobloxAssetIdParseErr;
    fn from_str(s: &str) -> Result<Self, Self::Err>{
        let regman=regex::Regex::new(r"(\d+)$").unwrap();
        if let Some(captures) = regman.captures(s) {
            if captures.len()==2{//captures[0] is all captures concatenated, and then each individual capture
                if let Ok(id) = captures[0].parse::<u64>() {
                    return Ok(Self(id));
                }
            }
        }
        Err(RobloxAssetIdParseErr)
    }
}
/* The ones I'm interested in:
Beam.Texture
Decal.Texture
FileMesh.MeshId
FileMesh.TextureId
MaterialVariant.ColorMap
MaterialVariant.MetalnessMap
MaterialVariant.NormalMap
MaterialVariant.RoughnessMap
MeshPart.MeshId
MeshPart.TextureID
ParticleEmitter.Texture
Sky.MoonTextureId
Sky.SkyboxBk
Sky.SkyboxDn
Sky.SkyboxFt
Sky.SkyboxLf
Sky.SkyboxRt
Sky.SkyboxUp
Sky.SunTextureId
SurfaceAppearance.ColorMap
SurfaceAppearance.MetalnessMap
SurfaceAppearance.NormalMap
SurfaceAppearance.RoughnessMap
SurfaceAppearance.TexturePack
*/
fn download_textures(paths: Vec<std::path::PathBuf>) -> AResult<()>{
    println!("download_textures paths:{:?}",paths);
    let header=format!("Cookie: .ROBLOSECURITY={}",std::env::var("RBXCOOKIE")?);
    let shared_args=&[
        "-q",
        "--header",
        header.as_str(),
        "-O",
    ];
    let mut texture_list=std::collections::HashSet::new();
    for path in paths {
        let mut input = std::io::BufReader::new(std::fs::File::open(path.clone())?);

        match get_dom(&mut input){
            Ok(dom)=>{
                let object_refs = get_texture_refs(&dom);
                for &object_ref in object_refs.iter() {
                    if let Some(object)=dom.get_by_ref(object_ref){
                        if let Some(rbx_dom_weak::types::Variant::Content(content)) = object.properties.get("Texture") {
                            println!("Texture content:{:?}",content);
                            if let Ok(asset_id)=content.clone().into_string().parse::<RobloxAssetId>(){
                                texture_list.insert(asset_id.0);
                            }
                        }
                    }
                }
            },
            Err(e)=>println!("error loading map {:?}: {:?}",path.file_name(),e),
        }
    }
    println!("Texture list:{:?}",texture_list);
    let processes_result:Result<Vec<_>, _>=texture_list.iter().map(|asset_id|{
        std::process::Command::new("wget")
        .args(shared_args)
        .arg(format!("textures/unprocessed/{}",asset_id))
        .arg(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",asset_id))
        .spawn()
    }).collect();
    //naively wait for all because idk how to make an async progress bar lmao
    for child in processes_result?{
        let output=child.wait_with_output()?;
        println!("texture exit_success:{}",output.status.success());
    }
    Ok(())
}

fn load_image<R:Read+Seek+std::io::BufRead>(input:&mut R)->AResult<image::DynamicImage>{
    let mut fourcc=[0u8;4];
    input.read_exact(&mut fourcc)?;
    input.rewind()?;
    match &fourcc{
        b"\x89PNG"=>Ok(image::load(input,image::ImageFormat::Png)?),
        b"\xFF\xD8\xFF\xE0"=>Ok(image::load(input,image::ImageFormat::Jpeg)?),//JFIF
        other=>Err(anyhow::Error::msg(format!("Unknown texture format {:?}",other))),
    }
}

fn convert(file_thing:std::fs::DirEntry) -> AResult<()>{
    let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);

    let mut extracted_input=None;
    let image=match maybe_gzip_decode(&mut input){
        Ok(ReaderType::GZip(mut readable)) => {
            //gzip
            let mut extracted:Vec<u8>=Vec::new();
            //read the entire thing to the end so that I can clone the data and write a png to processed images
            readable.read_to_end(&mut extracted)?;
            extracted_input=Some(extracted.clone());
            load_image(&mut std::io::Cursor::new(extracted))
        },
        Ok(ReaderType::Raw(readable)) => load_image(readable),
        Err(e) => Err(e)?,
    }?.to_rgba8();//this is setting a=0?

    let format=if image.width()%4!=0||image.height()%4!=0{
        image_dds::ImageFormat::R8G8B8A8Srgb
    }else{
        image_dds::ImageFormat::BC7Srgb
    };
    //this fails if the image dimensions are not a multiple of 4
    let dds = image_dds::dds_from_image(
        &image,
        format,
        image_dds::Quality::Slow,
        image_dds::Mipmaps::GeneratedAutomatic,
    )?;

    //write dds
    let mut dest=std::path::PathBuf::from("textures/dds");
    dest.push(file_thing.file_name());
    dest.set_extension("dds");
    let mut writer = std::io::BufWriter::new(std::fs::File::create(dest)?);
    dds.write(&mut writer)?;

    if let Some(mut extracted)=extracted_input{
        //write extracted to processed
        let mut dest=std::path::PathBuf::from("textures/processed");
        dest.push(file_thing.file_name());
        std::fs::write(dest, &mut extracted)?;
        //delete ugly gzip file
        std::fs::remove_file(file_thing.path())?;
    }else{
        //move file to processed
        let mut dest=std::path::PathBuf::from("textures/processed");
        dest.push(file_thing.file_name());
        std::fs::rename(file_thing.path(), dest)?;
    }
    Ok(())
}
fn convert_textures() -> AResult<()>{
    let start = std::time::Instant::now();
    let mut threads=Vec::new();
    for entry in std::fs::read_dir("textures/unprocessed")? {
        let file_thing=entry?;
        threads.push(std::thread::spawn(move ||{
            let file_name=file_thing.file_name();
            let result=convert(file_thing);
            if let Err(e)=result{
                println!("error processing file:{:?} error message:{:?}",file_name,e);
            }
        }));
    }
    let mut i=0;
    let n_threads=threads.len();
    for thread in threads{
        i+=1;
        if let Err(e)=thread.join(){
            println!("thread error: {:?}",e);
        }else{
            println!("{}/{}",i,n_threads);
        }
    }
    println!("{:?}", start.elapsed());
    Ok(())
}

enum Scan{
    Passed,
    Blocked,
    Flagged,
}

fn scan() -> AResult<()>{
    let mut id = get_id()?;
    //Construct allowed scripts
    let allowed_set = get_allowed_set()?;
    let mut blocked = get_blocked()?;

    for entry in std::fs::read_dir("maps/unprocessed")? {
        let file_thing=entry?;
        let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);

        let dom = get_dom(&mut input)?;

        let script_refs = get_script_refs(&dom);

        //check scribb
        let mut fail_count=0;
        let mut fail_type=Scan::Passed;
        for &script_ref in script_refs.iter() {
            if let Some(script)=dom.get_by_ref(script_ref){
                if let Some(rbx_dom_weak::types::Variant::String(s)) = script.properties.get("Source") {
                    //flag keywords and instantly fail
                    if check_source_illegal_keywords(s){
                        println!("{:?} - flagged.",file_thing.file_name());
                        fail_type=Scan::Flagged;
                        break;
                    }
                    if allowed_set.contains(s) {
                        continue;
                    }else{
                        fail_type=Scan::Blocked;//no need to check for Flagged, it breaks the loop.
                        fail_count+=1;
                        if !blocked.contains(s) {
                            blocked.insert(s.clone());//all fixed! just clone!
                            std::fs::write(format!("scripts/blocked/{}.lua",id),s)?;
                            id+=1;
                        }
                    }
                }else{
                    panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
                }
            }else{
                panic!("FATAL: failed to get_by_ref {:?}",script_ref);
            }
        }
        let mut dest=match fail_type {
            Scan::Passed => std::path::PathBuf::from("maps/processed"),
            Scan::Blocked => {
                println!("{:?} - {} {} not allowed.",file_thing.file_name(),fail_count,if fail_count==1 {"script"}else{"scripts"});
                std::path::PathBuf::from("maps/blocked")
            }
            Scan::Flagged => std::path::PathBuf::from("maps/flagged")
        };
        dest.push(file_thing.file_name());
        std::fs::rename(file_thing.path(), dest)?;
    }
    std::fs::write("id",id.to_string())?;
    Ok(())
}

fn extract(paths: Vec<std::path::PathBuf>) -> AResult<()>{
    let mut id = 0;
    //Construct allowed scripts
    let mut script_set = std::collections::HashSet::<String>::new();

    for path in paths {
        let file_name=path.file_name();
        let mut input = std::io::BufReader::new(std::fs::File::open(&path)?);

        let dom = get_dom(&mut input)?;

        let script_refs = get_script_refs(&dom);

        //extract scribb
        for &script_ref in script_refs.iter() {
            if let Some(script)=dom.get_by_ref(script_ref){
                if let Some(rbx_dom_weak::types::Variant::String(s)) = script.properties.get("Source") {
                    if script_set.contains(s) {
                        continue;
                    }else{
                        script_set.insert(s.clone());
                        std::fs::write(format!("scripts/extracted/{:?}_{}_{}.lua",file_name,id,script.name),s)?;
                        id+=1;
                    }
                }else{
                    panic!("FATAL: failed to get source for {:?}",file_name);
                }
            }else{
                panic!("FATAL: failed to get_by_ref {:?}",script_ref);
            }
        }
    }
    println!("extracted {} {}",id,if id==1 {"script"}else{"scripts"});
    Ok(())
}
fn replace() -> AResult<()>{
    let allowed_map=get_allowed_map()?;
    let replace_map=get_replace_map()?;

    for entry in std::fs::read_dir("maps/blocked")? {
        let file_thing=entry?;

        let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
        let mut dom = get_dom(&mut input)?;

        let script_refs = get_script_refs(&dom);

        //check scribb
        let mut any_failed=false;
        for &script_ref in script_refs.iter() {
            if let Some(script)=dom.get_by_ref(script_ref){
                if let Some(rbx_dom_weak::types::Variant::String(source)) = script.properties.get("Source") {
                    if let (Some(replace_id),Some(replace_script))=(replace_map.get(source),dom.get_by_ref_mut(script.referent())) {
                        println!("replace {}",replace_id);
                        //replace the source
                        if let Some(replace_source)=allowed_map.get(replace_id){
                            replace_script.properties.insert("Source".to_string(), rbx_dom_weak::types::Variant::String(replace_source.clone()));
                        }else{
                            println!("failed to get replacement source {}",replace_id);
                            any_failed=true;
                        }
                    }else{
                        println!("failed to failed to get replace_id and replace_script");
                        any_failed=true;
                    }
                }else{
                    panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
                }
            }else{
                panic!("FATAL: failed to get_by_ref {:?}",script_ref);
            }
        }
        if any_failed {
            println!("One or more scripts failed to replace.");
        }else{
            let mut dest=std::path::PathBuf::from("maps/unprocessed");
            dest.set_file_name(file_thing.file_name());
            let output = std::io::BufWriter::new(std::fs::File::open(dest)?);
            rbx_binary::to_writer(output, &dom, &[dom.root_ref()])?;
        }
    }
    Ok(())
}

enum UploadAction {
    Upload(u64),
    Skip,
    New,
    Delete,
}
struct ParseUploadActionErr;
impl std::str::FromStr for UploadAction {
    type Err=ParseUploadActionErr;
    fn from_str(s: &str) -> Result<Self, Self::Err>{
        if s=="skip\n"{
            Ok(Self::Skip)
        }else if s=="new\n"{
            Ok(Self::New)
        }else if s=="delete\n"{
            Ok(Self::Delete)
        }else if let Ok(asset_id)=s[..s.len()-1].parse::<u64>(){
            Ok(Self::Upload(asset_id))
        }else{
            Err(ParseUploadActionErr)
        }
    }
}

fn upload() -> AResult<()>{
    //interactive prompt per upload:
    for entry in std::fs::read_dir("maps/passed")? {
        let file_thing=entry?;
        println!("map file: {:?}",file_thing.file_name());
        let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);

        let dom = get_dom(&mut input)?;
        let (modelname,creator,displayname) = get_mapinfo(&dom)?;

        //Creator: [auto fill creator]
        //DisplayName: [auto fill DisplayName]
        //id: ["New" for blank because of my double enter key]
        print!("Model name: {}\nCreator: {}\nDisplayName: {}\nAction or Upload Asset Id: ",modelname,creator,displayname);
        std::io::Write::flush(&mut std::io::stdout())?;
        let upload_action;
        loop{
            let mut upload_action_string = String::new();
            std::io::stdin().read_line(&mut upload_action_string)?;
            if let Ok(parsed_upload_action)=upload_action_string.parse::<UploadAction>(){
                upload_action=parsed_upload_action;
                break;
            }else{
                print!("Action or Upload Asset Id: ");
                std::io::Write::flush(&mut std::io::stdout())?;
            }
        }
        match upload_action {
            UploadAction::Upload(asset_id) => {
                let status=std::process::Command::new("../rbxcompiler-linux-amd64")
                .arg("--compile=false")
                .arg("--group=6980477")
                .arg(format!("--asset={}",asset_id))
                .arg(format!("--input={}",file_thing.path().into_os_string().into_string().unwrap()))
                .status()?;
                match status.code() {
                    Some(0)=>{
                        //move file
                        let mut dest=std::path::PathBuf::from("maps/uploaded");
                        dest.push(file_thing.file_name());
                        std::fs::rename(file_thing.path(), dest)?;
                    }
                    Some(code)=>println!("upload failed! code={}",code),
                    None => println!("no status code!"),
                }
            }
            UploadAction::Skip => continue,
            UploadAction::New => {
                let output=std::process::Command::new("../rbxcompiler-linux-amd64")
                .arg("--compile=false")
                .arg("--group=6980477")
                .arg("--new-asset=true")
                .arg(format!("--input={}",file_thing.path().into_os_string().into_string().unwrap()))
                .output()?;
                match output.status.code() {
                    Some(0)=>{
                        //print output
                        println!("{}", std::str::from_utf8(output.stdout.as_slice())?);
                        //move file
                        let mut dest=std::path::PathBuf::from("maps/uploaded");
                        dest.push(file_thing.file_name());
                        std::fs::rename(file_thing.path(), dest)?;
                    }
                    Some(code)=>println!("upload failed! code={}",code),
                    None => println!("no status code!"),
                }
            }
            UploadAction::Delete => std::fs::remove_file(file_thing.path())?,
        }
    }
    Ok(())
}

enum Interactive{
    Passed,
    Blocked,
    Flagged,
}
enum ScriptAction {
    Pass,
    Replace(u32),
    Flag,
    Block,
    Delete,
}
enum ScriptActionParseResult {
    Pass,
    Block,
    Exit,
    Delete,
}
struct ParseScriptActionErr;
impl std::str::FromStr for ScriptActionParseResult {
    type Err=ParseScriptActionErr;
    fn from_str(s: &str) -> Result<Self, Self::Err>{
        if s=="pass\n"||s=="1\n"{
            Ok(Self::Pass)
        }else if s=="block\n"{
            Ok(Self::Block)
        }else if s=="exit\n"{
            Ok(Self::Exit)
        }else if s=="delete\n"{
            Ok(Self::Delete)
        }else{
            Err(ParseScriptActionErr)
        }
    }
}

fn interactive() -> AResult<()>{
    let mut id=get_id()?;
    //Construct allowed scripts
    let mut allowed_set=get_allowed_set()?;
    let mut allowed_map=get_allowed_map()?;
    let mut replace_map=get_replace_map()?;
    let mut blocked = get_blocked()?;

    'map_loop: for entry in std::fs::read_dir("maps/unprocessed")? {
        let file_thing=entry?;
        println!("processing map={:?}",file_thing.file_name());
        let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
        let mut dom = get_dom(&mut input)?;

        let script_refs = get_script_refs(&dom);

        //check scribb
        let mut script_count=0;
        let mut replace_count=0;
        let mut block_count=0;
        let mut fail_type=Interactive::Passed;
        for &script_ref in script_refs.iter() {
            if let Some(script)=dom.get_by_ref(script_ref){
                if let Some(rbx_dom_weak::types::Variant::String(source)) = script.properties.get("Source") {
                    script_count+=1;
                    let source_action=if check_source_illegal_keywords(source) {
                        ScriptAction::Flag//script triggers flagging -> Flag
                    } else if blocked.contains(source) {
                        ScriptAction::Block//script is blocked -> Block
                    } else if allowed_set.contains(source) {
                        ScriptAction::Pass//script is allowed -> Pass
                    }else if let Some(replace_id)=replace_map.get(source) {
                        ScriptAction::Replace(*replace_id)
                    }else{
                        //interactive logic goes here
                        print!("unresolved source location={}\naction: ",get_full_name(&dom, script));
                        std::io::Write::flush(&mut std::io::stdout())?;
                        //load source into current.lua
                        std::fs::write("current.lua",source)?;
                        //prompt action in terminal
                        //wait for input
                        let script_action;
                        loop{
                            let mut action_string = String::new();
                            std::io::stdin().read_line(&mut action_string)?;
                            if let Ok(parsed_script_action)=action_string.parse::<ScriptActionParseResult>(){
                                script_action=parsed_script_action;
                                break;
                            }else{
                                print!("action: ");
                                std::io::Write::flush(&mut std::io::stdout())?;
                            }
                        }
                        //update allowed/replace/blocked
                        match script_action{
                            ScriptActionParseResult::Pass => {
                                //if current.lua was updated, create an allowed and replace file and set script_action to replace(new_id)
                                let modified_source=std::fs::read_to_string("current.lua")?;
                                if &modified_source==source{
                                    //it's always new.
                                    //insert allowed_set
                                    allowed_set.insert(modified_source.clone());
                                    //insert allowed_map
                                    allowed_map.insert(id,modified_source.clone());
                                    //write allowed/id.lua
                                    std::fs::write(format!("scripts/allowed/{}.lua",id),modified_source)?;
                                    id+=1;
                                    ScriptAction::Pass
                                }else{
                                    //insert allowed_set
                                    allowed_set.insert(modified_source.clone());
                                    //insert allowed_map
                                    allowed_map.insert(id,modified_source.clone());
                                    //insert replace_map
                                    replace_map.insert(source.clone(),id);//this cannot be reached if it already exists
                                    //write allowed/id.lua
                                    std::fs::write(format!("scripts/allowed/{}.lua",id),modified_source)?;
                                    //write replace/id.lua
                                    std::fs::write(format!("scripts/replace/{}.lua",id),source)?;
                                    let ret=ScriptAction::Replace(id);
                                    id+=1;
                                    ret
                                }
                            },
                            ScriptActionParseResult::Block => {
                                blocked.insert(source.clone());
                                std::fs::write(format!("scripts/blocked/{}.lua",id),source)?;
                                id+=1;
                                ScriptAction::Block
                            },
                            ScriptActionParseResult::Exit => break 'map_loop,
                            ScriptActionParseResult::Delete => ScriptAction::Delete,
                        }
                    };
                    
                    let location=get_full_name(&dom, script);
                    match source_action{
                        ScriptAction::Pass => println!("passed source location={}",location),
                        ScriptAction::Replace(replace_id)=>{
                            //replace the source
                            if let (Some(replace_source),Some(replace_script))=(allowed_map.get(&replace_id),dom.get_by_ref_mut(script.referent())){
                                replace_count+=1;
                                println!("replaced source id={} location={}",replace_id,location);
                                replace_script.properties.insert("Source".to_string(), rbx_dom_weak::types::Variant::String(replace_source.clone()));
                            }else{
                                panic!("failed to get replacement source id={} location={}",replace_id,location);
                            }
                        },
                        ScriptAction::Delete => {
                            println!("deleted source location={}",location);
                            replace_count+=1;//trigger a new file generation
                            dom.destroy(script.referent());
                        },
                        ScriptAction::Flag => {
                            println!("flagged source location={}",location);
                            fail_type=Interactive::Flagged;
                        },
                        ScriptAction::Block => {
                            block_count+=1;
                            println!("blocked source location={}",location);
                            match fail_type{
                                Interactive::Passed => fail_type=Interactive::Blocked,
                                _=>(),
                            }
                        },
                    }
                }else{
                    panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
                }
            }else{
                panic!("FATAL: failed to get_by_ref {:?}",script_ref);
            }
        }
        let mut dest=match fail_type{
            Interactive::Passed => {
                println!("map={:?} passed with {} {}",file_thing.file_name(),script_count,if script_count==1 {"script"}else{"scripts"});
                if replace_count==0{
                    std::path::PathBuf::from("maps/passed")
                }else{
                    //create new file
                    println!("{} {} replaced - generating new file...",replace_count,if replace_count==1 {"script was"}else{"scripts were"});
                    let mut dest=std::path::PathBuf::from("maps/passed");
                    dest.push(file_thing.file_name());
                    let output = std::io::BufWriter::new(std::fs::File::create(dest)?);
                    //write workspace:GetChildren()[1]
                    let workspace_children=dom.root().children();
                    if workspace_children.len()!=1{
                        return Err(anyhow::Error::msg("there can only be one model"));
                    }
                    rbx_binary::to_writer(output, &dom, &[workspace_children[0]])?;
                    //move original to processed folder
                    std::path::PathBuf::from("maps/unaltered")
                }
            },//write map into maps/processed
            Interactive::Blocked => {
                println!("map={:?} blocked with {}/{} {} blocked",file_thing.file_name(),block_count,script_count,if script_count==1 {"script"}else{"scripts"});
                std::path::PathBuf::from("maps/blocked")
            },//write map into maps/blocked
            Interactive::Flagged => {
                println!("map={:?} flagged",file_thing.file_name());
                std::path::PathBuf::from("maps/flagged")
            },//write map into maps/flagged
        };
        dest.push(file_thing.file_name());
        std::fs::rename(file_thing.path(), dest)?;
    }
    std::fs::write("id",id.to_string())?;
    Ok(())
}


fn unzip_all()->AResult<()>{
    for entry in std::fs::read_dir("maps/unprocessed")? {
        let file_thing=entry?;
        println!("processing map={:?}",file_thing.file_name());
        let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
        match maybe_gzip_decode(&mut input){
        Ok(ReaderType::GZip(mut readable)) => {
            //gzip
            let mut extracted:Vec<u8>=Vec::new();
            //read the entire thing to the end so that I can clone the data and write a png to processed images
            readable.read_to_end(&mut extracted)?;
            //write extracted
            let mut dest=std::path::PathBuf::from("maps/unzipped");
            dest.push(file_thing.file_name());
            std::fs::write(dest, &mut extracted)?;
            //delete ugly gzip file
            std::fs::remove_file(file_thing.path())?;
        },
        Ok(ReaderType::Raw(_)) => (),
        Err(e) => Err(e)?,
        }
    }
    Ok(())
}

fn main() -> AResult<()> {
    let cli = Cli::parse();
    match cli.command {
        Commands::Download(map_list)=>download(map_list.maps),
        Commands::DownloadTextures(pathlist)=>download_textures(pathlist.paths),
        Commands::ConvertTextures=>convert_textures(),
        Commands::Extract(pathlist)=>extract(pathlist.paths),
        Commands::Interactive=>interactive(),
        Commands::Replace=>replace(),
        Commands::Scan=>scan(),
        Commands::UnzipAll=>unzip_all(),
        Commands::Upload=>upload(),
    }
}