//! # 网络层
//!
//! 网络层(net)规定了数据包格式(Packet)，维护路由表(Protocols)

mod links;
mod packet;
mod protocols;
mod route;

use crate::link::Link;
use alloc::boxed::Box;
use alloc::sync::Arc;
use links::Links;
pub use packet::Id;
use packet::{Field, Packet};
use protocols::{Protocols, RecvCallback};
use route::Routes;

/// 上级父设备
pub const ID_PARENT: Id = [0; 8];
/// 下级子设备
pub const ID_CHILD: Id = [0xFF; 8];

/// 网络层
struct InnerNet {
    /// 转发开关
    relay: bool,
    /// 本设备ID
    id: Id,
    /// 路由表
    routes: spin::RwLock<Routes>,
    /// 链路池
    links: spin::RwLock<Links>,
    /// 协议表
    protocols: spin::RwLock<Protocols>,
}
/// 网络层
#[derive(Clone)]
pub struct Net {
    inner: Arc<InnerNet>,
}
impl Net {
    /// 创建一个网络层
    pub fn new(id: &Id, relay: bool) -> Self {
        let inner = InnerNet {
            relay: relay,
            id: id.clone(),
            routes: spin::RwLock::new(Routes::new()),
            links: spin::RwLock::new(Links::new()),
            protocols: spin::RwLock::new(Protocols::new()),
        };
        Net {
            inner: Arc::new(inner),
        }
    }
    /// 运行
    pub fn run(&self) {
        let net = &self.inner;
        let links = net.links.read();
        links.recv();
    }
    /// 添加本地链路
    pub fn add_link(&self, link: Link, is_parent: bool) {
        let net_tmp = self.clone();
        link.set_recv_cb(Box::new(move |link: Link, load: &[u8]| {
            net_tmp.recv(link, load);
        }));
        let net = &self.inner;
        let mut links = net.links.write();
        links.add(link, is_parent);
    }
    /// 注册子协议的数据包接收函数
    pub fn register_protocol(&self, id: u8, cb: Box<RecvCallback>) {
        let net = &self.inner;
        let mut protocols = net.protocols.write();
        protocols.add_protocol(id, cb);
    }
    /// 通用发送函数
    fn send_common(
        &self,
        packet: &mut Packet,
        dst: Option<&Id>,
        dst_link: Option<&Link>,
        origin: Option<&Link>,
    ) {
        let net = &self.inner;
        let mut link: Option<Link> = None;

        let id: &Id = if let Some(id) = dst {
            packet.set_var(Field::Dst, id);
            id
        } else {
            &packet.dst
        };
        if let None = dst_link {
            let routes = net.routes.read();
            if let Some(l) = routes.find(id) {
                link = Some(l);
            }
        }
        let buf = packet.to_buf();
        if let Some(link) = link {
            if let Some(origin) = origin {
                if origin.eq(&link) {
                    return;
                }
            }
            link.send(&buf);
        } else {
            if let Some(origin) = origin {
                for parent in &net.links.read().parents {
                    if origin.eq(&parent) {
                        return;
                    }
                }
            }

            for parent in &net.links.read().parents {
                parent.send(&buf);
            }
        }
    }
    /// 发送数据包到链路接口
    pub fn send(&self, protocol: u8, data: &[u8], id: Option<&Id>, link: Option<&Link>) {
        let mut packet = Packet::new();
        packet.set_var(Field::Protocol, &[protocol]);
        packet.set_var(Field::Data, data);
        packet.set_var(Field::Src, &self.inner.id);
        packet.set_var(Field::Ttl, &[8]);
        self.send_common(&mut packet, id, link, None);
    }
    /// 发送数据包到所有子设备
    pub fn broadcast(&self, protocol: u8, data: &[u8]) {
        let mut packet = Packet::new();
        packet.set_var(Field::Protocol, &[protocol]);
        packet.set_var(Field::Data, data);
        packet.set_var(Field::Src, &self.inner.id);
        packet.set_var(Field::Dst, &ID_CHILD);
        packet.set_var(Field::Ttl, &[0]);
        let buf = packet.to_buf();
        let routes = self.inner.routes.read();
        for (_id, route) in routes.iter() {
            route.link.send(&buf);
        }
    }
    /// 收到了数据包
    fn recv(&self, link: Link, buf: &[u8]) {
        let packet = Packet::try_from_buf(buf);
        let mut packet = if let Ok(packet) = packet {
            packet
        } else {
            return;
        };
        self.update_route(&packet.src, &link);

        let net = &self.inner;
        if packet.dst == net.id {
            let protocols = net.protocols.read();
            protocols.distribute(packet.protocol, &packet.src, &packet.data);
        } else if net.relay {
            if packet.ttl > 0 {
                packet.set_var(Field::Ttl, &[packet.ttl - 1]);
                self.send_common(&mut packet, None, None, Some(&link));
            } else {
                // I:("unmp TTL is 0.");
            }
        }
    }
    /// 设置固定路由
    pub fn connect(&self, id: &Id, link: &Link) {
        let net = &self.inner;
        let mut routes = net.routes.write();
        routes.remove(id);
        routes.update(id, link.clone());
        routes.fix(id);
    }
    /// 更新路由
    pub fn update_route(&self, id: &Id, link: &Link) {
        let net = &self.inner;

        for parent in &net.links.read().parents {
            if link.eq(&parent) {
                return;
            }
        }
        let mut routes = net.routes.write();
        let route = routes.find(id);
        if let Some(route) = route {
            if route.uid() != link.uid() {
                routes.update(id, link.clone());
            }
        } else {
            routes.update(id, link.clone());
        }
    }
}