use crate::event::event::*;
use crate::event::manager::EventHandle;
use crate::packet::packet::Packet;
use crate::session::session::Session;
use crate::thread::thread::ThreadContex;
use std::cell::RefCell;
use std::rc::Rc;

#[derive(Clone)]
pub struct ExamplePulgin {
    plugin_name: &'static str,
    plugin_ctx: Rc<RefCell<String>>,
    thread_ctx: Rc<RefCell<ThreadContex>>,
    tcp_opening_event: usize,
    tcp_active_event: usize,
    tcp_expire_event: usize,
    tcp_closed_event: usize,
    http_opening_event: usize,
}

impl ExamplePulgin {
    pub fn new(plugin_name: &'static str, thread_ctx: Rc<RefCell<ThreadContex>>) -> ExamplePulgin {
        ExamplePulgin {
            plugin_name,
            plugin_ctx: Rc::new(RefCell::new(String::new())),
            thread_ctx: thread_ctx,
            tcp_opening_event: 0,
            tcp_active_event: 0,
            tcp_expire_event: 0,
            tcp_closed_event: 0,
            http_opening_event: 0,
        }
    }

    pub fn get_thread_ctx(&self) -> Rc<RefCell<ThreadContex>> {
        self.thread_ctx.clone()
    }
}

impl EventHandle for ExamplePulgin {
    fn init(&mut self) {
        let thread_ctx = self.get_thread_ctx();
        let event_mgr = thread_ctx.borrow().get_event_mgr();

        self.tcp_opening_event = event_mgr
            .borrow_mut()
            .event2index(BUILTIN_TCP_OPENING_EVENT);
        event_mgr
            .borrow_mut()
            .register(self.tcp_opening_event, Box::new(self.clone()));

        self.tcp_active_event = event_mgr.borrow_mut().event2index(BUILTIN_TCP_ACTIVE_EVENT);
        event_mgr
            .borrow_mut()
            .register(self.tcp_active_event, Box::new(self.clone()));

        self.tcp_expire_event = event_mgr.borrow_mut().event2index(BUILTIN_TCP_EXPIRE_EVENT);
        event_mgr
            .borrow_mut()
            .register(self.tcp_expire_event, Box::new(self.clone()));

        self.tcp_closed_event = event_mgr.borrow_mut().event2index(BUILTIN_TCP_CLOSED_EVENT);
        event_mgr
            .borrow_mut()
            .register(self.tcp_closed_event, Box::new(self.clone()));

        self.http_opening_event = event_mgr
            .borrow_mut()
            .event2index("USERDEF_HTTP_OPENING_EVENT");
        event_mgr
            .borrow_mut()
            .register(self.http_opening_event, Box::new(self.clone()));
    }

    fn handle(
        &mut self,
        index: usize,
        packet: Option<&Packet>,
        session: Option<Rc<RefCell<Session>>>,
    ) {
        self.plugin_ctx.borrow_mut().clear();
        self.plugin_ctx.borrow_mut().push_str("1");

        if session.is_none() {
            return;
        }

        if packet.is_some() {
            let flow_id = packet.unwrap().get_flow_id();
            println!("{} handle Packet: {:?}", self.plugin_name, flow_id);
        } else {
            println!("{} handle Packet: None", self.plugin_name);
        }

        let session = session.unwrap();
        if index == self.tcp_opening_event {
            println!(
                "{} handle BUILTIN_TCP_OPENING_EVENT: {:?}",
                self.plugin_name, session
            );
        } else if index == self.tcp_active_event {
            println!(
                "{} handle BUILTIN_TCP_ACTIVE_EVENT: {:?}",
                self.plugin_name, session
            );
        } else if index == self.tcp_expire_event {
            println!(
                "{} handle BUILTIN_TCP_EXPIRE_EVENT: {:?}",
                self.plugin_name, session
            );
        } else if index == self.tcp_closed_event {
            println!(
                "{} handle BUILTIN_TCP_CLOSED_EVENT: {:?}",
                self.plugin_name, session
            );
        } else if index == self.http_opening_event {
            println!(
                "{} handle USERDEF_HTTP_OPENING_EVENT: {:?}",
                self.plugin_name, session
            );
        } else {
            println!("{} handle UNKNOWN_EVENT: {:?}", self.plugin_name, session);
        }
    }
}