use std::env;
use std::str::{self, FromStr};

pub trait Parsable {
    fn parse(s: &str) -> Self;
}

impl<T: Parsable> Parsable for Vec<T> {
    fn parse(s: &str) -> Vec<T> {
        let mut depth = 0;
        let mut sep = Vec::new();
        let s = s
            .trim()
            .strip_prefix("[")
            .expect("Missing [")
            .strip_suffix("]")
            .expect("Missing ]");
        let mut last = 0;
        for (i, c) in s.chars().enumerate() {
            if c == '[' {
                depth += 1;
            } else if c == ']' {
                if depth == 0 {
                    panic!("Invalid array format");
                }
                depth -= 1;
            } else if c == ',' && depth == 0 {
                sep.push((last, i));
                last = i + 1;
            }
        }
        if last != s.len() {
            sep.push((last, s.len()));
        }
        let mut out = Vec::new();
        for (start, end) in sep {
            out.push(parse(s[start..end].trim()));
        }
        out
    }
}

impl Parsable for i32 {
    fn parse(s: &str) -> i32 {
        i32::from_str(s).unwrap_or_else(|_| panic!("Failed to parse integer ({s})"))
    }
}

impl Parsable for char {
    fn parse(s: &str) -> char {
        s.chars()
            .next()
            .unwrap_or_else(|| panic!("Parsing empty string"))
    }
}

pub fn parse<T: Parsable>(s: &str) -> T {
    <T as Parsable>::parse(s)
}

pub fn vc(s: &str) -> Vec<char> {
    parse(s)
}

pub fn vvc(s: &str) -> Vec<Vec<char>> {
    parse(s)
}

pub fn vi(s: &str) -> Vec<i32> {
    parse(s)
}

pub fn vvi(s: &str) -> Vec<Vec<i32>> {
    parse(s)
}

pub fn arg(n: usize) -> String {
    env::args()
        .nth(n)
        .unwrap_or_else(|| panic!("Failed to get argument ({n})"))
}

pub fn arg_into<T: Parsable>(n: usize) -> T {
    <T as Parsable>::parse(arg(n).as_str())
}