use serde::Deserialize;

#[derive(Debug, Default)]
pub enum PrintStatus {
    #[default]
    Unknown,
    Idle,
    Printing,
    Paused,
    Finished,
}

#[derive(Debug, Default)]
pub struct PrinterState {
    pub bed_temp: f32,
    pub status: PrintStatus,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum PrusaState {
    Idle,
    Printing,
    Paused,
    Finished,
    Stopped,
    Error,
    Attention,
    Busy,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BambuState {
    Idle,
    Running,
    Pause,
    Finish,
    Failed,
}

#[derive(Debug, Deserialize)]
pub struct PrusaJob {
    pub id: u32,
    pub progress: f32,
    pub time_remaining: u32,
    pub time_printing: u32,
}

#[derive(Debug, Deserialize)]
pub struct PrusaPrinterInfo {
    pub state: PrusaState,
    pub temp_nozzle: f32,
    pub target_nozzle: f32,
    pub temp_bed: f32,
    pub target_bed: f32,
    pub axis_x: f32,
    pub axis_y: f32,
    pub axis_z: f32,
    pub flow: u32,
    pub speed: u32,
    pub fan_hotend: u32,
    pub fan_print: u32,
}

#[derive(Debug, Deserialize)]
pub struct PrusaStatus {
    pub job: Option<PrusaJob>,
    pub printer: PrusaPrinterInfo,
}

#[derive(Deserialize)]
pub struct BambuPrintMessage {
    pub bed_target_temper: Option<f32>,
    pub bed_temper: Option<f32>,
    pub gcode_state: Option<BambuState>,
    pub layer_num: Option<u32>,
    pub mc_percent: Option<u32>,
    pub mc_remaining_time: Option<u32>,
    pub nozzle_target_temper: Option<f32>,
    pub nozzle_temper: Option<f32>,
    pub print_speed: Option<String>,
    pub total_layer_num: Option<u32>,
}

#[derive(Deserialize)]
pub struct BambuStatus {
    pub print: Option<BambuPrintMessage>,
}

#[derive(Debug, Deserialize)]
pub struct Config {
    // This allows you to have a list of different printer types
    pub printers: Vec<Printer>,
}

impl Config {
    pub fn load(toml: &str) -> Config {
        toml::from_str(toml).expect("Couldn't parse config.toml")
    }
}

#[derive(Debug, Deserialize)]
#[serde(tag = "type", rename_all = "lowercase")]
pub enum Printer {
    Prusa {
        name: String,
        host: String,
        api_key: String,
    },
    Bambu {
        name: String,
        host: String,
        access_code: String,
        serial_number: String,
    },
}

pub fn extract_status_from_prusa(status: &PrusaStatus, state: &mut PrinterState) {
    state.status = match status.printer.state {
        PrusaState::Idle => PrintStatus::Idle,
        PrusaState::Printing => PrintStatus::Printing,
        PrusaState::Paused => PrintStatus::Paused,
        PrusaState::Finished => PrintStatus::Finished,
        _ => PrintStatus::Unknown,
    };
    state.bed_temp = status.printer.temp_bed;
}

pub fn extract_status_from_bambu(status: &BambuStatus, state: &mut PrinterState) {
    if let Some(print) = &status.print {
        if let Some(bed_temper) = print.bed_temper {
            state.bed_temp = bed_temper;
        }
        if let Some(gcode_state) = &print.gcode_state {
            state.status = match gcode_state {
                BambuState::Idle => PrintStatus::Idle,
                BambuState::Running => PrintStatus::Printing,
                BambuState::Pause => PrintStatus::Paused,
                BambuState::Finish => PrintStatus::Finished,
                _ => PrintStatus::Unknown,
            };
        }
    }
}