use bevy::prelude::*;

use crate::{
    components::DirworldEntity,
    events::{DirworldNavigationComplete, DirworldSpawn},
    resources::{DirworldObservers, DirworldTasks, EntryType},
    Extensions,
};

use super::{
    DirworldPreloadBegin, PreloadPaths, PreloadState, RoomAssets,
};

pub fn cache_preload_paths(
    mut event_reader: EventReader<DirworldPreloadBegin>,
    mut paths: ResMut<PreloadPaths>,
) {
    for DirworldPreloadBegin { old_path, path } in event_reader.read() {
        paths.src = old_path.canonicalize().unwrap();
        paths.dst = path.canonicalize().unwrap();
    }
}

pub fn handle_preload(
    asset_server: Res<AssetServer>,
    room_assets: Res<RoomAssets>,
    mut next_state: ResMut<NextState<PreloadState>>,
    mut dirworld_tasks: ResMut<DirworldTasks>,
) {
    if room_assets.is_empty()
        || room_assets
            .values()
            .flat_map(|v| v.values())
            .all(|a| asset_server.is_loaded_with_dependencies(a))
    {
        info!("Preload Done.");
        next_state.set(PreloadState::Done);
        dirworld_tasks.remove("Loading Room");
    }
}

pub fn handle_spawn(
    preload_paths: Res<PreloadPaths>,
    dirworld_entity_query: Query<(Entity, &DirworldEntity)>,
    mut commands: Commands,
    observers: Res<DirworldObservers>,
    mut event_writer: EventWriter<DirworldNavigationComplete>,
) {
    info!("Spawning");
    for (entity, DirworldEntity { path, .. }) in dirworld_entity_query.iter() {
        let entry_type = if path.is_dir() {
            EntryType::Folder
        } else {
            EntryType::File(path.extensions())
        };
        if let Some(observer) = observers.get(&entry_type) {
            info!("Found observer {observer:?} for {entry_type:?}");
            commands.trigger_targets(DirworldSpawn(entity), observer.clone());
        }
    }
    event_writer.send(DirworldNavigationComplete {
        from: preload_paths.src.clone(),
        to: preload_paths.dst.clone(),
    });
}