oxwm

use oxwm::errors::ConfigError;

use oxwm::errors::MainError;

use std::path::Path;

use std::path::PathBuf;

const CONFIG_FILE: &str = "config.lua";

const TEMPLATE: &str = include_str!("../../templates/config.lua");

enum Args {

    Exit,

    Arguments(Vec<String>),

    Error(MainError),

}

fn main() -> Result<(), MainError> {

    let arguments = match process_args() {

        Args::Exit => return Ok(()),

        Args::Arguments(v) => v,

        Args::Error(e) => return Err(e),

    };

    let (config, config_warning) = load_config(arguments.get(2))?;

    let mut window_manager = match oxwm::window_manager::WindowManager::new(config) {

        Ok(wm) => wm,

        Err(e) => return Err(MainError::CouldNotStartWm(e)),

    };

    if let Some(warning) = config_warning {

        window_manager.show_startup_config_error(warning);

    }

    if let Err(e) = window_manager.run() {

        return Err(MainError::WmError(e));

    }

    Ok(())

}

fn load_config(

    config_path: Option<&String>,

) -> Result<(oxwm::Config, Option<ConfigError>), MainError> {

    let path = match config_path {

        None => {

            let config_dir = get_config_path()?;

            let config_path = config_dir.join(CONFIG_FILE);

            check_convert(&config_path)?;

            config_path

        }

        Some(p) => PathBuf::from(p),

    };

    let config_string = match std::fs::read_to_string(&path) {

        Ok(c) => c,

        Err(e) => return Err(MainError::FailedReadConfig(e)),

    };

    let config_directory = path.parent();

    let (mut config, config_warning) =

        match oxwm::config::parse_lua_config(&config_string, config_directory) {

            Ok(config) => (config, None),

            Err(warning) => {

                let config = match oxwm::config::parse_lua_config(TEMPLATE, None) {

                    Ok(c) => c,

                    Err(e) => return Err(MainError::FailedReadConfigTemplate(e)),

                };

                (config, Some(warning))

            }

        };

    config.path = Some(path);

    Ok((config, config_warning))

}

fn init_config() -> Result<(), MainError> {

    let config_directory = get_config_path()?;

    if let Err(e) = std::fs::create_dir_all(&config_directory) {

        return Err(MainError::CouldNotCreateConfigDir(e));

    }

    let config_template = TEMPLATE;

    let config_path = config_directory.join(CONFIG_FILE);

    if let Err(e) = std::fs::write(&config_path, config_template) {

        return Err(MainError::CouldNotWriteConfig(e));

    }

    println!("✓ Config created at {:?}", config_path);

    println!("  Edit the file and reload with Mod+Shift+R");

    println!("  No compilation needed - changes take effect immediately!");

    Ok(())

}

fn get_config_path() -> Result<PathBuf, MainError> {

    match dirs::config_dir() {

        Some(p) => Ok(p.join("oxwm")),

        None => Err(MainError::NoConfigDir),

    }

}

fn print_help() {

    println!("OXWM - A dynamic window manager written in Rust\n");

    println!("USAGE:");

    println!("    oxwm [OPTIONS]\n");

    println!("OPTIONS:");

    println!("    --init              Create default config in ~/.config/oxwm/config.lua");

    println!("    --config <PATH>     Use custom config file");

    println!("    --version           Print version information");

    println!("    --help              Print this help message\n");

    println!("CONFIG:");

    println!("    Location: ~/.config/oxwm/config.lua");

    println!("    Edit the config file and use Mod+Shift+R to reload");

    println!("    No compilation needed - instant hot-reload!");

    println!("    LSP support included with oxwm.lua type definitions\n");

    println!("FIRST RUN:");

    println!("    Run 'oxwm --init' to create a config file");

    println!("    Or just start oxwm and it will create one automatically\n");

}

fn process_args() -> Args {

    let mut args = std::env::args();

    let name = match args.next() {

        Some(n) => n,

        None => return Args::Error(MainError::NoProgramName),

    };

    let switch = args.next();

    let path = args.next();

    let switch = match switch {

        Some(s) => s,

        None => return Args::Arguments(vec![name]),

    };

    match switch.as_str() {

        "--version" => {

            println!("{name} {}", env!("CARGO_PKG_VERSION"));

            Args::Exit

        }

        "--help" => {

            print_help();

            Args::Exit

        }

        "--init" => match init_config() {

            Ok(_) => Args::Exit,

            Err(e) => Args::Error(e),

        },

        "--config" => match check_custom_config(path) {

            Ok(p) => Args::Arguments(vec![name, switch, p]),

            Err(e) => Args::Error(e),

        },

        _ => Args::Error(MainError::InvalidArguments),

    }

}

fn check_custom_config(path: Option<String>) -> Result<String, MainError> {

    let path = match path {

        Some(p) => p,

        None => {

            return Err(MainError::NoConfigPath);

        }

    };

    match std::fs::exists(&path) {

        Ok(b) => match b {

            true => Ok(path),

            false => Err(MainError::BadConfigPath),

        },

        Err(e) => Err(MainError::FailedCheckExist(e)),

    }

}

fn check_convert(path: &Path) -> Result<(), MainError> {

    let config_directory = get_config_path()?;

    if !path.exists() {

        let ron_path = config_directory.join("config.ron");

        let had_ron_config = ron_path.exists();

        println!("No config found at {:?}", config_directory);

        println!("Creating default Lua config...");

        init_config()?;

        if had_ron_config {

            println!("\n NOTICE: OXWM has migrated to Lua configuration.");

            println!("   Your old config.ron has been preserved, but is no longer used.");

            println!("   Your settings have been reset to defaults.");

            println!("   Please manually port your configuration to the new Lua format.");

            println!("   See the new config.lua template for examples.\n");

        }

    }

    Ok(())

}