use chrono::{DateTime, Utc};
use serde::Serialize;
use tokio::time;

use kairo_common::Point;

use crate::Config;

#[derive(Debug, Serialize)]
pub struct Error {
    error: f64,
    speed: f64,
    time: DateTime<Utc>,
}
#[allow(dead_code)]
pub async fn thread(config: Config) {
    let period = time::Duration::from_millis(500);

    let mut position = Point::new(config.radius, 0.0);
    let mut speed = position;
    position.rotate_by(f64::to_radians(config.angle_step));
    speed -= position;

    let _speed = speed.module();

    loop {
        let start = time::Instant::now();

        // let real = KnownPosition::get_last_for("real", 1).await;
        // let calc = KnownPosition::get_last_for(config.id.as_str(), 1).await;
        // if real.is_ok() && calc.is_ok() {
        //     let real = real.unwrap();
        //     let calc = calc.unwrap();

        //     if real.is_some() && calc.is_some() {
        //         let real = real.unwrap();
        //         let calc = calc.unwrap();
        //         #[allow(non_snake_case)]
        //         let Δx = real.x - calc.x;
        //         #[allow(non_snake_case)]
        //         let Δy = real.y - calc.y;
        //         let error = Error {
        //             speed,
        //             error: f64::sqrt(Δx.powi(2) + Δy.powi(2)),
        //             time: chrono::Utc::now(),
        //         };

        // let table_name = format!("error_{}", config.id.as_str());
        // get_influx_cli()
        //     .query(error.into_query(table_name.as_str()))
        //     .await
        //     .unwrap();
        // }
        time::sleep(period - start.elapsed()).await;
        // }
    }
}