use std::{
    net::{IpAddr, Ipv4Addr},
    sync::Arc,
};

use async_trait::async_trait;
use cidr::Ipv4Cidr;
use harmony::{
    executors::ExecutorError,
    hardware::{HostCategory, Location, PhysicalHost, SwitchGroup},
    infra::opnsense::OPNSenseManagementInterface,
    inventory::Inventory,
    modules::opnsense::node_exporter::NodeExporterScore,
    topology::{
        HAClusterTopology, LogicalHost, PreparationError, PreparationOutcome, Topology,
        UnmanagedRouter, node_exporter::NodeExporter,
    },
};
use harmony_macros::{ip, ipv4, mac_address};

#[derive(Debug)]
struct OpnSenseTopology {
    node_exporter: Arc<dyn NodeExporter>,
}

#[async_trait]
impl Topology for OpnSenseTopology {
    async fn ensure_ready(&self) -> Result<PreparationOutcome, PreparationError> {
        Ok(PreparationOutcome::Success {
            details: "Success".to_string(),
        })
    }
    fn name(&self) -> &str {
        "OpnsenseTopology"
    }
}

#[async_trait]
impl NodeExporter for OpnSenseTopology {
    async fn ensure_initialized(&self) -> Result<(), ExecutorError> {
        self.node_exporter.ensure_initialized().await
    }

    async fn commit_config(&self) -> Result<(), ExecutorError> {
        self.node_exporter.commit_config().await
    }

    async fn reload_restart(&self) -> Result<(), ExecutorError> {
        self.node_exporter.reload_restart().await
    }
}

#[tokio::main]
async fn main() {
    let firewall = harmony::topology::LogicalHost {
        ip: ip!("192.168.1.1"),
        name: String::from("fw0"),
    };

    let opnsense = Arc::new(
        harmony::infra::opnsense::OPNSenseFirewall::new(firewall, None, "root", "opnsense").await,
    );

    let topology = OpnSenseTopology {
        node_exporter: opnsense.clone(),
    };

    let inventory = Inventory::empty();

    let node_exporter_score = NodeExporterScore {};

    harmony_cli::run(
        inventory,
        topology,
        vec![Box::new(node_exporter_score)],
        None,
    )
    .await
    .unwrap();
}