use std::io;
use log::{error, trace, warn};
use tokio::sync::mpsc::channel;
use domo_proto::commands::node_management::NodeManagementCommand;
use domo_proto::identifier::Identifier;
use domo_proto::packet::{Packet, ToPacket};
use domo_proto::packet::packet_data::PacketData;
use domo_proto::packet::raw_packet::RawPacket;
use crate::{CONFIG, prelude};
use crate::config::node::NodeType;
use crate::connection::server::Server;

impl NodeType {
    pub async fn start(self) -> io::Result<()> {
        match self {
            NodeType::Master { bind } => {
                let server = Server::new(
                    bind,
                    Some(
                        Identifier::from(
                            hex::decode(CONFIG.with_borrow(|c| c.node.device_id.clone()))
                                .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "could not parse hex"))?
                        )
                    ),
                ).await?;

                {
                    let p = NodeManagementCommand::Ping.to_packet(
                        Identifier::random(),
                        server.device_id(),
                        Identifier::random(),
                        Identifier::default(),
                    );
                    std::fs::write("./packet", Into::<Vec<u8>>::into(p))?;
                }

                loop {
                    match server.recv_packet().await {
                        (Ok(p), Some(s)) => {
                            if p.dest != server.device_id() {
                                if let Some(d) = server.devices().get(&p.dest) {
                                    let _ = &server.send(d.socket_addr, p).await;
                                }
                                continue;
                            }
                            match p.data {
                                PacketData::NodeManagement(NodeManagementCommand::Ping) => {
                                    trace!("ping from: [{s}->{}]", p.src);
                                    let _ = server.send(s, NodeManagementCommand::Ping.to_packet(
                                        server.device_id(),
                                        p.src,
                                        Identifier::random(),
                                        p.packet_id,
                                    )).await;
                                }
                                _ => {}
                            }
                        }
                        (Err(e), Some(source)) => {
                            error!("{source} sent intelligible data: {e}");
                            let device_id = server.device_id();
                            if let Err(e) = server.send(source,
                                                        prelude::quick_err::net_broken_packet(
                                                            device_id,
                                                            Identifier::random(),
                                                        ),
                            ).await {
                                error!("could not send error packet: {e}");
                            }
                        }
                        _ => warn!("dropped packet")
                    }
                }
            }
            NodeType::Bridge { .. } => {}
            NodeType::Subnet { .. } => {}
        }
        Ok(())
    }
}