#[macro_use]
extern crate diesel;

use chrono::{DateTime, Duration, Utc};
use diesel::prelude::*;
use diesel::sqlite::SqliteConnection;
use diesel::Connection;
use std::io;

mod maxmin;
mod models;
mod schema;
mod device;

use self::maxmin::*;
use self::models::*;
use self::device::DeviceResponse;

fn open_database(db_filename: &str) -> io::Result<SqliteConnection> {
    SqliteConnection::establish(db_filename).map_err(|e| io::Error::new(io::ErrorKind::Other, e))
}

fn main() -> io::Result<()> {
    use self::schema::data::dsl::*;
    use self::schema::devices::dsl::*;

    dotenv::dotenv().ok();
    env_logger::init();

    let db_path = std::env::var("DATABASE_URL").expect("Missing DATABASE env variable");
    let given_device_id = std::env::var("DEVICE_ID").expect("Missing DEVICE_ID env variable");

    let mut db = open_database(&db_path)?;

    let start_time = Utc::now() - Duration::days(90);
    let data_records = data
        .filter(timestamp.ge(start_time.naive_utc()).and(self::schema::data::dsl::device_id.eq(&given_device_id)))
        .load::<Datapoint>(&mut db)
        .expect("Error loading data");

    let mut resp = DeviceResponse::new(given_device_id);

    println!(
        "{:<40}\t{:>8}\t{:<20?}\t{:<40}",
        "timestamp",
        "value",
        "water_level",
        "last_watered");

    for (i, record) in data_records.iter().enumerate() {
        let previous_last_watered = resp.last_watered();

        resp.calculate_status(&data_records[0..i]);

        let flag = if resp.last_watered() != previous_last_watered {
            "******"
        } else if record.value < 12000.0 {
            "^^^^^"
        } else {
            ""
        };

        println!(
            "{:<40}\t{:>8}\t{:<20?}\t{:<40?} {}",
            record.timestamp,
            record.value,
            resp.water_level(),
            resp.last_watered(),
            flag,
            );
    }

    Ok(())
}