#![allow(dead_code)]
use std::collections::HashMap;

pub struct Object(HashMap<String, Json>);
pub struct Array(Vec<Json>);

pub enum Json {
    Bool(bool),
    Object(Object),
    Array(Array),
    Number(f64),
    String(String),
    Null
}

pub enum JsonError<'a> {
	InvalidTokenErr(&'a str),
	ExpectedValueErr(&'a str),
	ObjectExpectedValueErr(&'a str),
	ObjectInvalidKeyErr(&'a str),
	MaxDepthErr(&'a str),
	InvalidNumberErr(&'a str),
	InvalidStringErr(&'a str),
	StringInvalidEscapeErr(&'a str),
	StringInvalidUnicodeErr(&'a str),
	StringInvalidErr(&'a str),
}

fn skip_ws(raw_json: &str) -> &str {
    let non_ws = raw_json.find(|chr: char| !chr.is_whitespace()).unwrap_or(raw_json.len());
    &raw_json[non_ws..]
}

impl Json {
    pub fn parse(raw_json: &str) -> Result<Json, JsonError> {
        todo!()
    }

    fn parse_value(raw: &str) -> Result<(&str, Json), JsonError> {
        let raw = skip_ws(raw);
        match raw.chars().next() {
            Some('"') => Json::parse_string(raw),
            Some('{') => Json::parse_object(raw),
            Some('[') => Json::parse_array(raw),
            Some(_) => Json::parse_literal(raw),
            None => return Err(JsonError::StringInvalidErr(raw))
        }
    }

    fn parse_object(raw: &str) -> Result<(&str, Json), JsonError> {
        let mut empty = true;
        let raw = skip_ws(raw);

        'outer: loop {
            for chr in raw.chars() {
            }
        }

        todo!()
    }
    fn parse_array(raw: &str) -> Result<(&str, Json), JsonError> {
        todo!()
    }
    fn parse_string(raw: &str) -> Result<(&str, Json), JsonError> {
        todo!()
    }
    fn parse_literal(raw: &str) -> Result<(&str, Json), JsonError> {
        todo!()
    }
}