use telnet::Telnet;
use crate::{commands, wrappers};
use crate::models::{Client, Event, EventType};
use crate::response::Response;

pub fn register_events(connection: &mut Telnet, events: Vec<EventType>) -> Result<(), String> {
    for event in events {
        if commands::clientnotifyregister(connection, 1, event).is_err() {
            return Err(String::from("Failed to register event listener."));
        }
    }
    Ok(())
}

pub fn handle_event_response(connection: &mut Telnet, response: Response, known_clients: &mut Vec<Client>) {
    if let Response::Event(event_type, params) = response {

        let event = Event::new(connection, event_type, params, known_clients);
        match serde_json::to_string(&event) {
            Ok(json) => println!("{}", json),
            Err(err) => {
                // TODO: Handle serialization error
                eprintln!("Serialization error: {}", err);
            }
        }

        if let Ok(new_clients) = wrappers::get_clients(connection) {
            *known_clients = new_clients;
        }
    }
}

pub fn loop_response_reader(connection: &mut Telnet) {
    let mut known_clients = wrappers::get_clients(connection).unwrap_or_else(|_| Vec::new());
    loop {
        match commands::read_response(connection, true, String::new()) {
            Ok(response) => handle_event_response(connection, response, &mut known_clients),
            Err(_) => {
                // print error?
                return;
            }
        }
    }
}