use std::{path::PathBuf, process};

use anyhow::Result;
use app::App;
use clap::Parser;
use emulator::EmulatorBuilder;
use thread_priority::{ThreadBuilder, ThreadPriority};
use winit::event_loop::{ControlFlow, EventLoop};

mod app;
mod audio;
mod controller;
mod emulator;
mod graphics;
mod input;

#[derive(Parser)]
struct Args {
    rom: Option<PathBuf>,
}

#[cfg(windows)]
fn set_process_priority_to_high() -> Result<()> {
    use windows::Win32::{Foundation, System::Threading};
    let process = unsafe { Threading::GetCurrentProcess() };
    unsafe { Threading::SetPriorityClass(process, Threading::HIGH_PRIORITY_CLASS)? };
    unsafe { Foundation::CloseHandle(process)? };
    Ok(())
}

fn main() -> Result<()> {
    #[cfg(windows)]
    set_process_priority_to_high()?;

    let args = Args::parse();

    let (mut builder, client) = EmulatorBuilder::new();
    if let Some(path) = args.rom {
        builder = builder.with_rom(&path);
    }

    ThreadBuilder::default()
        .name("Emulator".to_owned())
        .priority(ThreadPriority::Max)
        .spawn_careless(move || {
            let mut emulator = match builder.build() {
                Ok(e) => e,
                Err(err) => {
                    eprintln!("Error initializing emulator: {err}");
                    process::exit(1);
                }
            };
            emulator.run();
        })?;

    let event_loop = EventLoop::with_user_event().build().unwrap();
    event_loop.set_control_flow(ControlFlow::Poll);
    let proxy = event_loop.create_proxy();
    event_loop.run_app(&mut App::new(client, proxy))?;
    Ok(())
}