mod barbfile;

use jsonformat::{format_json, Indentation};

use barbfile::BarbFile;

use clap::Parser;

use std::collections::HashMap;
use std::env;
use std::fs;
use std::str::FromStr;
use ureq;

struct Context {
    vars: HashMap<String, String>,
}

impl Context {
    pub fn new() -> Context {
        Context {
            vars: HashMap::new(),
        }
    }

    pub fn get_var(&self, name: String) -> Option<String> {
        self.vars
            .get(&name)
            .map(|val| val.clone())
            .or_else(|| env::var(name).ok())
    }

    pub fn execute(&self, bfile: BarbFile) -> String {
        let req = ureq::request(bfile.method_as_string().as_str(), &bfile.url());

        let resp = match bfile.method().takes_body() {
            true => match bfile.body() {
                Some(body) => req.send_string(body.as_str()),
                None => req.call(),
            },
            false => req.call(),
        };

        resp.unwrap().into_string().unwrap()
    }
}

#[derive(Parser, Debug)]
#[clap(version)]
struct Args {
    #[clap(short, long)]
    headers: bool,
    #[clap(short, long)]
    body: bool,
    #[clap(short, long)]
    raw: bool,
    files: Vec<String>,
}

fn main() {
    let args = Args::parse();

    let mut context = Context::new();
    let bfile = BarbFile::from_str(
        fs::read_to_string("test-post.barb")
            .expect("Failed to read file")
            .as_str(),
    )
    .expect("Failed to parse file");
    let result = context.execute(bfile);

    println!("{}", format_json(result.as_str(), Indentation::Default));
}