use std::rc::{Rc, Weak};
use std::any::Any;
use std::cell::RefCell;
use std::time::{Instant};
use r9::xtimer::{TimerCb, XTimerWp, XTimerAttacherRp, TimerEvent};
use r9_macro::SharedFromSelf;
use r9_macro_derive::SharedFromSelf;

pub type TimerWp = XTimerWp;
pub type TimerAttacherRp = XTimerAttacherRp;

#[derive(SharedFromSelf)]
pub struct Timer {
    base: Rc::<RefCell::<r9::xtimer::XTimer>>,
    _self_wp: Weak::<RefCell::<Self>>,
}

impl Timer {

    pub fn instance() -> Rc::<RefCell::<Self>> {
        static mut _INSTANCE: Option<Rc::<RefCell::<Timer>>> = None;
        unsafe {
            match &_INSTANCE {
                Some(v) => {
                    return v.clone();
                }
                None => {
                    _INSTANCE = Some(Rc::new(RefCell::new(
                        Timer{
                            base: r9::xtimer::XTimer::new(),
                            _self_wp: Default::default(),
                        }
                    )));
                    _INSTANCE.clone().unwrap().borrow_mut()._self_wp =
                        Rc::downgrade(&_INSTANCE.clone().unwrap());
                }
            }
            return _INSTANCE.clone().unwrap().clone();
        }
    }

    pub fn init(&mut self) {
        let now = Instant::now();
        self.base.borrow_mut().init
            (
                Box::new(
                    move || -> i64 {
                        //println!("tick:{}", now.elapsed().as_millis());
                        return now.elapsed().as_millis() as i64;
                    }
                ),
                10,
                10
            );
    }

    pub fn uninit(&mut self) {
        self.base.borrow_mut().uninit();
    }

    pub fn update(&mut self) {
        r9::xtimer::XTimer::update(&self.base);
        //return self.base.borrow_mut().update();
    }

    pub fn set_timeout(&mut self, time: i32, cb: TimerCb) -> TimerWp {
        return self.base.borrow_mut().set_timeout(time, cb);
    }

    pub fn set_timeout_ex
        (&mut self, time: i32, cb: TimerCb, attacher: TimerAttacherRp) -> TimerWp {
        return self.base.borrow_mut().set_timeout_ex(time, cb, attacher);
    }

    pub fn set_interval(&mut self, time: i32, cb: TimerCb) -> TimerWp {
        return self.base.borrow_mut().set_interval(time, cb);
    }

    pub fn set_interval_ex
        (&mut self, time: i32, cb: TimerCb, attacher: TimerAttacherRp) -> TimerWp {
        return self.base.borrow_mut().set_interval_ex(time, cb, attacher);
    }

    pub fn fire_event(&mut self,
                      timer_wp: TimerWp,
                      e: TimerEvent,
                      args: Option<Vec<Rc::<dyn Any>>>) {
        return self.base.borrow_mut().fire_event(timer_wp, e, args);
    }

    pub fn modify(&mut self, timer_wp: TimerWp, expire_time: i32) {
        self.base.borrow_mut().modify(timer_wp, expire_time);
    }

    pub fn delete_current_timer(&mut self) {
        self.base.borrow_mut().delete_current_timer();
    }

    pub fn is_running(&self) -> bool {
        return self.base.borrow().is_running();
    }

    pub fn delete(&mut self, timer_wp: TimerWp) {
        self.base.borrow_mut().delete(timer_wp);
    }

    pub fn get_remain_time(&mut self, timer_wp: TimerWp) -> i64 {
        return self.base.borrow_mut().get_remain_time(timer_wp);
    }

    pub fn get_idle_time(&self) -> i64 {
        return self.base.borrow().get_idle_time();
    }

}