use crate::CrashReport;
use crate::os::SystemOS;
use crate::{RenderWorkerConfig, RenderWorkerController};
use prometeu_hal::app_mode::AppMode;
use prometeu_hal::cartridge::Cartridge;
use prometeu_hal::telemetry::{CertificationConfig, TelemetryFrame};
use prometeu_hal::{
    FrameId, InputSignals, RenderWorkerBackend, RenderWorkerError, RenderWorkerFrameSink,
    RuntimePlatform,
};
use prometeu_vm::VirtualMachine;
use std::sync::atomic::Ordering;

pub struct VmFacade<'a> {
    pub(in crate::os) os: &'a mut SystemOS,
}

impl<'a> VmFacade<'a> {
    pub fn initialize(
        &mut self,
        vm: &mut VirtualMachine,
        cartridge: &Cartridge,
    ) -> Result<(), CrashReport> {
        self.os.clear_cartridge_service_state();
        self.os.vm_runtime.initialize_vm(&mut self.os.log_service, vm, cartridge)
    }

    pub fn tick(
        &mut self,
        vm: &mut VirtualMachine,
        signals: &InputSignals,
        platform: &mut dyn RuntimePlatform,
    ) -> Option<CrashReport> {
        self.os.vm_runtime.tick(
            &mut self.os.log_service,
            &mut self.os.fs,
            &mut self.os.fs_state,
            &mut self.os.memcard,
            &mut self.os.open_files,
            &mut self.os.next_handle,
            vm,
            signals,
            platform,
        )
    }

    pub fn reset(&mut self, vm: &mut VirtualMachine) {
        self.os.vm_runtime.reset(vm);
    }

    pub fn debug_step_instruction(
        &mut self,
        vm: &mut VirtualMachine,
        platform: &mut dyn RuntimePlatform,
    ) -> Option<CrashReport> {
        self.os.vm_runtime.debug_step_instruction(&mut self.os.log_service, vm, platform)
    }

    pub fn paused(&self) -> bool {
        self.os.vm_runtime.paused
    }

    pub fn set_paused(&mut self, paused: bool) {
        self.os.vm_runtime.paused = paused;
    }

    pub fn set_inspection_active(&mut self, active: bool) {
        self.os.vm_runtime.inspection_active = active;
    }

    pub fn request_debug_step(&mut self) {
        self.os.vm_runtime.debug_step_request = true;
    }

    pub fn debug_step_requested(&self) -> bool {
        self.os.vm_runtime.debug_step_request
    }

    pub fn logical_frame_active(&self) -> bool {
        self.os.vm_runtime.logical_frame_active
    }

    pub fn tick_index(&self) -> u64 {
        self.os.vm_runtime.tick_index
    }

    pub fn logical_frame_index(&self) -> u64 {
        self.os.vm_runtime.logical_frame_index
    }

    pub fn last_frame_cpu_time_us(&self) -> u64 {
        self.os.vm_runtime.last_frame_cpu_time_us
    }

    pub fn completed_logical_frames(&self) -> u64 {
        self.os.vm_runtime.atomic_telemetry.completed_logical_frames.load(Ordering::Relaxed).into()
    }

    pub fn telemetry_snapshot(&self) -> TelemetryFrame {
        self.os.vm_runtime.atomic_telemetry.snapshot()
    }

    pub fn start_render_worker<B, S>(&mut self, config: RenderWorkerConfig, backend: B, sink: S)
    where
        B: RenderWorkerBackend,
        S: RenderWorkerFrameSink,
    {
        self.os.vm_runtime.start_render_worker(config, backend, sink);
    }

    pub fn stop_render_worker(&mut self) -> Result<(), RenderWorkerError> {
        self.os.vm_runtime.stop_render_worker()
    }

    pub fn render_worker_controller(&self) -> Option<&RenderWorkerController> {
        self.os.vm_runtime.render_worker_controller.as_ref()
    }

    pub fn record_repeated_render_worker_frame(&self, frame_id: FrameId) {
        self.os.vm_runtime.record_repeated_render_worker_frame(frame_id);
    }

    pub fn cert_config(&self) -> &CertificationConfig {
        &self.os.vm_runtime.certifier.config
    }

    pub fn last_crash_report(&self) -> Option<&CrashReport> {
        self.os.vm_runtime.last_crash_report.as_ref()
    }

    pub fn current_app_id(&self) -> u32 {
        self.os.vm_runtime.current_app_id
    }

    pub fn current_cartridge_title(&self) -> String {
        self.os.vm_runtime.current_cartridge_title.clone()
    }

    pub fn current_cartridge_app_version(&self) -> String {
        self.os.vm_runtime.current_cartridge_app_version.clone()
    }

    pub fn current_cartridge_app_mode(&self) -> AppMode {
        self.os.vm_runtime.current_cartridge_app_mode
    }
}