use clap::{Parser, Subcommand};
mod core;
#[derive(Parser)]
struct CLI {
    #[clap(subcommand)]
    command: Commands,
}
#[derive(Subcommand)]
enum Commands {
    New {
        #[clap(short, long)]
        author: Option<String>,
        name: String,
    },
}
#[tokio::main]
async fn main() {
    let cli = CLI::parse();
    //handle subcommands
    match cli.command {
        Commands::New { author, name } => {
            let author = if let Some(a) = author {
                a
            } else {
                //TODO: Attempt to load from config, or else fail
                String::new()
            };
            core::create(author, name);
        }
    }
    println!("Hello, world!");
}

use anyhow::{Context, Result};
use regex::Regex;
use serde::{Deserialize, Serialize};
use std::{fmt::Display, fs, str::FromStr};
use super::FILE_NAME;
#[derive(Deserialize, Serialize, Debug, Clone, Default)]
pub(crate) struct Index {
    pub(crate) mods: Vec<Mod>,
}
impl Index {
    pub fn read() -> Result<Self> {
        let p = std::env::current_dir()?.join(FILE_NAME);
        if let Ok(raw) = fs::read_to_string(&p) {
            ron::from_str(&raw).context("Unable to parse index")
        } else {
            Ok(Index::default())
        }
    }
    pub fn write(&self) -> Result<()> {
        let cfg = ron::ser::PrettyConfig::new().compact_arrays(true);
        let p = std::env::current_dir()?.join(FILE_NAME);
        let raw = ron::ser::to_string_pretty(self, cfg)?;
        fs::write(&p, &raw).context("Failed to write index")?;
        Ok(())
    }
}
#[derive(Deserialize, Serialize, Debug, Clone)]
pub(crate) struct Mod {
    name: String,
    author: String,
    version: Version,
}
impl Mod {
    pub(crate) fn new(author: String, name: String, version: String) -> Self {
        Mod {
            author,
            name,
            version: version.parse::<Version>().unwrap(),
        }
    }
}
#[derive(Deserialize, Serialize, Debug, Clone)]
struct Version {
    major: u8,
    minor: u8,
    patch: u8,
}
impl FromStr for Version {
    type Err = String;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let re = Regex::new(r"(\d+)\.(\d+)\.(\d+)").unwrap();
        if let Some(c) = re.captures(s) {
            let major = c.get(1).unwrap().as_str().parse::<u8>().unwrap();
            let minor = c.get(2).unwrap().as_str().parse::<u8>().unwrap();
            let patch = c.get(3).unwrap().as_str().parse::<u8>().unwrap();
            Ok(Version {
                major,
                minor,
                patch,
            })
        } else {
            Err(String::from("Unable to parse version"))
        }
    }
}
impl Display for Version {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}.{}.{}", self.major, self.minor, self.patch)
    }
}

pub(crate) const FILE_NAME: &'static str = "mrvn.ron";
mod model;
use model::Index;
use self::model::Mod;
///Create a mod in the current directory
pub fn create(author: String, name: String) {
    let root = std::env::current_dir().unwrap();
    let mod_dir = root.join(format!("{}.{}", author, name));
    let mut mrvnfile = Index::read().unwrap();
    mrvnfile
        .mods
        .push(Mod::new(author, name, "0.1.0".to_owned()));
    mrvnfile.write().unwrap();
}

{
   "name": "Yourname.Modname",
   "Description": "Woo yeah wooo!",
   "LoadPriority": 0,
   "ConVars": [],
   "Scripts": [],
   "Localisation": []
}