use platform::Platform;

use crate::Kernel;

impl<P: Platform> Kernel<P> {
    pub fn handle_fault(
        &mut self,
        tid: types::id::ThreadId,
        fault: domain::fault::Fault,
        fault_pc: usize,
    ) {
        let pid = match self.threads.get(tid) {
            Ok(t) => t.process(),
            Err(_) => return,
        };

        // Try to deliver fault to a fault handler endpoint (if configured)
        if let Ok(process) = self.processes.get(pid) {
            if let Some(handler_slot) = process.fault_handler() {
                if let Ok(cap) = process.capabilities().get(handler_slot) {
                    if let domain::resource::Resource::Endpoint(ep_id) = cap.resource() {
                        let msg = domain::message::Message::from_words([
                            pid.raw() as usize,
                            fault.code(),
                            fault.address(),
                            fault_pc,
                        ]);

                        if let Some(ep) = self.endpoints.get_mut(*ep_id) {
                            if ep.has_waiting_receiver() {
                                if let Some(receiver_tid) = ep.dequeue_receiver() {
                                    self.pending_results[receiver_tid.raw() as usize] =
                                        Some(crate::SyscallResult::Message(msg));

                                    if let Ok(receiver) = self.threads.get_mut(receiver_tid) {
                                        let priority = receiver.priority();
                                        let _ = receiver.unblock();
                                        let core = self.platform.core_id();
                                        use domain::scheduler::Scheduler;
                                        self.scheduler.add(receiver_tid, priority, core);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        self.destroy_process(pid);
    }
}