use std::sync::{Arc, Mutex};
use crate::can::CanTxHandler;
use crate::can_ids::{DeviceId, PackageId, PackageModel};
use crate::hk::HkRequest;
use crate::power_handler::{DeviceState, PowerSwitcher};
use crate::requests::{Request, RequestWithToken};
use crate::ActionRequest;
use satrs_core::power::SwitchId;
use std::sync::mpsc::{Receiver, TryRecvError};
use serde::{Deserialize, Serialize};

pub enum AocsSensorMode {
    Idle,
    SendingData,
}

pub trait AocsSensorHandler {
    type Error;

    fn get_package_id(&mut self) -> Result<PackageId, Self::Error>;
    fn send_message(&mut self, id: PackageId, buf: &[u8]) -> Result<(), Self::Error>;

    fn enable_sensor_data_generation(&mut self) -> Result<(), Self::Error> {
        let id = self.get_package_id()?;
        self.send_message(id, &[1])
    }

    fn disable_sensor_data_generation(&mut self) -> Result<(), Self::Error> {
        let id = self.get_package_id()?;
        self.send_message(id, &[0])
    }

    fn request_sensor_data_oneshot(&mut self) -> Result<(), Self::Error> {
        let id = self.get_package_id()?;
        self.send_message(id, &[2])
    }
}

#[derive(Debug, Copy, Clone, Default, Serialize, Deserialize)]
pub struct MGMData {
    axis_1: f64,
    axis_2: f64,
    axis_3: f64,
}

impl MGMData {
    pub fn from_floats(axis_1: f64,
                       axis_2: f64,
                       axis_3: f64,
    ) -> MGMData {
        MGMData{axis_1, axis_2, axis_3}
    }

    pub fn new() -> MGMData { MGMData{axis_1: 0.0, axis_2: 0.0, axis_3: 0.0} }

    pub fn update(&mut self,
                  axis_1: f64,
                  axis_2: f64,
                  axis_3: f64
    ) {
        self.axis_1 = axis_1;
        self.axis_2 = axis_2;
        self.axis_3 = axis_3;
    }

    pub fn to_array(&self) -> [f64; 3] {
        [self.axis_1, self.axis_2, self.axis_3]
    }

    pub fn to_tuple(&self) -> (f64, f64, f64) {
        (self.axis_1, self.axis_2, self.axis_3)
    }
}

pub struct MGMHandler {
    power_switcher: PowerSwitcher,
    device_id: DeviceId,
    switch_id: SwitchId,
    device_state: DeviceState,
    can_tx: CanTxHandler,
    can_rx: Receiver<PackageModel>,
    mode: AocsSensorMode,
    mode_rx: Receiver<AocsSensorMode>,
    action_rx: Receiver<RequestWithToken>,
    mgm_data: Arc<Mutex<MGMData>>,
}

impl AocsSensorHandler for MGMHandler {
    type Error = ();

    fn get_package_id(&mut self) -> Result<PackageId, Self::Error> {
        return match self.device_id {
            DeviceId::MGM1 => Ok(PackageId::AOCSDataRequestMGM1),
            DeviceId::MGM2 => Ok(PackageId::AOCSDataRequestMGM2),
            DeviceId::MGM3 => Ok(PackageId::AOCSDataRequestMGM3),
            DeviceId::MGM4 => Ok(PackageId::AOCSDataRequestMGM4),
            _ => Err(()),
        };
    }

    fn send_message(&mut self, id: PackageId, buf: &[u8]) -> Result<(), Self::Error> {
        self.can_tx.tx_socket(id, buf);
        return Ok(());
    }
}

impl MGMHandler {
    pub fn new(
        power_switcher: PowerSwitcher,
        device_id: DeviceId,
        switch_id: SwitchId,
        can_tx: CanTxHandler,
        can_rx: Receiver<PackageModel>,
        mode_rx: Receiver<AocsSensorMode>,
        action_rx: Receiver<RequestWithToken>,
    ) -> MGMHandler {
        MGMHandler {
            power_switcher,
            device_id,
            switch_id,
            device_state: DeviceState::Off,
            can_tx,
            can_rx,
            mode: AocsSensorMode::Idle,
            mode_rx,
            action_rx,
            mgm_data: Arc::new(Mutex::new(MGMData::new())),
        }
    }

    pub fn get_data_ref(&mut self) -> Arc<Mutex<MGMData>> {
        self.mgm_data.clone()
    }

    pub fn periodic_op(&mut self) {
        self.update_mode();
        //self.handle_action_requests();
    }

    pub fn update_mode(&mut self) {
        if self.device_state == DeviceState::On {
            if let Ok(mode) = self.mode_rx.try_recv() {
                self.mode = mode;
            }
        }
    }

    pub fn handle_requests(&mut self) {
        if self.device_state == DeviceState::On {
            if let Ok(request) = self.action_rx.try_recv() {
                match request.0 {
                    Request::HkRequest(hk_req) => {
                        self.handle_hk_request(hk_req);
                    }
                    Request::ActionRequest(action_request) => {
                        self.handle_action_request(action_request);
                    }
                }
            }
        }
    }

    pub fn handle_hk_request(&mut self, hk_req: HkRequest) {
        match hk_req {
            HkRequest::OneShot(_) => {

            }
            HkRequest::Enable(_) => {}
            HkRequest::Disable(_) => {}
            HkRequest::ModifyCollectionInterval(_, _) => {}
        }
    }
    pub fn handle_action_request(&mut self, action_request: ActionRequest) {}
}