nano9 0.1.0-alpha.7

use bevy::{
    asset::{
        AssetPath,
        io::{AssetSourceBuilder, AssetSourceId},
    },
    prelude::*,
};
use clap::{Parser, Subcommand};
use nano9::{
    config::{load_and_insert_pico8, pause_pico8_when_loaded, run_pico8_when_loaded},
    pico8::{CartLoaderSettings, Pico8Asset, Pico8Handle, SharedData},
    *,
};
use std::{env, ffi::OsStr, fs, io, path::PathBuf, process::ExitCode};

#[derive(Parser)]
#[command(version, about, long_about, disable_help_subcommand = true,
          // subcommand_required = true,
          // arg_required_else_help = true,
)]
// #[command(next_line_help = true)]
struct Cli {
    // /// Optional name to operate on
    // name: Option<String>,

    // Sets a custom config file
    // #[arg(short, long, value_name = "FILE")]
    // config: Option<PathBuf>,

    // /// Turn debugging information on
    // #[arg(short, long, action = clap::ArgAction::Count)]
    // debug: u8,
    #[command(subcommand)]
    command: Command,
}

#[derive(Subcommand)]
enum Command {
    /// Run a Pico-8 cart or Nano-9 project
    ///
    /// Environment variables:
    ///
    /// NANO9_ASSETS   - override the assets directory
    /// 
    /// NANO9_LUA_CODE - log the translated code to file
    Run {
        /// Run path.
        path: PathBuf,

        #[arg(long)]
        /// Start paused.
        pause: bool,
        #[arg(long)]
        /// Shared data for Pico-8 carts
        shared_data: Option<SharedData>,
    },
    /// Check a Pico-8 cart or Nano-9 project
    ///
    /// Environment variables:
    ///
    /// NANO9_ASSETS - override the assets directory
    /// NANO9_LUA_CODE   - log the translated code to file
    Check {
        /// Run path.
        path: PathBuf,
    },
    /// Create a new Nano-9 project
    ///
    /// Depending on the extension and arguments, it will create the following kind of project:
    ///   - FILE.p8lua, a one file Pico-8 Lua game with embedded config
    ///   - FILE.lua, a one file Lua game with embedded config
    ///   - [--language lua] FILE, a directory with config and Lua scripts (no Rust)
    ///   - --language rust FILE, a Rust-only crate with config in assets directory
    ///   - --language lua-rust FILE, a Rust crate with config and Lua scripts in assets directory
    #[command(verbatim_doc_comment)]
    New {
        /// Language
        // #[arg(long, default_value = "lua")]
        #[arg(long)]
        language: Option<Language>,
        /// Choose a starter template
        #[arg(long)]
        starter: Option<StarterKit>,
        /// Overwrite files if present
        #[arg(long)]
        force: bool,
        /// Destination path
        ///
        /// A one-file project is created if the path ends with the following
        /// extensions: .p8lua and .lua.
        path: PathBuf,
    },
    /// Report on available features
    Info {},
}

#[derive(Debug, Clone, clap::ValueEnum, PartialEq)]
enum Language {
    Rust,
    Lua,
    LuaRust,
}

#[derive(Debug, Clone, clap::ValueEnum)]
enum StarterKit {
    Platformer,
    TopDown,
}

const HELLO_WORLD: &str = include_str!("templates/main.lua");
// Secondary command line interface used as fallback.
//
// [source](https://stackoverflow.com/a/79564853/6454690)
#[derive(Parser)]
#[command(long_about = None)]
struct CliDefault {
    #[arg(long)]
    shared_data: Option<SharedData>,
    #[arg(long)]
    pause: bool,
    path: PathBuf,
}

