/// Commandline program testing csv imports
use serde::Deserialize;
use std::env;
use std::{
     error::Error,
     io,
//     process,
//     thread,
    //     time::{Duration, Instant}
};
use tracing::{debug, trace, Level};

mod parse_args;

#[derive(Debug, Deserialize)]
struct Environment {
    test_lang: String,
}

#[derive(Debug, Deserialize)]
pub struct CsvImportRecord {
    // dion               => Allianz Dion: 1
    // policy_code        => Policy Typ: "AS"
    // policy_number      => Versicherungsscheinnummer: "1515735810"
    pub dion: String,
    pub policy_code: String,
    pub policy_number: u32,
}

/// import from csv format (Standard in)
fn import() -> Result<(), Box<dyn Error>> {
    // Build the CSV reader and iterate over each record.
    let mut csv_reader = csv::Reader::from_reader(io::stdin());
    for result in csv_reader.deserialize() {
        // The iterator yields Result<StringRecord, Error>, so we check the
        // error here.
        let record: CsvImportRecord = result?;
        println!("{:?}", record);
    }
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use dotenv::dotenv;
    use parse_args::parse_args;
    use locales::t;
    //use std::process;
    //use std::sync::Arc;
    use tracing_subscriber::fmt;
    use viperus::Viperus;

    //static DEFAULT_FILTER: &str = concat!(module_path!(), "=", "trace");

    // initialize the tracing subsystem
    // a drop in replacement for classical logging
    // reference: https://tokio.rs/blog/2019-08-tracing/
    let span = tracing::span!(Level::TRACE, "csv-import");
    let _enter = span.enter();
    let subscriber = fmt::Subscriber::builder()
        .with_env_filter("trace")
        //.with_max_level(tracing::Level::DEBUG)
        .finish();

    // initialize logger
    //env_logger::init();
    //info!("Commencing the import Test-Run!");

    tracing::subscriber::with_default(subscriber, || {
        // get system environment
        let mut lang = env::var("LANG").unwrap_or("en".to_string());
        let mut res = t!("parse.environment", lang);
        let mut state = t!("state.started", lang);
        trace!(target: "csv-import", message = ?res, state = ?state);
        //debug!(message = ?res, state = ?state);
        trace!(target: "csv-import", environment = "system", lang = ?lang);

        // get testing environment (.env)
        dotenv().ok();
        match envy::from_env::<Environment>() {
            Ok(environment) => {
                if environment.test_lang != lang { lang = environment.test_lang; }
            },
            Err(e) => { debug!(target: "csv-import", "{}", e); }
        }
        res = t!("parse.environment", lang);
        trace!(target: "csv-import", environment = "envy", lang = ?lang);
        state = t!("state.finished", lang);
        trace!(target: "csv-import", message = ?res, state = ?state);

        // initialize viperus structure
        let mut v = Viperus::new();

        // parse commandline arguments
        res = t!("parse.arguments", lang);
        state = t!("state.started", lang);
        trace!(target: "csv-import", process = ?res, state = ?state);

        let _ = parse_args(&mut v);
        state = t!("state.finished", lang);
        trace!(target: "csv-import", process = ?res, state = ?state);
        //trace!(target: "Viperus", "Config results: {:?}", v);

        // Starting the program logic
        res = t!("main.started", lang);
        state = t!("state.started", lang);
        trace!(target: "csv-import", process = ?res, state = ?state);

        // import the given import file
        let csv_file = v.get::<String>("import_file").unwrap();

        state = t!("state.finished", lang);
        res = t!("main.finished", lang);
        trace!(target: "csv-import", process = ?res, state = ?state);
    });

    Ok(())
}