use crate::callback::CallbackSubscription;
use crate::callback::Consumer;
use crate::result::OtherError;
use crate::result::TockResult;
use crate::syscalls;
use core::marker::PhantomData;

const DRIVER_NUMBER: usize = 0x00003;

mod command_nr {
    pub const COUNT: usize = 0;
    pub const ENABLE_INTERRUPT: usize = 1;
    pub const DISABLE_INTERRUPT: usize = 2;
    pub const READ: usize = 3;
}

mod subscribe_nr {
    pub const SUBSCRIBE_CALLBACK: usize = 0;
}

#[non_exhaustive]
pub struct ButtonsDriverFactory;

impl ButtonsDriverFactory {
    pub fn init_driver(&mut self) -> TockResult<ButtonsDriver> {
        let buttons_driver = ButtonsDriver {
            num_buttons: syscalls::command(DRIVER_NUMBER, command_nr::COUNT, 0, 0)?,
            lifetime: PhantomData,
        };
        Ok(buttons_driver)
    }
}

pub struct ButtonsDriver<'a> {
    num_buttons: usize,
    lifetime: PhantomData<&'a ()>,
}

impl<'a> ButtonsDriver<'a> {
    pub fn num_buttons(&self) -> usize {
        self.num_buttons
    }

    pub fn get(&self, button_num: usize) -> Option<Button> {
        if button_num < self.num_buttons {
            Some(Button {
                button_num,
                lifetime: PhantomData,
            })
        } else {
            None
        }
    }

    pub fn buttons(&self) -> Buttons {
        Buttons {
            num_buttons: self.num_buttons,
            curr_button: 0,
            lifetime: PhantomData,
        }
    }

    pub fn subscribe<CB: Fn(usize, ButtonState)>(
        &self,
        callback: &'a mut CB,
    ) -> TockResult<CallbackSubscription> {
        syscalls::subscribe::<ButtonsEventConsumer, _>(
            DRIVER_NUMBER,
            subscribe_nr::SUBSCRIBE_CALLBACK,
            callback,
        )
        .map_err(Into::into)
    }
}

struct ButtonsEventConsumer;

impl<CB: Fn(usize, ButtonState)> Consumer<CB> for ButtonsEventConsumer {
    fn consume(callback: &mut CB, button_num: usize, button_state: usize, _: usize) {
        let button_state = match button_state {
            0 => ButtonState::Released,
            1 => ButtonState::Pressed,
            _ => return,
        };
        callback(button_num, button_state);
    }
}

pub struct Buttons<'a> {
    num_buttons: usize,
    curr_button: usize,
    lifetime: PhantomData<&'a ()>,
}

impl<'a> Iterator for Buttons<'a> {
    type Item = Button<'a>;

    fn next(&mut self) -> Option<Self::Item> {
        if self.curr_button < self.num_buttons {
            let item = Button {
                button_num: self.curr_button,
                lifetime: PhantomData,
            };
            self.curr_button += 1;
            Some(item)
        } else {
            None
        }
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum ButtonState {
    Pressed,
    Released,
}

impl From<ButtonState> for bool {
    fn from(button_state: ButtonState) -> Self {
        match button_state {
            ButtonState::Released => false,
            ButtonState::Pressed => true,
        }
    }
}

pub struct Button<'a> {
    button_num: usize,
    lifetime: PhantomData<&'a ()>,
}

impl<'a> Button<'a> {
    pub fn button_num(&self) -> usize {
        self.button_num
    }

    pub fn read(&self) -> TockResult<ButtonState> {
        let button_state = syscalls::command(DRIVER_NUMBER, command_nr::READ, self.button_num, 0)?;
        match button_state {
            0 => Ok(ButtonState::Released),
            1 => Ok(ButtonState::Pressed),
            _ => Err(OtherError::ButtonsDriverInvalidState.into()),
        }
    }

    pub fn enable_interrupt(&self) -> TockResult<()> {
        syscalls::command(
            DRIVER_NUMBER,
            command_nr::ENABLE_INTERRUPT,
            self.button_num,
            0,
        )?;
        Ok(())
    }

    pub fn disable_interrupt(&self) -> TockResult<()> {
        syscalls::command(
            DRIVER_NUMBER,
            command_nr::DISABLE_INTERRUPT,
            self.button_num,
            0,
        )?;
        Ok(())
    }
}