use crate::store::BaseData;
use rhai::{CustomType, TypeBuilder};
use serde::{Deserialize, Serialize};
use super::common::{PricingPolicy, SLAPolicy};

/// Storage device information
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct StorageDevice {
    /// can be used in node
    pub id: String,
    /// Size of the storage device in gigabytes
    pub size_gb: f64,
    /// Description of the storage device
    pub description: String,
}

/// Memory device information
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct MemoryDevice {
    /// can be used in node
    pub id: String,
    /// Size of the memory device in gigabytes
    pub size_gb: f64,
    /// Description of the memory device
    pub description: String,
}

/// CPU device information
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct CPUDevice {
    /// can be used in node
    pub id: String,
    /// Number of CPU cores
    pub cores: i32,
    /// Passmark score
    pub passmark: i32,
    /// Description of the CPU
    pub description: String,
    /// Brand of the CPU
    pub cpu_brand: String,
    /// Version of the CPU
    pub cpu_version: String,
}

/// GPU device information
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct GPUDevice {
    /// can be used in node
    pub id: String,
    /// Number of GPU cores
    pub cores: i32,
    /// Size of the GPU memory in gigabytes
    pub memory_gb: f64,
    /// Description of the GPU
    pub description: String,
    pub gpu_brand: String,
    pub gpu_version: String,
}

/// Network device information
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct NetworkDevice {
    /// can be used in node
    pub id: String,
    /// Network speed in Mbps
    pub speed_mbps: i32,
    /// Description of the network device
    pub description: String,
}

/// Aggregated device info for a node
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct DeviceInfo {
    pub vendor: String,
    pub storage: Vec<StorageDevice>,
    pub memory: Vec<MemoryDevice>,
    pub cpu: Vec<CPUDevice>,
    pub gpu: Vec<GPUDevice>,
    pub network: Vec<NetworkDevice>,
}

/// NodeCapacity represents the hardware capacity details of a node.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct NodeCapacity {
    /// Total storage in gigabytes
    pub storage_gb: f64,
    /// Total memory in gigabytes
    pub mem_gb: f64,
    /// Total GPU memory in gigabytes
    pub mem_gb_gpu: f64,
    /// Passmark score for the node
    pub passmark: i32,
    /// Total virtual cores
    pub vcores: i32,
}

// PricingPolicy and SLAPolicy moved to `common.rs` to be shared across models.

/// Compute slice (typically represents a base unit of compute)
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct ComputeSlice {
    /// the id of the slice in the node
    pub id: u16,
    pub mem_gb: f64,
    pub storage_gb: f64,
    pub passmark: i32,
    pub vcores: i32,
    pub cpu_oversubscription: i32,
    pub storage_oversubscription: i32,
    /// nr of GPU's see node to know what GPU's are
    pub gpus: u8,
}

impl ComputeSlice {
    pub fn new() -> Self {
        Self {
            id: 0,
            mem_gb: 0.0,
            storage_gb: 0.0,
            passmark: 0,
            vcores: 0,
            cpu_oversubscription: 0,
            storage_oversubscription: 0,
            gpus: 0,
        }
    }

    pub fn id(mut self, id: u16) -> Self {
        self.id = id;
        self
    }
    pub fn mem_gb(mut self, v: f64) -> Self {
        self.mem_gb = v;
        self
    }
    pub fn storage_gb(mut self, v: f64) -> Self {
        self.storage_gb = v;
        self
    }
    pub fn passmark(mut self, v: i32) -> Self {
        self.passmark = v;
        self
    }
    pub fn vcores(mut self, v: i32) -> Self {
        self.vcores = v;
        self
    }
    pub fn cpu_oversubscription(mut self, v: i32) -> Self {
        self.cpu_oversubscription = v;
        self
    }
    pub fn storage_oversubscription(mut self, v: i32) -> Self {
        self.storage_oversubscription = v;
        self
    }
    pub fn gpus(mut self, v: u8) -> Self {
        self.gpus = v;
        self
    }
}

/// Storage slice (typically 1GB of storage)
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct StorageSlice {
    /// the id of the slice in the node, are tracked in the node itself
    pub id: u16,
}

impl StorageSlice {
    pub fn new() -> Self {
        Self {
            id: 0,
        }
    }

    pub fn id(mut self, id: u16) -> Self {
        self.id = id;
        self
    }
}

/// Grid4 Node model
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default, crate::DeriveObject)]
pub struct Node {
    pub base_data: BaseData,
    /// Link to node group
    #[index]
    pub nodegroupid: i32,
    /// Uptime percentage 0..100
    pub uptime: i32,
    pub computeslices: Vec<ComputeSlice>,
    pub storageslices: Vec<StorageSlice>,
    pub devices: DeviceInfo,
    /// 2 letter code as specified in lib/data/countries/data/countryInfo.txt
    #[index]
    pub country: String,
    /// Hardware capacity details
    pub capacity: NodeCapacity,
    /// first time node was active
    pub birthtime: u32,
    /// node public key
    #[index]
    pub pubkey: String,
    /// signature done on node to validate pubkey with privkey
    pub signature_node: String,
    /// signature as done by farmers to validate their identity
    pub signature_farmer: String,
}

impl Node {
    pub fn new() -> Self {
        Self {
            base_data: BaseData::new(),
            nodegroupid: 0,
            uptime: 0,
            computeslices: Vec::new(),
            storageslices: Vec::new(),
            devices: DeviceInfo::default(),
            country: String::new(),
            capacity: NodeCapacity::default(),
            birthtime: 0,
            pubkey: String::new(),
            signature_node: String::new(),
            signature_farmer: String::new(),
        }
    }

    pub fn nodegroupid(mut self, v: i32) -> Self {
        self.nodegroupid = v;
        self
    }
    pub fn uptime(mut self, v: i32) -> Self {
        self.uptime = v;
        self
    }
    pub fn add_compute_slice(mut self, s: ComputeSlice) -> Self {
        self.computeslices.push(s);
        self
    }
    pub fn add_storage_slice(mut self, s: StorageSlice) -> Self {
        self.storageslices.push(s);
        self
    }
    pub fn devices(mut self, d: DeviceInfo) -> Self {
        self.devices = d;
        self
    }
    pub fn country(mut self, c: impl ToString) -> Self {
        self.country = c.to_string();
        self
    }
    pub fn capacity(mut self, c: NodeCapacity) -> Self {
        self.capacity = c;
        self
    }
    pub fn birthtime(mut self, t: u32) -> Self {
        self.birthtime = t;
        self
    }

    pub fn pubkey(mut self, v: impl ToString) -> Self {
        self.pubkey = v.to_string();
        self
    }
    pub fn signature_node(mut self, v: impl ToString) -> Self {
        self.signature_node = v.to_string();
        self
    }
    pub fn signature_farmer(mut self, v: impl ToString) -> Self {
        self.signature_farmer = v.to_string();
        self
    }

    /// Placeholder for capacity recalculation out of the devices on the Node
    pub fn check(self) -> Self {
        // TODO: calculate NodeCapacity out of the devices on the Node
        self
    }
}