use crate::constants::{ACCOUNT, ACTIVE_APP};
use crate::db::general::Report;

use super::Error;
use crate::old_brain;
use serde::{Deserialize, Serialize};
use surrealdb::engine::remote::ws::Client;
use surrealdb::sql::Datetime;
use surrealdb::{RecordId, Surreal};

#[derive(Debug, Serialize, Deserialize)]
pub struct AppNode {
    pub id: RecordId,
    pub operator: RecordId,
    pub country: String,
    pub region: String,
    pub city: String,
    pub ip: String,
    pub avail_mem_mb: u32,
    pub avail_vcpus: u32,
    pub avail_storage_gbs: u32,
    pub avail_ports: u32,
    pub max_ports_per_app: u32,
    pub price: u64,
    pub offline_minutes: u64,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct AppNodeWithReports {
    pub id: RecordId,
    pub operator: RecordId,
    pub country: String,
    pub region: String,
    pub city: String,
    pub ip: String,
    pub avail_mem_mb: u32,
    pub avail_vcpus: u32,
    pub avail_storage_gbs: u32,
    pub avail_ports: u32,
    pub max_ports_per_app: u32,
    pub price: u64,
    pub offline_minutes: u64,
    pub reports: Vec<Report>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ActiveApp {
    id: RecordId,
    #[serde(rename = "in")]
    admin: RecordId,
    #[serde(rename = "out")]
    app_node: RecordId,
    app_name: String,
    mapped_ports: Vec<(u64, u64)>,
    host_ipv4: String,
    vcpus: u64,
    memory_mb: u64,
    disk_size_gb: u64,
    created_at: Datetime,
    price_per_unit: u64,
    locked_nano: u64,
    collected_at: Datetime,
    mr_enclave: String,
    package_url: String,
    hratls_pubkey: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ActiveAppWithNode {
    pub id: RecordId,
    #[serde(rename = "in")]
    pub admin: RecordId,
    #[serde(rename = "out")]
    pub app_node: AppNode,
    pub app_name: String,
    pub mapped_ports: Vec<(u64, u64)>,
    pub host_ipv4: String,
    pub vcpus: u64,
    pub memory_mb: u64,
    pub disk_size_gb: u64,
    pub created_at: Datetime,
    pub price_per_unit: u64,
    pub locked_nano: u64,
    pub collected_at: Datetime,
    pub mr_enclave: String,
    pub package_url: String,
    pub hratls_pubkey: String,
}

impl ActiveAppWithNode {
    pub async fn get_by_uuid(db: &Surreal<Client>, uuid: &str) -> Result<Option<Self>, Error> {
        let contract: Option<Self> =
            db.query(format!("select * from {ACTIVE_APP}:{uuid} fetch out;")).await?.take(0)?;
        Ok(contract)
    }
}

impl From<&old_brain::BrainData> for Vec<AppNode> {
    fn from(old_data: &old_brain::BrainData) -> Self {
        let mut nodes = Vec::new();
        for old_node in old_data.app_nodes.iter() {
            nodes.push(AppNode {
                id: RecordId::from(("app_node", old_node.node_pubkey.clone())),
                operator: RecordId::from((ACCOUNT, old_node.operator_wallet.clone())),
                country: old_node.country.clone(),
                region: old_node.region.clone(),
                city: old_node.city.clone(),
                ip: old_node.ip.clone(),
                avail_mem_mb: old_node.avail_mem_mb,
                avail_vcpus: old_node.avail_vcpus,
                avail_storage_gbs: old_node.avail_storage_mb,
                avail_ports: old_node.avail_no_of_port,
                max_ports_per_app: old_node.max_ports_per_app,
                price: old_node.price,
                offline_minutes: old_node.offline_minutes,
            });
        }
        nodes
    }
}