use std::sync::{Arc, Mutex};

use diesel::{RunQueryDsl, SqliteConnection};
use toggl_api::{Timestamp, Toggl};

use crate::model::ServerTimeEntry;

pub(crate) struct Daemon {
    api: Toggl,
    last_sync: Option<Timestamp>,
    db: Arc<Mutex<SqliteConnection>>,
}

impl Daemon {
    pub(crate) fn new(api: Toggl, db: Arc<Mutex<SqliteConnection>>) -> Self {
        Self {
            api,
            last_sync: None,
            db,
        }
    }
    pub(crate) async fn sync(&mut self) -> Result<(), ()> {
        let (data, new_last_sync) = self.api.all_data(self.last_sync).await?;

        let mut db = self.db.lock().unwrap();

        let entries_cnt = data.time_entries.len();
        if entries_cnt > 0 {
            println!("Downloading {} time entries...", entries_cnt);
        }

        for time_entry in data.time_entries {
            let time_entry: ServerTimeEntry = time_entry.into();
            {
                use crate::schema::time_entries::dsl::*;
                diesel::insert_into(time_entries)
                    .values(&time_entry)
                    .on_conflict(server_id)
                    .do_update()
                    .set(&time_entry)
                    .execute(&mut *db)
                    .unwrap();
            }
        }
        self.last_sync = Some(new_last_sync);
        Ok(())
    }
}