#![allow(dead_code)]

use std::io;
use std::io::Write;

#[derive(Debug)]
enum ParameterType {
    Operational,
    UI,
    Tool
}

#[derive(Debug)]
struct PluginConfig {
    name: String
}

#[derive(Debug)]
enum Value {
    Instruction(String),
    Asset(String),
    Plugin(PluginConfig)
}

#[derive(Debug)]
struct Parameter {
    key: String,
    category: ParameterType,
    value: Value
}

struct Jarvis {
    name: String,
    cpu_usage: i32,
    config: Vec<Parameter>
}

impl Jarvis {
    fn create() -> Jarvis {
        let new_instance = Jarvis {
            name: "Jarvis coding assistant".to_string(),
            cpu_usage: 125,
            config: vec![]
        };

        new_instance
    }

    fn default_config(&mut self) {
        let tone_value = Value::Asset("Positive".to_string());
        let tone = Parameter {
            key: "Tone".to_string(),
            category: ParameterType::UI,
            value: tone_value
        };

        self.config.push(tone);
    }

    fn operate(&self) {
        println!("Hello Sr. Stark");
        println!("Stats: ");
        println!("\tname: {}", self.name);
        println!("\tcpu usage: {}", self.cpu_usage);
        println!("\tconfig: {:?}", self.config);
        println!("How can I help you?");
        print!("=>> ");
        io::stdout().flush().expect("Failed to flush stdout");
        let mut prompt = String::new();
        io::stdin().read_line(&mut prompt).expect("failed to readline");

        

        println!("Exiting....");
    }
}

fn main() {
    let mut jarvis = Jarvis::create();

    jarvis.default_config();
    jarvis.operate();
}