use async_std::task;
use std::time::{Duration, SystemTime};

use super::register::register_tasks;

// Usage : 
//
// interval:
//   - time interval between executions
//   - 0 seconds to only execute on startup
//
// last_exec:
//   - time of last execution, should be 0 by default
//
// name : 
//   - name of the task that will be displayed in the logs
//
// f :
//   - function that will be executed


pub struct ScheduledTaskInfo {
    interval: Duration,
    last_exec: Option<SystemTime>,
    name : String,
    f: fn(bool)
}

#[allow(dead_code)]
impl ScheduledTaskInfo {
    pub fn every_second(task_list: &mut Vec<ScheduledTaskInfo>, name: String, function: fn(bool)) {
        task_list.push( ScheduledTaskInfo { interval:  Duration::from_secs(1) , last_exec : None, name: name, f : function });
    }
    pub fn every_ten_seconds(task_list: &mut Vec<ScheduledTaskInfo>, name: String, function: fn(bool)) {
        task_list.push( ScheduledTaskInfo { interval:  Duration::from_secs(10) , last_exec : None, name: name, f : function });
    }
    pub fn every_half_minute(task_list: &mut Vec<ScheduledTaskInfo>, name: String, function: fn(bool)) {
        task_list.push( ScheduledTaskInfo { interval:  Duration::from_secs(30) , last_exec : None, name: name, f : function });
    }
    pub fn every_minute(task_list: &mut Vec<ScheduledTaskInfo>, name: String, function: fn(bool)) {
        task_list.push( ScheduledTaskInfo { interval:  Duration::from_mins(1) , last_exec : None, name: name, f : function });
    }
    pub fn every_fifteen_minutes(task_list: &mut Vec<ScheduledTaskInfo>, name: String, function: fn(bool)) {
        task_list.push( ScheduledTaskInfo { interval:  Duration::from_mins(15) , last_exec : None, name: name, f : function });
    }
    pub fn every_half_hour(task_list: &mut Vec<ScheduledTaskInfo>, name: String,  function: fn(bool)) {
        task_list.push( ScheduledTaskInfo { interval:  Duration::from_mins(30) , last_exec : None, name: name, f : function });
    }
    pub fn every_hour(task_list: &mut Vec<ScheduledTaskInfo>, name: String, function: fn(bool)) {
        task_list.push( ScheduledTaskInfo { interval:  Duration::from_hours(1) , last_exec : None, name: name, f : function });
    }
    pub fn every_day(task_list: &mut Vec<ScheduledTaskInfo>, name: String, function: fn(bool)) {
        task_list.push( ScheduledTaskInfo { interval:  Duration::from_hours(24) , last_exec : None, name: name, f : function });
    }
    pub fn every_week(task_list: &mut Vec<ScheduledTaskInfo>, name: String, function: fn(bool)) {
        task_list.push( ScheduledTaskInfo { interval:  Duration::from_hours(24 * 7) , last_exec : None, name: name, f : function });
    }
    pub fn every_interval(task_list: &mut Vec<ScheduledTaskInfo>, name: String,  function: fn(bool), interval: Duration) {
        task_list.push( ScheduledTaskInfo { interval:  interval , last_exec : None, name: name, f : function });
    }
    
    pub fn on_load(task_list: &mut Vec<ScheduledTaskInfo>, name: String, function: fn(bool)) {
        task_list.push( ScheduledTaskInfo { interval: Duration::from_secs(0), last_exec: None, name, f: function } );
    }
}

pub async fn scheduled_tasks_loop() {
    let mut tasks = register_tasks();
    loop {
        task::sleep(Duration::from_secs(1)).await;


        for task in &mut tasks {
            let mut first_exec = false;

            if let Some(last_exec) = task.last_exec {
                if(task.interval == Duration::from_secs(0)) {
                    continue ;
                }
            }

            let should_exec = match task.last_exec {
                Some(time) => SystemTime::now().duration_since(time).expect("how ???") >= task.interval,
                None => { first_exec = true; true }
            };

            if should_exec {
                tracing::info!("running task {}", task.name);
                (task.f)(first_exec);
                task.last_exec = Some(SystemTime::now());
            }
        }
    }
}