use crate::event::event::Event;
use crate::event::manager::EventHandle;
use crate::event::manager::EventManager;
use crate::event::manager::EventQueue;
use crate::packet::packet::Packet;
use crate::session::session::Session;
use std::cell::RefCell;
use std::rc::Rc;

#[derive(Clone)]
pub struct ExamplePulgin {
    plugin_name: &'static str,
    plugin_ctx: Rc<RefCell<String>>,
}

impl ExamplePulgin {
    pub fn new(plugin_name: &'static str) -> ExamplePulgin {
        ExamplePulgin {
            plugin_name,
            plugin_ctx: Rc::new(RefCell::new(String::new())),
        }
    }
}

impl EventHandle for ExamplePulgin {
    fn init(&mut self, event_mgr: &mut EventManager) {
        event_mgr.register(Event::TcpOpeningEvent, Box::new(self.clone()));
        event_mgr.register(Event::TcpActiveEvent, Box::new(self.clone()));
        event_mgr.register(Event::TcpExpireEvent, Box::new(self.clone()));
        event_mgr.register(Event::TcpClosedEvent, Box::new(self.clone()));
        event_mgr.register(Event::HttpRequestEvent, Box::new(self.clone()));
    }

    fn handle(
        &mut self,
        event: Event,
        queue: &mut EventQueue,
        packet: Option<&Packet>,
        session: Option<Rc<RefCell<Session>>>,
    ) {
        self.plugin_ctx.borrow_mut().push_str("1");

        if session.is_none() {
            return;
        }

        if packet.is_none() {
            println!("{} handle Packet: None", self.plugin_name);
        }

        let session = session.unwrap();
        session.borrow_mut().inc_session_c2s_metrics(0, 0, 1, 1);
        match event {
            Event::TcpOpeningEvent => {
                println!("{} handle TcpOpeningEvent: {:?}", self.plugin_name, session);
                let (src_port, dst_port) = packet.unwrap().get_inner_most_port().unwrap();
                if src_port == 80 || dst_port == 80 {
                    println!("{} add HttpRequestEvent", self.plugin_name);
                    queue.add(Event::HttpRequestEvent, Some(session));
                }
            }
            Event::TcpActiveEvent => {
                println!("{} handle TcpActiveEvent: {:?}", self.plugin_name, session);
            }
            Event::TcpExpireEvent => {
                println!("{} handle TcpExpireEvent: {:?}", self.plugin_name, session);
            }
            Event::TcpClosedEvent => {
                println!("{} handle TcpClosedEvent: {:?}", self.plugin_name, session);
            }
            Event::HttpRequestEvent => {
                println!(
                    "{} handle HttpRequestEvent: {:?}",
                    self.plugin_name, session
                );
            }
            _ => {
                println!("{} handle UnknownEvent: {:?}", self.plugin_name, session);
            }
        }
    }
}