use std::net::Ipv4Addr;

use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

use crate::{
    base_dir,
    node::{Node, OptionalNode},
    patch::{PatchEnv, Patches},
};

#[derive(Debug, Deserialize, JsonSchema, Clone)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Base {
    #[serde(default)]
    pub(crate) kernel_args: Vec<String>,
    #[serde(default)]
    pub(crate) patches: Patches,
}

#[derive(Debug, Serialize, Deserialize, JsonSchema, Clone)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Version {
    kubernetes: semver::Version,
    talos: semver::Version,
}

#[derive(Debug, Serialize, Deserialize, JsonSchema, Clone)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub enum ClusterEnv {
    Production,
    Staging,
}

#[derive(Debug, Serialize, Deserialize, JsonSchema, Clone)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Cluster {
    #[serde(skip_deserializing)]
    name: String,
    version: Version,
    nodes: Vec<String>,
    cluster_env: ClusterEnv,
    control_plane_ip: Ipv4Addr,
    #[serde(default, skip_serializing)]
    pub(crate) default: OptionalNode,
    #[serde(skip_serializing)]
    pub(crate) base: Base,
    // pub secrets_file: PathBuf,
}

impl Cluster {
    pub fn get(cluster_name: &str) -> Self {
        let mut path = base_dir().join("clusters").join(cluster_name);
        path.add_extension("yaml");
        let content = std::fs::read_to_string(path).unwrap();

        let mut cluster: Self = serde_yaml::from_str(&content).unwrap();
        cluster.name = cluster_name.to_string();

        cluster
    }

    pub fn nodes(&self, env: PatchEnv) -> Vec<Node> {
        self.nodes
            .iter()
            .map(|node_name| Node::get(node_name, &env, self))
            .collect()
    }
}