use tokio::signal::unix;

use tokio::time;

const ADV_INTERVAL: u64 = 1;

#[derive(Debug)]

enum VRRPv2State {

    Initialize,

    Backup,

    Master,

}

struct StateMachine {

    state: VRRPv2State,

}

impl StateMachine {

    fn new() -> Self {

        StateMachine {

            state: VRRPv2State::Initialize,

        }

    }

    fn transit_to(&mut self, new_state: VRRPv2State) {

        std::println!("vvrpd: {:?} -> {:?}", self.state, new_state);

        self.state = new_state;

    }

}

async fn advert_handler() {

    println!("advert timer fired");

}

async fn sighup_handler() {

    println!("got SIGHUP");

}

#[tokio::main(flavor = "current_thread")]

async fn main() {

    let advert_timer_handle = tokio::spawn(async move {

        let mut advert_interval = time::interval(time::Duration::from_secs(ADV_INTERVAL));

        loop {

            advert_interval.tick().await;

            advert_handler().await;

        }

    });

    let sighup_handle = tokio::spawn(async move {

        let mut stream =

            unix::signal(unix::SignalKind::hangup()).expect("Should be a signal stream");

        loop {

            stream.recv().await;

            sighup_handler().await;

        }

    });

    let mut sm = StateMachine::new();

    sm.transit_to(VRRPv2State::Master);

    sm.transit_to(VRRPv2State::Backup);

    tokio::try_join!(advert_timer_handle, sighup_handle).expect("task(s) erred");

}