fn main() -> io::Result<ExitCode> {
    let cli = match Cli::try_parse().or_else(|err| match err.kind() {
        clap::error::ErrorKind::InvalidSubcommand => CliDefault::try_parse()
            .map(|cli_default| Cli {
                command: Command::Run {
                    path: cli_default.path,
                    shared_data: cli_default.shared_data,
                    pause: cli_default.pause,
                },
            })
            .map_err(|_| err),
        _ => Err(err),
    }) {
        Ok(cli) => cli,
        Err(err) => {
            err.print().expect("error writing usage");
            // this will print any errors the same way as Cli::parse() would
            return Ok(ExitCode::from(err.exit_code() as u8));
        }
    };
    // let cli = Cli::parse();
    // let example_files = [
    //     "cart.p8",
    //     "cart.p8.png",
    //     "code.lua", // Lua
    //     // "code.pua", // Pico-8 dialect
    //     "game-dir",
    //     "game-dir/Nano9.toml",
    //     "code.n9",
    // ];
    match cli.command {
        Command::Run { .. } | Command::Check { .. } => run(cli),
        Command::New { .. } => new(cli),
        Command::Info { .. } => info(cli),
    }
}

fn info(_cli: Cli) -> io::Result<ExitCode> {
    macro_rules! feature_info {
        ($feature:literal, $description:literal, $enabled_by_default:expr) => {{
            let mark: char = match (cfg!(feature = $feature), $enabled_by_default) {
                (true, true) => 'x',
                (false, true) => '_',
                (true, false) => 'X',
                (false, false) => ' ',
            };
            println!("  - [{}] {:?} {}", mark, $feature, $description);
        }};
    }
    println!(
        r#"The following features are available. Use this key:
                                    - [x] enabled and enabled by default
                                    - [X] enabled and disabled by default
                                    - [_] disabled and enabled by default
                                    - [ ] disabled and disabled by default"#
    );
    feature_info!("scripting", "for Lua scripting", true);
    feature_info!("negate-y", "uses Pico-8's positive-y is downward", true);
    feature_info!("pixel-snap", "applies floor to pixel locations", true);
    feature_info!("pico8-to-lua", "converts Pico-8's dialect to Lua", true);
    feature_info!(
        "fixed-point",
        "uses fixed-point numbers for bit operations",
        true
    );
    feature_info!("web-asset", "allows URLs for asset locations", false);
    feature_info!("minibuffer", "embeds a gamedev console", false);
    feature_info!("inspector", "adds inspector commands to console", false);
    feature_info!("cli", "command line interface for n9", true);
    Ok(ExitCode::from(0))
}

