mod api;
mod cmd;
mod config;
mod errors;

use api::API;
use chrono::NaiveDateTime;
use cmd::*;
use config::Config;
use errors::GenericError;
use std::fs::File;
use std::io::prelude::*;
use std::sync::mpsc::TryRecvError;

fn main() {
    let env: EnvOpt = argh::from_env();
    if let Err(e) = from_env(env) {
        eprintln!("Error: {:?}", e);
        std::process::exit(1);
    }
}

fn from_env(env: EnvOpt) -> Result<(), GenericError> {
    match env.subcommand {
        Subcommand::Run(opt) => {
            let mut file = File::open("config.toml")?;
            let mut string = String::new();
            file.read_to_string(&mut string)?;

            let config: Config = toml::from_str(&string)?;

            run(
                &config,
                Some("1.1.2019 00:00:00".to_owned()),
                Some("1.5.2020 00:00:00".to_owned()),
            )?;
            Ok(())
        }
        Subcommand::Init(opt) => {
            let config = Config::default();

            let mut file = File::create("config.toml").unwrap();
            file.write_all(&toml::to_vec(&config).unwrap())?;
            Ok(())
        }
    }
}

fn run(config: &Config, from: Option<String>, to: Option<String>) -> Result<(), GenericError> {
    let mut api = API::new(config.clone());

    let from = get_opt(from.map(|f| NaiveDateTime::parse_from_str(&f, &config.between_format)))?;
    let to = get_opt(to.map(|t| NaiveDateTime::parse_from_str(&t, &config.between_format)))?;

    let tags = api.get_tags()?;
    let first_tag = tags[0].id.clone().unwrap();
    let state_list = api.get_states(&first_tag)?;

    let states = API::get_between(state_list.clone(), from, to, true, &config);

    //let mut locations = Vec::new();
    for (_, state) in states.iter() {
        api.queue_location(&first_tag, state.id.as_ref().unwrap());
    }
    let receiver = api.begin_location_fetch();
    loop {
        match receiver.try_recv() {
            Ok(res) => match res {
                Ok(loc) => {
                    let mut loc = loc;
                    println!("Received! {}", loc);
                    //locations.append(&mut loc);
                }
                Err(e) => eprintln!("{:?}", e),
            },
            Err(e) => {
                if let TryRecvError::Disconnected = e {
                    break;
                }
            }
        }
    }

    //dbg!(API::get_between(locations, from, to, false, &config));
    Ok(())
}

fn get_opt<A, B>(option: Option<Result<A, B>>) -> Result<Option<A>, B> {
    if let Some(res) = option {
        match res {
            Ok(a) => Ok(Some(a)),
            Err(b) => Err(b),
        }
    } else {
        Ok(None)
    }
}

fn exp_time(api: &API, reqs_left: u32) -> f32 {
    (reqs_left * api.last_response_ping) as f32 / 1000.
}