elf_utils 0.1.4

use serde::{Deserialize, Serialize};
use serde_json::{self, Value};
use std::fmt;

#[derive(Serialize, Deserialize, Debug, PartialEq)]
pub struct Params {
    #[serde(rename = "kp_scheduler_id")]
    ks_id: Option<u64>,
    #[serde(rename = "kp_target_id")]
    kt_id: Option<u64>,
    #[serde(rename = "kp_scheduler_name")]
    ks_name: Option<String>,
    uk: Option<String>,
    lid: Option<u64>,
}

impl Default for Params {
    fn default() -> Self {
        Self::new()
    }
}

impl Params {
    pub fn new() -> Self {
        Params {
            ks_id: None,
            kt_id: None,
            ks_name: None,
            uk: None,
            lid: None,
        }
    }

    pub fn valid(&self) -> bool {
        self.ks_id.is_some() || self.uk.is_some()
    }

    pub fn set_lid(&mut self, lid: u64) {
        self.lid = Some(lid);
    }

    pub fn gen_uk(&self) -> String {
        if let Some(ref uk) = self.uk {
            if !uk.is_empty() {
                return uk.clone();
            }
        }
        if self.lid.is_none() {
            return format!("s:{}:{}", self.ks_id.unwrap_or(0), self.kt_id.unwrap_or(0));
        }
        format!("s:{}:{}:{}", self.ks_id.unwrap_or(0), self.kt_id.unwrap_or(0), self.lid.unwrap_or(0))
    }
}

impl fmt::Display for Params {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match serde_json::to_string(self) {
            Ok(json) => write!(f, "{}", json),
            Err(_) => write!(f, "Failed to convert to JSON"),
        }
    }
}

pub fn parse_params(value: Value) -> Result<Params, serde_json::Error> {
    serde_json::from_value(value)
}

pub fn parse_params_from_str(data: &str) -> Result<Params, serde_json::Error> {
    let value: Value = serde_json::from_str(data)?;
    parse_params(value)
}