fn new(cli: Cli) -> io::Result<ExitCode> {
    match cli.command {
        Command::New {
            language,
            starter,
            path,
            force,
        } => {
            use log::info;
            env_logger::Builder::from_env(
                env_logger::Env::default().default_filter_or("info,n9=info"),
            )
            .format_timestamp(None)
            .init();
            if let Some(extension) = path.extension().and_then(|s| s.to_str()) {
                match extension {
                    "lua" | "p8lua" => {
                        // Copy the p8lua template.
                        let content = include_str!("../../assets/pset.lua");
                        fs::write(path, content)?;
                        Ok(ExitCode::from(0))
                    }
                    ext => {
                        eprintln!("error: No template for extension {ext:?}.");
                        Ok(ExitCode::from(5))
                    }
                }
            } else {
                // It's a directory path.
                let assets_path = match language {
                    lang @ Some(Language::Rust | Language::LuaRust) => {
                        use cmd_lib::run_cmd;
                        info!("Creating new cargo project at {:?}.", &path);
                        let lang = lang.unwrap();
                        let feature = match lang {
                            Language::Rust => "rust-lib",
                            Language::LuaRust => "lua-lib",
                            Language::Lua => unreachable!(),
                        };
                        match run_cmd!(
                            cargo new $path;
                            cd $path;
                            cargo add bevy@0.15;
                            cargo add nano9 --git "https://github.com/shanecelis/nano9.git" --branch dev --no-default-features --features $feature;
                        ) {
                            Ok(_) => {
                                // Copy files
                                let content = include_str!("templates/Nano9.toml");
                                let mut p = path.to_path_buf();
                                p.push("assets");
                                fs::create_dir_all(&p)?;
                                p.push("Nano9.toml");
                                info!("Creating Nano-9 config at {:?}.", &p);
                                fs::write(&p, content)?;

                                if lang == Language::LuaRust {
                                    let _ = p.pop();
                                    p.push("main.lua");
                                    info!("Creating main Lua code at {:?}.", &p);
                                    fs::write(&p, HELLO_WORLD)?;

                                    let content = include_str!("templates/main-lua-rust.rs.txt");
                                    let _ = p.pop();
                                    let _ = p.pop();
                                    p.push("src/main.rs");
                                    info!("Creating main Rust code at {:?}.", &p);
                                    fs::write(&p, content)?;
                                } else {
                                    let content = include_str!("templates/main-rust.rs.txt");
                                    let _ = p.pop();
                                    let _ = p.pop();
                                    p.push("src/main.rs");
                                    info!("Creating main Rust code at {:?}.", &p);
                                    fs::write(&p, content)?;
                                }
                            }
                            Err(e) => {
                                error!("error: Problem running cargo {e}");
                                return Ok(ExitCode::from(8));
                            }
                        }
                        let mut p = path.to_path_buf();
                        p.push("assets");
                        Some(p)
                    }
                    Some(Language::Lua) | None => {
                        if path.exists() {
                            if path.is_file() {
                                error!("error: {path:?} is a file; a directory was expected.");
                                return Ok(ExitCode::from(6));
                            }
                            if path.is_dir() && !force {
                                error!(
                                    "error: {path:?} already exists, canceling; cautiously use --force to overwrite."
                                );
                                return Ok(ExitCode::from(7));
                            }
                        } else {
                            fs::create_dir_all(&path)?;
                        }
                        copy_template!("../../examples/sprite/Nano9.toml", path, "Nano9.toml");

                        copy_template!("../../examples/sprite/main.p8lua", path, "main.lua");
                        // let config = include_str!("../../examples/sprite/Nano9.toml");
                        // let mut p = path.to_path_buf();
                        // p.push("Nano9.toml");
                        // fs::write(&p, config)?;

                        // let code = include_str!("../../examples/sprite/main.p8lua");
                        // let mut code_path = path.to_path_buf();
                        // code_path.push("main.lua");
                        // fs::write(&code_path, code)?;
                        Some(path.to_path_buf())
                    }
                };
                if starter.is_some() && assets_path.is_none() {
                    error!(
                        "No assets path to copy template to for starter kit {:?}",
                        starter
                    );
                    return Ok(ExitCode::from(9));
                }
                match starter {
                    Some(StarterKit::Platformer) => {
                        if let Some(assets_path) = assets_path {
                            copy_template!(
                                "templates/platformer/Nano9.toml",
                                assets_path,
                                "Nano9.toml"
                            );
                            copy_template!(
                                "templates/platformer/actor.p8",
                                assets_path,
                                "actor.p8"
                            );
                            copy_template!(
                                "templates/platformer/dolly.p8",
                                assets_path,
                                "dolly.p8"
                            );
                            copy_template!(
                                "templates/platformer/main.lua",
                                assets_path,
                                "main.lua"
                            );
                            copy_template!(
                                "templates/platformer/micro-platformer.p8",
                                assets_path,
                                "micro-platformer.p8"
                            );
                            copy_template!(
                                "templates/platformer/platformer.p8",
                                assets_path,
                                "platformer.p8"
                            );
                            copy_template!(
                                "templates/platformer/vector.p8",
                                assets_path,
                                "vector.p8"
                            );
                        }
                    }
                    None => (),
                    _ => todo!(),
                }

                Ok(ExitCode::from(0))
            }
        }
        _ => unreachable!(),
    }
}

