mod gtfs;
mod renderer;
use std::{collections::HashSet, process, time::SystemTime};
use chrono::{DateTime, Local};
use sdl3::{event::Event, libc::statx_timestamp};
use log::{Level, Metadata, Record, debug, error, info, warn};

use crate::{gtfs::structs::Gtfs, renderer::Screen};

const SRC_FILE: &str = "/home/nahuel/Downloads/GTFS_Realtime.zip";

fn refresh_schedule(gtfs: &Gtfs) {
    let current_timestamp = SystemTime::now();
    let datetime: DateTime<Local> = current_timestamp.clone().into(); 
    let next_arrivals = gtfs.get_next_arrivals_for(&datetime);
    debug!("Next arrivals: {:#?}", next_arrivals);  
}


fn main() {


    // Initialize logger
    static MY_LOGGER: MyLogger = MyLogger;
    struct MyLogger;
    impl log::Log for MyLogger {
        fn enabled(&self, _metadata: &Metadata) -> bool {
            true
        }

        fn log(&self, record: &Record) {
            if self.enabled(record.metadata()) {
                let timestamp = chrono::DateTime::<Local>::from(SystemTime::now()).format("%Y%m%d:%H%M%S");
                println!("{} - {} - {}", timestamp, record.level(), record.args());
            }
        }
        fn flush(&self) {}
    }

    log::set_logger(&MY_LOGGER).unwrap();
    log::set_max_level(log::LevelFilter::Trace);

    let gtfs_prefs = gtfs::structs::Preferences  {
        route_numbers: HashSet::from([String::from("15A"), String::from("F1"), String::from("F2"), String::from("F3")]),
        stop_codes: HashSet::from([String::from("1117")])
    };

    let screen_prefs = renderer::structs::Prefs {
        font_path: String::from("resources/jd_lcd_rounded/jd-lcd-rounded.ttf"),
        screen_width: 1920,
        screen_height: 720,
    };

    // Init GTFS static info
    info!("Loading GTFS data...");
    let gtfs = Gtfs::load(SRC_FILE, &gtfs_prefs);

    // Init screen
    //println!("Initializing screen...");
    //let screen = Screen::init(&screen_prefs);
    //println!("Startup done.");

    // Start an asynchronous refresh thread
    //let _update_thread = thread::Builder::new().name("updater".to_string()).spawn(move || { refresh_schedule(&gtfs) });

    refresh_schedule(&gtfs);
    debug!("Refresh done.");

    // Main event loop
    /*
    let mut event_pump = screen.get_context().event_pump().unwrap();
    loop {
        let event = event_pump.wait_event();
        
        match event {
            Event::Quit { timestamp: _  } => {
                process::exit(0);
            }

            Event::User { timestamp: _, window_id: _, type_: _, code: _, data1: _, data2: _ } => {
                // a message from another thread, probably a refresh?
            }

            // Ignore all other events
            _ => {}
        }

    }    */
}