use local_ip_address::local_ip;
use std::sync::{Arc, Mutex};
use tide::prelude::*;
use tide::Request;

use lcd_writer::lcd::Lcd;

#[derive(Clone)]
struct App {
    values: Vec<i32>,
    lcd: Arc<Mutex<Lcd>>,
}

impl App {
    fn new(lcd: Lcd) -> Self {
        App {
            values: Vec::new(),
            lcd: Arc::new(Mutex::new(lcd)),
        }
    }
}

#[derive(Debug, Deserialize)]
struct Sample {
    value: i32,
}

#[async_std::main]
async fn main() -> tide::Result<()> {
    let lcd = Lcd::new()?;
    let mut app = tide::with_state(App::new(lcd));
    app.at("/sample").post(send_sample);
    if let Ok(ip) = local_ip() {
        println!("Starting server at {ip}:8000!");
    } else {
        println!("Starting server on port 8000. Could not get IP");
    }
    app.listen("0.0.0.0:8000").await?;
    Ok(())
}

async fn send_sample(mut req: Request<App>) -> tide::Result {
    let Sample { value } = req.body_json().await?;

    let lcd = req.state().lcd.lock()?;
    lcd.clear();
    lcd.set_cursor(0, 0);
    lcd.write(format!("Value: {}", value).as_str());

    req.state().values.push(value);

    println!("Ok, value: {}", value);
    Ok(format!("Ok, value: {}", value).into())
}