#[macro_export]
macro_rules! copy_template {
    ($src:expr, $path:expr, $filename:expr) => {{
        let config = include_str!($src);
        let mut p = $path.to_path_buf();
        p.push($filename);
        std::fs::write(&p, config)?;
        let _ = p.pop();
        p
    }};
}

enum Lookup {
    /// There are no defined asset sources.
    Default,
    /// There is one asset source for script and asset lookup.
    One { path: PathBuf },
    /// There are two asset sources, the default one and the script one.
    Two { default: PathBuf, script: PathBuf },
}

fn run(cli: Cli) -> io::Result<ExitCode> {
    let (input_path, shared_data, pause, check) = match cli.command {
        Command::Run {
            path,
            shared_data,
            pause,
        } => (path, shared_data, pause, false),
        Command::Check { path } => (path, None, false, true),
        _ => unreachable!(),
    };

    let invocation_dir = env::current_dir()?;
    let config_path = if input_path.extension() == Some(OsStr::new("toml")) {
        Some(input_path.clone())
    } else if input_path.is_dir() {
        let mut config_path = input_path.clone();
        config_path.push("Nano9.toml");
        Some(config_path)
    } else {
        None
    };
    let script_path = config_path.unwrap_or_else(|| input_path.clone());
    // Choose the default asset root before creating the app so we can register
    // it before AssetPlugin (Default must be registered before AssetPlugin).
    // - If NANO9_ASSETS is set, it always wins.
    // - Otherwise, if the input is a local path, use the "game directory":
    //   - directory arg: that directory
    //   - file arg: parent directory
    //
    // This keeps relative asset paths (scripts, sprite sheets, etc.) resolving the same way for:
    //   (cd examples/sprite && ... check .)
    //   (cd examples && ... check sprite)
    let env_asset_root: Option<PathBuf> = env::var_os("NANO9_ASSETS").map(PathBuf::from);
    let script_asset_root: Option<PathBuf> = if input_path.exists() {
        // Local path
        if input_path.is_dir() {
            Some(input_path)
        } else {
            input_path.parent().map(|p| p.to_path_buf())
        }
    } else {
        None
    };

    let lookup = match (env_asset_root, script_asset_root) {
        (None, None) => Lookup::Default,
        (Some(path), None) => Lookup::One { path },
        (None, Some(path)) => Lookup::One { path },
        (Some(default), Some(script)) => Lookup::Two { default, script },
    };
    let mut app = App::new();
    let mut info_logs = vec![];
    match lookup {
        Lookup::One { ref path }
        | Lookup::Two {
            default: ref path, ..
        } => {
            let mut abs_path = invocation_dir.clone();
            abs_path.push(path);
            info_logs.push(format!(
                "The default assets directory: {:?}",
                abs_path.display()
            ));
            app.register_asset_source(
                &AssetSourceId::Default,
                AssetSourceBuilder::platform_default(
                    abs_path.to_str().expect("default asset dir"),
                    None,
                ),
            );
        }
        _ => (),
    }
    let input_asset_path_stripped: Option<AssetPath<'static>> = match lookup {
        Lookup::Default => None,
        Lookup::One { ref path } => {
            if let Ok(p) = script_path.strip_prefix(path) {
                Some(AssetPath::from_path(p).clone_owned())
            } else {
                None
            }
        }
        Lookup::Two {
            ref default,
            ref script,
        } => {
            if let Ok(p) = script_path.strip_prefix(default) {
                Some(AssetPath::from_path(p).clone_owned())
            } else if let Ok(p) = script_path.strip_prefix(script) {
                // Okay, we need this separate asset source.
                let mut abs_path = invocation_dir.clone();
                abs_path.push(script);
                info_logs.push(format!(
                    "The 'script_dir://' assets directory: {:?}",
                    abs_path.display()
                ));
                app.register_asset_source(
                    "script_dir",
                    AssetSourceBuilder::platform_default(
                        abs_path.to_str().expect("script dir"),
                        None,
                    ),
                );
                Some(
                    AssetPath::from_path(p)
                        .with_source(AssetSourceId::from("script_dir"))
                        .clone_owned(),
                )
            } else {
                None
            }
        }
    };

    let input_asset_path: AssetPath<'static> = match input_asset_path_stripped {
        Some(p) => p,
        None => {
            if let Some(s) = script_path.to_str() {
                match AssetPath::try_parse(s) {
                    Ok(p) => p.clone_owned(),
                    Err(e) => {
                        eprintln!("Cannot convert {:?} to input path: {e}", &s);
                        return Ok(ExitCode::from(9));
                    }
                }
            } else {
                eprintln!(
                    "Cannot convert input path to UTF-8 string {:?}.",
                    script_path.display()
                );
                return Ok(ExitCode::from(10));
            }
        }
    };

    app.add_plugins(Nano9Plugins);
    // We emit info logs now because the `LogPlugin` is now registered and they
    // will be seen. Before adding `Nano9Plugins` no `info!` lines will be
    // shown.
    for log in info_logs {
        info!("{}", &log);
    }

    let extension = script_path
        .extension()
        .and_then(|ext| ext.to_str())
        .unwrap_or_default();
    match extension {
        "p8" | "png" => {
            app.add_systems(
                Startup,
                move |asset_server: Res<AssetServer>, mut commands: Commands| {
                    let shared_data = shared_data.unwrap_or_default();
                    let pico8_asset: Handle<Pico8Asset> = asset_server.load_with_settings(
                        &input_asset_path,
                        move |settings: &mut CartLoaderSettings| {
                            settings.shared_data = shared_data;
                        },
                    );
                    commands.insert_resource(Pico8Handle::from(pico8_asset));
                },
            );
        }
        "toml" | "lua" | "p8lua" => {
            if cfg!(not(feature = "pico8-to-lua")) && extension == "p8lua" {
                eprintln!(
                    "error: Must compile with 'pico8-to-lua' feature to handle 'p8lua' files."
                );
                return Ok(ExitCode::from(3));
            }
            app.add_systems(Startup, load_and_insert_pico8(input_asset_path));
        }
        ext => {
            eprintln!(
                "error: File has {ext:?} extension but only accepts extensions: .p8, .png, .lua, .p8lua, and .toml."
            );
            return Ok(ExitCode::from(1));
        }
    }

    if pause {
        app.add_systems(PreUpdate, pause_pico8_when_loaded);
    } else {
        app.add_systems(PreUpdate, run_pico8_when_loaded);
    }

    if app.is_plugin_added::<WindowPlugin>() {
        app.add_systems(
            Update,
            action::toggle_fullscreen.run_if(condition::on_just_pressed_with(
                KeyCode::Enter,
                vec![KeyCode::AltLeft, KeyCode::AltRight],
            )),
        );
    }
    #[cfg(feature = "minibuffer")]
    app.add_plugins(nano9::minibuffer::quick_plugin);
    #[cfg(feature = "debugdump")]
    bevy_mod_debugdump::print_schedule_graph(&mut app, Update);

    #[cfg(all(feature = "level", feature = "user_properties"))]
    app.add_systems(Startup, |reg: Res<AppTypeRegistry>| {
        bevy_ecs_tiled::map::export_types(&reg, "all-export-types.json", |name| true);
        bevy_ecs_tiled::map::export_types(&reg, "export-types.json", |name| {
            name.contains("bevy_ecs_tilemap::tiles") || name.contains("nano9")
        });
    });
    let app_exit = if !check {
        app.run()
    } else {
        use bevy::app::PluginsState;

        while app.plugins_state() == PluginsState::Adding {
            #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
            bevy::tasks::tick_global_task_pools_on_main_thread();
        }

        app.finish();
        app.cleanup();

        app.update();
        app.should_exit().unwrap_or(AppExit::Success)
    };

    Ok(match app_exit {
        AppExit::Success => ExitCode::from(0),
        AppExit::Error(code) => ExitCode::from(code.get()),
    })
}