use ayin::runtime::*;
use hotwatch::{
    self,
    notify::event::{DataChange, ModifyKind},
};
use macroquad::prelude::*;
use std::{
    sync::{Arc, RwLock},
    time::Duration,
};

fn window_conf() -> Conf {
    Conf {
        window_title: "Ayin".to_owned(),
        fullscreen: false,
        window_width: SCREEN_WIDTH as i32,
        window_height: SCREEN_HEIGHT as i32,
        ..Default::default()
    }
}

#[macroquad::main(window_conf)]
async fn main() {
    env_logger::init();
    info!("Hello, 👁️‍🗨️!");
    if screen_width() < SCREEN_WIDTH {
        request_new_screen_size(SCREEN_WIDTH as f32, SCREEN_HEIGHT as f32);
    }
    rand::srand(macroquad::miniquad::date::now() as _);

    let args: Vec<String> = std::env::args().collect();
    let file = args[1].clone();

    let writer = Arc::new(RwLock::new(None));
    let reader = writer.clone();
    let mut hotwatch = hotwatch::Hotwatch::new_with_custom_delay(Duration::from_millis(10))
        .expect("hotwatch failed to initialize!");
    hotwatch
        .watch(file.clone(), move |event: hotwatch::Event| {
            if let hotwatch::EventKind::Modify(ModifyKind::Data(DataChange::Content)) = event.kind {
                match std::fs::read_to_string(file.clone()) {
                    Err(err) => println!("Error: {err:#?}"),
                    Ok(txt) => match ayin::parser::parse_file(txt) {
                        Err(err) => println!("Error: {err:#?}"),
                        Ok(program) => {
                            let mut w = writer.write().unwrap();
                            *w = Some(program);
                        }
                    },
                }
            }
        })
        .expect("failed to watch file!");

    let file = args[1].clone();

    match std::fs::read_to_string(file) {
        Err(err) => println!("Error: {err:#?}"),
        Ok(txt) => match ayin::parser::parse_file(txt) {
            Err(err) => println!("Error: {err:#?}"),
            Ok(program) => {
                let mut state = setup(program).await;

                loop {
                    let new_program = {
                        let prog = { (*(reader.read().unwrap())).clone() };
                        if let Some(new_program) = prog {
                            let mut w = reader.write().unwrap();
                            *w = None;
                            Some(new_program)
                        } else {
                            None
                        }
                    };
                    if let Some(new_program) = new_program {
                        state = migrate(state, new_program);
                    }

                    let events = fetch_events(&mut state);
                    update(&mut state, events);
                    draw(&mut state);
                    next_frame().await;
                }
            }
        },
    }
}