//! Application to run python userscript per filepath

use rustpython_vm as vm;
use rustpython;

use vm::builtins::{PyCode, PyStr};
use vm::compiler::CompileError;
use vm::{PyPayload, PyRef};
use rustpython_vm::compiler::core::Mode;

use walkdir::WalkDir;

use std::fs;
use std::path;

fn evaluate_filepath(interp: &vm::Interpreter, filepath: &path::Path, userscript_filepath: &path::Path) -> Result<(), String> {

    let filepath_basename = match filepath.file_name() {
        Some(b) => b,
        None => return Ok(()),
    };

    if let Err(err) = interp.enter(|rvm| {
        let source: String = fs::read_to_string(userscript_filepath).expect("cannot read python source file");

        let compiled: Result<PyRef<PyCode>, CompileError> = rvm.compile(&source, Mode::Exec, userscript_filepath.to_str().unwrap().to_string());
        match compiled {
            Ok(ref_code) => {
                let scope = rvm.new_scope_with_builtins();
                let object_ref = rvm.run_code_obj(ref_code, scope.clone())?;

                let fn1 = scope.globals.get_item("rename", rvm)?;
                let fn1_result = fn1.call((filepath_basename.to_str().unwrap().to_string(),), rvm)?;

                let ret_value: PyRef<PyStr> = match fn1_result.downcast() {
                    Ok(string_return_value) => string_return_value,
                    Err(_) => return Err(rvm.new_value_error(format!("function rename did not return a string"))),
                };
                println!("modified filepath = '{}'", ret_value);
                // TODO actually rename the file, not doing it so no copier accidentally runs it
            },
            Err(err) => {
                eprintln!("could not compile provided user script '{}'", filepath.display());
                eprintln!("error: {}", err);
                return Err(rvm.new_import_error(format!("failed to compile provided user script"), PyStr::from("userscript.py").into_ref(rvm.ctx.as_ref())));
            },
        }
        
        Ok(())
    }) {
        let e = err.clone();
        let errmsg = format!("cause={:?} context={:?} traceback={:?}", e.cause(), e.context(), e.traceback().unwrap());
        return Err(errmsg);
    }

    Ok(())
}

fn traverse_filesystem(root_dir: &str, userscript_filepath: &str) -> Result<(), String> {
    // (1) verify that all specified filepaths exist
    let userscript_path = path::Path::new(userscript_filepath);
    if !userscript_path.exists() {
        return Err(format!("userscript path not found '{}'", userscript_filepath));
    }

    // (2) initialize Python runtime
    let interp = rustpython::InterpreterConfig::new().init_stdlib().interpreter();
    if let Err(err) = interp.enter(|rvm| {
        let main_scope = rvm.new_scope_with_builtins();
        let source: String = fs::read_to_string(userscript_path).expect(&format!("python could not read user script '{}' file", userscript_path.display()));

        let compiled: Result<PyRef<PyCode>, CompileError> = rvm.compile(&source, Mode::Exec, userscript_path.display().to_string());
        match compiled {
            Ok(ref_code) => {
                rvm.run_code_obj(ref_code, main_scope.clone())?;
                println!("python source code was compiled");
                // TODO may I fetch a reference to python function 'rename' here?
            },
            Err(err) => {
                eprintln!("could not compile provided user script '{}'", userscript_path.display());
                eprintln!("error: {}", err);
                return Err(rvm.new_import_error(format!("failed to compile provided user script"), PyStr::from("userscript.py").into_ref(rvm.ctx.as_ref())));
            },
        }
        
        Ok(())
    }) {
        let e = err.clone();
        let errmsg = format!("cause={:?} context={:?} traceback={:?}", e.cause(), e.context(), e.traceback().unwrap());
        interp.finalize(Some(err.clone()));
        return Err(errmsg); 
    }

    // (3) traverse filesystem
    let root_path = path::PathBuf::from(root_dir);
    let walk = WalkDir::new(root_path).follow_links(true).sort_by_key(|a| a.file_name().to_owned()).into_iter().filter_map(|e| e.ok());
    for entry in walk {
        evaluate_filepath(&interp, entry.path(), userscript_path)?;
    }

    interp.finalize(None);

    Ok(())
}

fn main() {
    match traverse_filesystem(".", "userscript.py") {
        Err(err) => eprintln!("{}", err),
        Ok(_) => println!("done."),
    }
}