use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
pub struct Light {
    #[serde(rename = "alert")]
    pub alert: Alert,

    #[serde(rename = "color")]
    pub color: Option<Color>,

    #[serde(rename = "color_temperature")]
    pub color_temperature: ColorTemperature,

    #[serde(rename = "color_temperature_delta")]
    pub color_temperature_delta: Delta,

    #[serde(rename = "dimming")]
    pub dimming: Dimming,

    #[serde(rename = "dimming_delta")]
    pub dimming_delta: Delta,

    #[serde(rename = "dynamics")]
    pub dynamics: Dynamics,

    #[serde(rename = "id")]
    pub id: String,

    #[serde(rename = "id_v1")]
    pub id_v1: String,

    #[serde(rename = "metadata")]
    pub metadata: Metadata,

    #[serde(rename = "mode")]
    pub mode: String,

    #[serde(rename = "on")]
    pub on: On,

    #[serde(rename = "owner")]
    pub owner: Owner,

    #[serde(rename = "type")]
    pub datum_type: String,

    #[serde(rename = "effects")]
    pub effects: Option<Effects>,
}

#[derive(Serialize, Deserialize)]
pub struct Alert {
    #[serde(rename = "action_values")]
    pub action_values: Vec<String>,
}

#[derive(Serialize, Deserialize)]
pub struct Color {
    #[serde(rename = "gamut")]
    pub gamut: Option<Gamut>,

    #[serde(rename = "gamut_type")]
    pub gamut_type: Option<String>,

    #[serde(rename = "xy")]
    pub xy: Xy,
}

#[derive(Serialize, Deserialize)]
pub struct Gamut {
    #[serde(rename = "blue")]
    pub blue: Xy,

    #[serde(rename = "green")]
    pub green: Xy,

    #[serde(rename = "red")]
    pub red: Xy,
}

#[derive(Serialize, Deserialize)]
pub struct Xy {
    #[serde(rename = "x")]
    pub x: f64,

    #[serde(rename = "y")]
    pub y: f64,
}

#[derive(Serialize, Deserialize)]
pub struct ColorTemperature {
    #[serde(rename = "mirek")]
    pub mirek: i64,

    #[serde(rename = "mirek_schema")]
    pub mirek_schema: MirekSchema,

    #[serde(rename = "mirek_valid")]
    pub mirek_valid: bool,
}

#[derive(Serialize, Deserialize)]
pub struct MirekSchema {
    #[serde(rename = "mirek_maximum")]
    pub mirek_maximum: i64,

    #[serde(rename = "mirek_minimum")]
    pub mirek_minimum: i64,
}

#[derive(Serialize, Deserialize)]
pub struct Delta {}

#[derive(Serialize, Deserialize)]
pub struct Dimming {
    #[serde(rename = "brightness")]
    pub brightness: f64,

    #[serde(rename = "min_dim_level")]
    pub min_dim_level: f64,
}

#[derive(Serialize, Deserialize)]
pub struct Dynamics {
    #[serde(rename = "speed")]
    pub speed: f64,

    #[serde(rename = "speed_valid")]
    pub speed_valid: bool,

    #[serde(rename = "status")]
    pub status: DynamicsStatus,

    #[serde(rename = "status_values")]
    pub status_values: Vec<DynamicsStatus>,
}

#[derive(Serialize, Deserialize)]
pub struct Effects {
    #[serde(rename = "effect_values")]
    pub effect_values: Vec<StatusElement>,

    #[serde(rename = "status")]
    pub status: StatusElement,

    #[serde(rename = "status_values")]
    pub status_values: Vec<StatusElement>,
}

#[derive(Serialize, Deserialize)]
pub struct Metadata {
    #[serde(rename = "archetype")]
    pub archetype: String,

    #[serde(rename = "name")]
    pub name: String,
}

#[derive(Serialize, Deserialize)]
pub struct On {
    #[serde(rename = "on")]
    pub on: bool,
}

#[derive(Serialize, Deserialize)]
pub struct Owner {
    #[serde(rename = "rid")]
    pub rid: String,

    #[serde(rename = "rtype")]
    pub rtype: String,
}

#[derive(Serialize, Deserialize)]
pub enum DynamicsStatus {
    #[serde(rename = "dynamic_palette")]
    DynamicPalette,

    #[serde(rename = "none")]
    None,
}

#[derive(Serialize, Deserialize)]
pub enum StatusElement {
    #[serde(rename = "candle")]
    Candle,

    #[serde(rename = "fire")]
    Fire,

    #[serde(rename = "no_effect")]
    NoEffect,
}