use std::cell::RefCell;
use std::rc::Rc;
use raidillon_core::scene::{Scene, SceneManager};
use crate::system::{SystemContext, SystemManager};
use raidillon_platform::PlatformContext;
use raidillon_core::{define_typemap, DebugUIBuffer};
use raidillon_core::engine::EngineTrait;
use crate::input::InputState;
use crate::resources::EngineResources;

pub struct Engine {
    pub scene_manager: SceneManager,
    pub system_manager: SystemManager,
    pub resources: EngineResources,
}

impl Engine {
    fn load_default_resources(&mut self) {
        let input = InputState::default();
        self.resources.insert(input);
    }
}

impl EngineTrait for Engine {
    type PlatformCtx = PlatformContext;
    fn new() -> Self {
        let scene_manager = SceneManager::new();
        let system_manager = SystemManager::new();
        let mut s = Self {
            scene_manager,
            system_manager,
            resources: EngineResources::new(),
        };
        s.load_default_resources();
        s
    }

    /// Initialize systems, load the world.
    fn initialize(&mut self, platform_context: PlatformContext) {
        // Engine Loading Stage 1: initialize systems
        for system in self.system_manager.systems.values_mut() {
            system.initialize();
        }
        self.resources.insert(platform_context);
        // Engine Loading Stage 2: load world
        for system in self.system_manager.systems.values_mut() {
            system.load_world(&mut self.resources, &mut self.scene_manager.current_mut());
        }
    }

    /// Update the engine
    fn frame_update(&mut self, platform_context: PlatformContext) {
        self.scene_manager.current_mut().resources.get_mut::<DebugUIBuffer>().unwrap().reset_buffer();
        self.resources.insert(platform_context);

        for system in self.system_manager.systems.values_mut() {
            system.frame_update(&mut self.resources, &mut self.scene_manager.current_mut());
        }
    }

    fn fixed_update(&mut self, platform_context: PlatformContext) {
        self.resources.insert(platform_context);
        for system in self.system_manager.systems.values_mut() {
            system.fixed_update(&mut self.resources, &mut self.scene_manager.current_mut());
        }
    }

    fn handle_event(&mut self, platform_context: PlatformContext) {
        self.resources.get_mut::<InputState>().unwrap().handle_event(&platform_context.current_event);
        self.resources.insert(platform_context);
        for system in self.system_manager.systems.values_mut() {
            system.handle_event(&mut self.resources, &mut self.scene_manager.current_mut());
        }
    }

    // pub fn build_system_context(&mut self) -> SystemContext {
    //     SystemContext {
    //         scene: self.scene_manager.current_mut(),
    //     }
    // }

    fn current_scene_mut(&mut self) -> &mut Scene {
        self.scene_manager.current_mut()
    }

    fn current_scene(&self) -> &Scene {
        self.scene_manager.current()
    }

    fn get_debug_ui_buffer(&self) -> &DebugUIBuffer {
        self.scene_manager.current().resources.get::<DebugUIBuffer>().unwrap()
    }

    fn reset_debug_ui_buffer(&mut self) {
        self.scene_manager.current_mut().resources.get_mut::<DebugUIBuffer>().unwrap().reset_buffer();
    }

    // fn scene_and_debug_ui_buffer_mut(&mut self) -> (&mut Scene, &DebugUIBuffer) {
    //     let (sm, dub) = (&mut self.scene_manager, self.scene_manager.current().resources.get::<DebugUIBuffer>().unwrap());
    //     (sm.current_mut(), dub)
    // }
}