use alloc::{collections::BTreeMap,
            format,
            string::{String, ToString},
            vec::Vec};
use core::{option::NoneError, slice, str};

use core_io::{Error as IoError, Write};
use cslice::AsCSlice;
use dma::{Error as DmaError, Manager as DmaManager};
use io::{Cursor, ProtoWrite};
use ksupport::{eh_artiq, kernel, rpc};
use libboard_artiq::{drtio_routing::RoutingTable,
                     drtioaux,
                     drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE, SAT_PAYLOAD_MAX_SIZE},
                     pl::csr};
use libboard_zynq::{time::Milliseconds, timer::GlobalTimer};
use libcortex_a9::sync_channel::Receiver;
use log::warn;
use routing::{Router, SliceMeta, Sliceable};

#[derive(Debug, Clone, PartialEq)]
enum KernelState {
    Absent,
    Loaded,
    Running,
    MsgAwait {
        max_time: Option<Milliseconds>,
        id: u32,
        tags: Vec<u8>,
    },
    MsgSending,
    SubkernelAwaitLoad,
    SubkernelAwaitFinish {
        max_time: Option<Milliseconds>,
        id: u32,
    },
    DmaUploading,
    DmaPendingPlayback {
        id: u32,
        timestamp: u64,
    },
    DmaPendingAwait {
        id: u32,
        timestamp: u64,
        max_time: Milliseconds,
    },
    DmaAwait {
        max_time: Milliseconds,
    },
}

#[derive(Debug)]
pub enum Error {
    Load(String),
    KernelNotFound,
    Unexpected(String),
    NoMessage,
    AwaitingMessage,
    SubkernelIoError,
    DrtioError,
    KernelException(Sliceable),
    DmaError(DmaError),
}

impl From<NoneError> for Error {
    fn from(_: NoneError) -> Error {
        Error::KernelNotFound
    }
}

impl From<IoError> for Error {
    fn from(_value: IoError) -> Error {
        Error::SubkernelIoError
    }
}

impl From<DmaError> for Error {
    fn from(value: DmaError) -> Error {
        Error::DmaError(value)
    }
}

impl From<()> for Error {
    fn from(_: ()) -> Error {
        Error::NoMessage
    }
}

impl From<drtioaux::Error> for Error {
    fn from(_value: drtioaux::Error) -> Error {
        Error::DrtioError
    }
}

macro_rules! unexpected {
    ($($arg:tt)*) => (return Err(Error::Unexpected(format!($($arg)*))));
}

/* represents interkernel messages */
struct Message {
    count: u8,
    id: u32,
    data: Vec<u8>,
}

#[derive(PartialEq)]
enum OutMessageState {
    NoMessage,
    MessageBeingSent,
    MessageSent,
    MessageAcknowledged,
}

/* for dealing with incoming and outgoing interkernel messages */
struct MessageManager {
    out_message: Option<Sliceable>,
    out_state: OutMessageState,
    in_queue: Vec<Message>,
    in_buffer: Option<Message>,
}

// Per-run state
struct Session {
    id: u32,
    kernel_state: KernelState,
    last_exception: Option<Sliceable>,
    messages: MessageManager,
    source: u8, // which destination requested running the kernel
    subkernels_finished: Vec<u32>,
}

impl Session {
    pub fn new(id: u32) -> Session {
        Session {
            id: id,
            kernel_state: KernelState::Absent,
            last_exception: None,
            messages: MessageManager::new(),
            source: 0,
            subkernels_finished: Vec::new(),
        }
    }

    fn running(&self) -> bool {
        match self.kernel_state {
            KernelState::Absent | KernelState::Loaded => false,
            _ => true,
        }
    }
}

#[derive(Debug)]
struct KernelLibrary {
    library: Vec<u8>,
    complete: bool,
}

pub struct Manager<'a> {
    kernels: BTreeMap<u32, KernelLibrary>,
    session: Session,
    control: &'a mut kernel::Control,
    cache: BTreeMap<String, Vec<i32>>,
    last_finished: Option<SubkernelFinished>,
}

pub struct SubkernelFinished {
    pub id: u32,
    pub with_exception: bool,
    pub exception_source: u8,
    pub source: u8,
}

impl MessageManager {
    pub fn new() -> MessageManager {
        MessageManager {
            out_message: None,
            out_state: OutMessageState::NoMessage,
            in_queue: Vec::new(),
            in_buffer: None,
        }
    }

    pub fn handle_incoming(
        &mut self,
        status: PayloadStatus,
        id: u32,
        length: usize,
        data: &[u8; MASTER_PAYLOAD_MAX_SIZE],
    ) {
        // called when receiving a message from master
        if status.is_first() {
            self.in_buffer = None;
        }
        match self.in_buffer.as_mut() {
            Some(message) => message.data.extend(&data[..length]),
            None => {
                self.in_buffer = Some(Message {
                    count: data[0],
                    id: id,
                    data: data[1..length].to_vec(),
                });
            }
        };
        if status.is_last() {
            // when done, remove from working queue
            self.in_queue.push(self.in_buffer.take().unwrap());
        }
    }

    pub fn was_message_acknowledged(&mut self) -> bool {
        match self.out_state {
            OutMessageState::MessageAcknowledged => {
                self.out_state = OutMessageState::NoMessage;
                true
            }
            _ => false,
        }
    }

    pub fn get_outgoing_slice(&mut self, data_slice: &mut [u8; MASTER_PAYLOAD_MAX_SIZE]) -> Option<SliceMeta> {
        if self.out_state != OutMessageState::MessageBeingSent {
            return None;
        }
        let meta = self.out_message.as_mut()?.get_slice_master(data_slice);
        if meta.status.is_last() {
            // clear the message slot
            self.out_message = None;
            // notify kernel with a flag that message is sent
            self.out_state = OutMessageState::MessageSent;
        }
        Some(meta)
    }

    pub fn ack_slice(&mut self) -> bool {
        // returns whether or not there's more to be sent
        match self.out_state {
            OutMessageState::MessageBeingSent => true,
            OutMessageState::MessageSent => {
                self.out_state = OutMessageState::MessageAcknowledged;
                false
            }
            _ => {
                warn!("received unsolicited SubkernelMessageAck");
                false
            }
        }
    }

    pub fn accept_outgoing(
        &mut self,
        id: u32,
        self_destination: u8,
        destination: u8,
        message: Vec<u8>,
        routing_table: &RoutingTable,
        rank: u8,
        router: &mut Router,
    ) -> Result<(), Error> {
        self.out_message = Some(Sliceable::new(destination, message));

        let mut data_slice: [u8; MASTER_PAYLOAD_MAX_SIZE] = [0; MASTER_PAYLOAD_MAX_SIZE];
        self.out_state = OutMessageState::MessageBeingSent;
        let meta = self.get_outgoing_slice(&mut data_slice).unwrap();
        router.route(
            drtioaux::Packet::SubkernelMessage {
                source: self_destination,
                destination: destination,
                id: id,
                status: meta.status,
                length: meta.len as u16,
                data: data_slice,
            },
            routing_table,
            rank,
            self_destination,
        );
        Ok(())
    }

    pub fn get_incoming(&mut self, id: u32) -> Option<Message> {
        for i in 0..self.in_queue.len() {
            if self.in_queue[i].id == id {
                return Some(self.in_queue.remove(i));
            }
        }
        None
    }
}

impl<'a> Manager<'_> {
    pub fn new(control: &mut kernel::Control) -> Manager {
        Manager {
            kernels: BTreeMap::new(),
            session: Session::new(0),
            control: control,
            cache: BTreeMap::new(),
            last_finished: None,
        }
    }

    pub fn add(&mut self, id: u32, status: PayloadStatus, data: &[u8], data_len: usize) -> Result<(), Error> {
        let kernel = match self.kernels.get_mut(&id) {
            Some(kernel) => {
                if kernel.complete || status.is_first() {
                    // replace entry
                    self.kernels.remove(&id);
                    self.kernels.insert(
                        id,
                        KernelLibrary {
                            library: Vec::new(),
                            complete: false,
                        },
                    );
                    self.kernels.get_mut(&id)?
                } else {
                    kernel
                }
            }
            None => {
                self.kernels.insert(
                    id,
                    KernelLibrary {
                        library: Vec::new(),
                        complete: false,
                    },
                );
                self.kernels.get_mut(&id)?
            }
        };
        kernel.library.extend(&data[0..data_len]);

        kernel.complete = status.is_last();
        Ok(())
    }

    pub fn running(&self) -> bool {
        self.session.running()
    }

    pub fn get_current_id(&self) -> Option<u32> {
        match self.running() {
            true => Some(self.session.id),
            false => None,
        }
    }

    pub fn run(&mut self, source: u8, id: u32) -> Result<(), Error> {
        if self.session.kernel_state != KernelState::Loaded || self.session.id != id {
            self.load(id)?;
        }
        self.session.kernel_state = KernelState::Running;
        self.session.source = source;
        unsafe {
            csr::cri_con::selected_write(2);
        }

        self.control.tx.send(kernel::Message::StartRequest);
        Ok(())
    }

    pub fn message_handle_incoming(
        &mut self,
        status: PayloadStatus,
        id: u32,
        length: usize,
        slice: &[u8; MASTER_PAYLOAD_MAX_SIZE],
    ) {
        if !self.running() {
            return;
        }
        self.session.messages.handle_incoming(status, id, length, slice);
    }

    pub fn message_get_slice(&mut self, slice: &mut [u8; MASTER_PAYLOAD_MAX_SIZE]) -> Option<SliceMeta> {
        if !self.running() {
            return None;
        }
        self.session.messages.get_outgoing_slice(slice)
    }

    pub fn message_ack_slice(&mut self) -> bool {
        if !self.running() {
            warn!("received unsolicited SubkernelMessageAck");
            return false;
        }
        self.session.messages.ack_slice()
    }

    pub fn load(&mut self, id: u32) -> Result<(), Error> {
        if self.session.id == id && self.session.kernel_state == KernelState::Loaded {
            return Ok(());
        }
        if !self.kernels.get(&id)?.complete {
            return Err(Error::KernelNotFound);
        }
        self.session = Session::new(id);
        self.control.restart();

        self.control
            .tx
            .send(kernel::Message::LoadRequest(self.kernels.get(&id)?.library.clone()));
        let reply = self.control.rx.recv();
        match reply {
            kernel::Message::LoadCompleted => Ok(()),
            kernel::Message::LoadFailed => Err(Error::Load("kernel load failed".to_string())),
            _ => Err(Error::Load(format!(
                "unexpected kernel CPU reply to load request: {:?}",
                reply
            ))),
        }
    }

    pub fn exception_get_slice(&mut self, data_slice: &mut [u8; SAT_PAYLOAD_MAX_SIZE]) -> SliceMeta {
        match self.session.last_exception.as_mut() {
            Some(exception) => exception.get_slice_sat(data_slice),
            None => SliceMeta {
                destination: 0,
                len: 0,
                status: PayloadStatus::FirstAndLast,
            },
        }
    }

    fn kernel_stop(&mut self) {
        self.session.kernel_state = KernelState::Absent;
        unsafe {
            csr::cri_con::selected_write(0);
        }
    }

    fn runtime_exception(&mut self, cause: Error) {
        let raw_exception: Vec<u8> = Vec::new();
        let mut writer = Cursor::new(raw_exception);
        match write_exception(
            &mut writer,
            &[Some(eh_artiq::Exception {
                id: 11, // SubkernelError, defined in ksupport
                message: format!("in subkernel id {}: {:?}", self.session.id, cause).as_c_slice(),
                param: [0, 0, 0],
                file: file!().as_c_slice(),
                line: line!(),
                column: column!(),
                function: format!("subkernel id {}", self.session.id).as_c_slice(),
            })],
            &[eh_artiq::StackPointerBacktrace {
                stack_pointer: 0,
                initial_backtrace_size: 0,
                current_backtrace_size: 0,
            }],
            &[],
            0,
        ) {
            Ok(_) => self.session.last_exception = Some(Sliceable::new(0, writer.into_inner())),
            Err(_) => error!("Error writing exception data"),
        }
        self.kernel_stop();
    }

    pub fn ddma_finished(&mut self, error: u8, channel: u32, timestamp: u64) {
        if let KernelState::DmaAwait { .. } = self.session.kernel_state {
            self.control.tx.send(kernel::Message::DmaAwaitRemoteReply {
                timeout: false,
                error: error,
                channel: channel,
                timestamp: timestamp,
            });
            self.session.kernel_state = KernelState::Running;
        }
    }

    pub fn ddma_nack(&mut self) {
        // for simplicity treat it as a timeout...
        if let KernelState::DmaAwait { .. } = self.session.kernel_state {
            self.control.tx.send(kernel::Message::DmaAwaitRemoteReply {
                timeout: true,
                error: 0,
                channel: 0,
                timestamp: 0,
            });
            self.session.kernel_state = KernelState::Running;
        }
    }

    pub fn ddma_remote_uploaded(&mut self, succeeded: bool) -> Option<(u32, u64)> {
        // returns a tuple of id, timestamp in case a playback needs to be started immediately
        if !succeeded {
            self.kernel_stop();
            self.runtime_exception(Error::DmaError(DmaError::UploadFail));
        }
        let res = match self.session.kernel_state {
            KernelState::DmaPendingPlayback { id, timestamp } => {
                self.session.kernel_state = KernelState::Running;
                Some((id, timestamp))
            }
            KernelState::DmaPendingAwait {
                id,
                timestamp,
                max_time,
            } => {
                self.session.kernel_state = KernelState::DmaAwait { max_time: max_time };
                Some((id, timestamp))
            }
            KernelState::DmaUploading => {
                self.session.kernel_state = KernelState::Running;
                None
            }
            _ => None,
        };
        res
    }

    pub fn process_kern_requests(
        &mut self,
        router: &mut Router,
        routing_table: &RoutingTable,
        rank: u8,
        destination: u8,
        dma_manager: &mut DmaManager,
        timer: &GlobalTimer,
    ) {
        if let Some(subkernel_finished) = self.last_finished.take() {
            info!(
                "subkernel {} finished, with exception: {}",
                subkernel_finished.id, subkernel_finished.with_exception
            );
            router.route(
                drtioaux::Packet::SubkernelFinished {
                    destination: subkernel_finished.source,
                    id: subkernel_finished.id,
                    with_exception: subkernel_finished.with_exception,
                    exception_src: subkernel_finished.exception_source,
                },
                &routing_table,
                rank,
                destination,
            );
        }

        if !self.running() {
            return;
        }

        match self.process_external_messages(timer) {
            Ok(()) => (),
            Err(Error::AwaitingMessage) => return, // kernel still waiting, do not process kernel messages
            Err(Error::KernelException(exception)) => {
                self.session.last_exception = Some(exception);
                self.last_finished = Some(SubkernelFinished {
                    id: self.session.id,
                    with_exception: true,
                    exception_source: destination,
                    source: self.session.source,
                });
            }
            Err(e) => {
                error!("Error while running processing external messages: {:?}", e);
                self.runtime_exception(e);
                self.last_finished = Some(SubkernelFinished {
                    id: self.session.id,
                    with_exception: true,
                    exception_source: destination,
                    source: self.session.source,
                });
            }
        }

        match self.process_kern_message(router, routing_table, rank, destination, dma_manager, timer) {
            Ok(true) => {
                self.last_finished = Some(SubkernelFinished {
                    id: self.session.id,
                    with_exception: false,
                    exception_source: 0,
                    source: self.session.source,
                });
            }
            Ok(false) | Err(Error::NoMessage) => (),
            Err(Error::KernelException(exception)) => {
                self.session.last_exception = Some(exception);
                self.last_finished = Some(SubkernelFinished {
                    id: self.session.id,
                    with_exception: true,
                    exception_source: destination,
                    source: self.session.source,
                });
            }
            Err(e) => {
                error!("Error while running kernel: {:?}", e);
                self.runtime_exception(e);
                self.last_finished = Some(SubkernelFinished {
                    id: self.session.id,
                    with_exception: true,
                    exception_source: destination,
                    source: self.session.source,
                });
            }
        }
    }

    pub fn subkernel_load_run_reply(&mut self, succeeded: bool) {
        if self.session.kernel_state == KernelState::SubkernelAwaitLoad {
            self.control
                .tx
                .send(kernel::Message::SubkernelLoadRunReply { succeeded: succeeded });
            self.session.kernel_state = KernelState::Running;
        } else {
            warn!("received unsolicited SubkernelLoadRunReply");
        }
    }

    pub fn remote_subkernel_finished(&mut self, id: u32, with_exception: bool, exception_source: u8) {
        if with_exception {
            self.kernel_stop();
            self.last_finished = Some(SubkernelFinished {
                source: self.session.source,
                id: self.session.id,
                with_exception: true,
                exception_source: exception_source,
            })
        } else {
            self.session.subkernels_finished.push(id);
        }
    }

    fn process_kern_message(
        &mut self,
        router: &mut Router,
        routing_table: &RoutingTable,
        rank: u8,
        self_destination: u8,
        dma_manager: &mut DmaManager,
        timer: &GlobalTimer,
    ) -> Result<bool, Error> {
        let reply = self.control.rx.try_recv()?;
        match reply {
            kernel::Message::KernelFinished(_async_errors) => {
                self.kernel_stop();
                dma_manager.cleanup(router, rank, self_destination, routing_table);
                return Ok(true);
            }
            kernel::Message::KernelException(exceptions, stack_pointers, backtrace, async_errors) => {
                error!("exception in kernel");
                for exception in exceptions {
                    error!("{:?}", exception.unwrap());
                }
                error!("stack pointers: {:?}", stack_pointers);
                error!("backtrace: {:?}", backtrace);
                let buf: Vec<u8> = Vec::new();
                let mut writer = Cursor::new(buf);
                match write_exception(&mut writer, exceptions, stack_pointers, backtrace, async_errors) {
                    Ok(()) => (),
                    Err(_) => error!("Error writing exception data"),
                }
                self.kernel_stop();
                return Err(Error::KernelException(Sliceable::new(0, writer.into_inner())));
            }
            kernel::Message::CachePutRequest(key, value) => {
                self.cache.insert(key, value);
            }
            kernel::Message::CacheGetRequest(key) => {
                const DEFAULT: Vec<i32> = Vec::new();
                let value = self.cache.get(&key).unwrap_or(&DEFAULT).clone();
                self.control.tx.send(kernel::Message::CacheGetReply(value));
            }

            kernel::Message::DmaPutRequest(recorder) => {
                // ddma is always used on satellites
                if let Ok(id) = dma_manager.put_record(recorder, self_destination) {
                    dma_manager.upload_traces(id, router, rank, self_destination, routing_table)?;
                    self.session.kernel_state = KernelState::DmaUploading;
                } else {
                    unexpected!("DMAError: found an unsupported call to RTIO devices on master")
                }
            }
            kernel::Message::DmaEraseRequest(name) => {
                dma_manager.erase_name(&name, router, rank, self_destination, routing_table);
            }
            kernel::Message::DmaGetRequest(name) => {
                let dma_meta = dma_manager.retrieve(self_destination, &name);
                self.control.tx.send(kernel::Message::DmaGetReply(dma_meta));
            }
            kernel::Message::DmaStartRemoteRequest { id, timestamp } => {
                if self.session.kernel_state != KernelState::DmaUploading {
                    dma_manager.playback_remote(
                        id as u32,
                        timestamp as u64,
                        router,
                        rank,
                        self_destination,
                        routing_table,
                    )?;
                } else {
                    self.session.kernel_state = KernelState::DmaPendingPlayback {
                        id: id as u32,
                        timestamp: timestamp as u64,
                    };
                }
            }
            kernel::Message::DmaAwaitRemoteRequest(_id) => {
                let max_time = timer.get_time() + Milliseconds(10000);
                self.session.kernel_state = match self.session.kernel_state {
                    // if we are still waiting for the traces to be uploaded, extend the state by timeout
                    KernelState::DmaPendingPlayback { id, timestamp } => KernelState::DmaPendingAwait {
                        id: id,
                        timestamp: timestamp,
                        max_time: max_time,
                    },
                    _ => KernelState::DmaAwait { max_time: max_time },
                };
            }

            kernel::Message::SubkernelMsgSend {
                id: _id,
                destination: msg_dest,
                data,
            } => {
                let msg_dest = msg_dest.or(Some(self.session.source)).unwrap();
                self.session.messages.accept_outgoing(
                    self.session.id,
                    self_destination,
                    msg_dest,
                    data,
                    routing_table,
                    rank,
                    router,
                )?;
                self.session.kernel_state = KernelState::MsgSending;
            }
            kernel::Message::SubkernelMsgRecvRequest { id, timeout, tags } => {
                let id = if id == -1 { self.session.id } else { id as u32 };
                let max_time = if timeout > 0 {
                    Some(timer.get_time() + Milliseconds(timeout as u64))
                } else {
                    None
                };
                self.session.kernel_state = KernelState::MsgAwait {
                    max_time: max_time,
                    id: id,
                    tags: tags,
                };
            }
            kernel::Message::SubkernelLoadRunRequest {
                id,
                destination: sk_destination,
                run,
            } => {
                self.session.kernel_state = KernelState::SubkernelAwaitLoad;
                router.route(
                    drtioaux::Packet::SubkernelLoadRunRequest {
                        source: self_destination,
                        destination: sk_destination,
                        id: id,
                        run: run,
                    },
                    routing_table,
                    rank,
                    self_destination,
                );
            }

            kernel::Message::SubkernelAwaitFinishRequest { id, timeout } => {
                let max_time = if timeout > 0 {
                    Some(timer.get_time() + Milliseconds(timeout as u64))
                } else {
                    None
                };
                self.session.kernel_state = KernelState::SubkernelAwaitFinish {
                    max_time: max_time,
                    id: id,
                };
            }
            kernel::Message::UpDestinationsRequest(destination) => {
                self.control.tx.send(kernel::Message::UpDestinationsReply(
                    destination == (self_destination as i32),
                ));
            }
            _ => {
                unexpected!("unexpected message from core1 while kernel was running: {:?}", reply);
            }
        }
        Ok(false)
    }

    fn process_external_messages(&mut self, timer: &GlobalTimer) -> Result<(), Error> {
        match &self.session.kernel_state {
            KernelState::MsgAwait { max_time, id, tags } => {
                if let Some(max_time) = *max_time {
                    if timer.get_time() > max_time {
                        self.control.tx.send(kernel::Message::SubkernelMsgRecvReply {
                            status: kernel::SubkernelStatus::Timeout,
                            count: 0,
                        });
                        self.session.kernel_state = KernelState::Running;
                        return Ok(());
                    }
                }
                if let Some(message) = self.session.messages.get_incoming(*id) {
                    self.control.tx.send(kernel::Message::SubkernelMsgRecvReply {
                        status: kernel::SubkernelStatus::NoError,
                        count: message.count,
                    });
                    let tags = tags.clone();
                    self.session.kernel_state = KernelState::Running;
                    self.pass_message_to_kernel(&message, tags, timer)
                } else {
                    Err(Error::AwaitingMessage)
                }
            }
            KernelState::MsgSending => {
                if self.session.messages.was_message_acknowledged() {
                    self.session.kernel_state = KernelState::Running;
                    self.control.tx.send(kernel::Message::SubkernelMsgSent);
                    Ok(())
                } else {
                    Err(Error::AwaitingMessage)
                }
            }
            KernelState::SubkernelAwaitFinish { max_time, id } => {
                if let Some(max_time) = *max_time {
                    if timer.get_time() > max_time {
                        self.control.tx.send(kernel::Message::SubkernelAwaitFinishReply {
                            status: kernel::SubkernelStatus::Timeout,
                        });
                        self.session.kernel_state = KernelState::Running;
                        return Ok(());
                    }
                }
                let mut i = 0;
                for status in &self.session.subkernels_finished {
                    if *status == *id {
                        self.control.tx.send(kernel::Message::SubkernelAwaitFinishReply {
                            status: kernel::SubkernelStatus::NoError,
                        });
                        self.session.kernel_state = KernelState::Running;
                        self.session.subkernels_finished.swap_remove(i);
                        break;
                    }
                    i += 1;
                }
                Ok(())
            }
            KernelState::DmaAwait { max_time } | KernelState::DmaPendingAwait { max_time, .. } => {
                if timer.get_time() > *max_time {
                    self.control.tx.send(kernel::Message::DmaAwaitRemoteReply {
                        timeout: true,
                        error: 0,
                        channel: 0,
                        timestamp: 0,
                    });
                    self.session.kernel_state = KernelState::Running;
                }
                Ok(())
            }
            _ => Ok(()),
        }
    }

    fn pass_message_to_kernel(&mut self, message: &Message, tags: Vec<u8>, timer: &GlobalTimer) -> Result<(), Error> {
        let mut reader = Cursor::new(&message.data);
        let mut current_tags: &[u8] = &tags;
        let mut i = message.count;
        loop {
            let slot = match recv_w_timeout(&mut self.control.rx, timer, 100)? {
                kernel::Message::RpcRecvRequest(slot) => slot,
                other => unexpected!("expected root value slot from core1, not {:?}", other),
            };
            let mut exception: Option<Sliceable> = None;
            let mut unexpected: Option<String> = None;
            let remaining_tags = rpc::recv_return(&mut reader, current_tags, slot, &mut |size| {
                if size == 0 {
                    0 as *mut ()
                } else {
                    self.control.tx.send(kernel::Message::RpcRecvReply(Ok(size)));
                    match recv_w_timeout(&mut self.control.rx, timer, 100) {
                        Ok(kernel::Message::RpcRecvRequest(slot)) => slot,
                        Ok(kernel::Message::KernelException(exceptions, stack_pointers, backtrace, async_errors)) => {
                            let buf: Vec<u8> = Vec::new();
                            let mut writer = Cursor::new(buf);
                            match write_exception(&mut writer, exceptions, stack_pointers, backtrace, async_errors) {
                                Ok(()) => {
                                    exception = Some(Sliceable::new(0, writer.into_inner()));
                                }
                                Err(_) => {
                                    unexpected = Some("Error writing exception data".to_string());
                                }
                            };
                            0 as *mut ()
                        }
                        other => {
                            unexpected = Some(format!("expected nested value slot from kernel CPU, not {:?}", other));
                            0 as *mut ()
                        }
                    }
                }
            })?;
            if let Some(exception) = exception {
                self.kernel_stop();
                return Err(Error::KernelException(exception));
            } else if let Some(unexpected) = unexpected {
                self.kernel_stop();
                unexpected!("{}", unexpected);
            }
            self.control.tx.send(kernel::Message::RpcRecvReply(Ok(0)));
            i -= 1;
            if i == 0 {
                break;
            } else {
                current_tags = remaining_tags;
            }
        }
        Ok(())
    }
}

fn write_exception<W>(
    writer: &mut W,
    exceptions: &[Option<eh_artiq::Exception>],
    stack_pointers: &[eh_artiq::StackPointerBacktrace],
    backtrace: &[(usize, usize)],
    async_errors: u8,
) -> Result<(), Error>
where
    W: Write + ?Sized,
{
    /* header */
    writer.write_bytes(&[0x5a, 0x5a, 0x5a, 0x5a, /*Reply::KernelException*/ 9])?;
    writer.write_u32(exceptions.len() as u32)?;
    for exception in exceptions.iter() {
        let exception = exception.as_ref().unwrap();
        writer.write_u32(exception.id)?;

        if exception.message.len() == usize::MAX {
            // exception with host string
            writer.write_u32(u32::MAX)?;
            writer.write_u32(exception.message.as_ptr() as u32)?;
        } else {
            let msg =
                str::from_utf8(unsafe { slice::from_raw_parts(exception.message.as_ptr(), exception.message.len()) })
                    .unwrap()
                    .replace(
                        "{rtio_channel_info:0}",
                        &format!(
                            "0x{:04x}:{}",
                            exception.param[0],
                            ksupport::resolve_channel_name(exception.param[0] as u32)
                        ),
                    );
            writer.write_string(&msg)?;
        }
        writer.write_u64(exception.param[0] as u64)?;
        writer.write_u64(exception.param[1] as u64)?;
        writer.write_u64(exception.param[2] as u64)?;
        writer.write_bytes(exception.file.as_ref())?;
        writer.write_u32(exception.line)?;
        writer.write_u32(exception.column)?;
        writer.write_bytes(exception.function.as_ref())?;
    }

    for sp in stack_pointers.iter() {
        writer.write_u32(sp.stack_pointer as u32)?;
        writer.write_u32(sp.initial_backtrace_size as u32)?;
        writer.write_u32(sp.current_backtrace_size as u32)?;
    }
    writer.write_u32(backtrace.len() as u32)?;
    for &(addr, sp) in backtrace {
        writer.write_u32(addr as u32)?;
        writer.write_u32(sp as u32)?;
    }
    writer.write_u8(async_errors as u8)?;
    Ok(())
}

fn recv_w_timeout(
    rx: &mut Receiver<'_, kernel::Message>,
    timer: &GlobalTimer,
    timeout: u64,
) -> Result<kernel::Message, Error> {
    let max_time = timer.get_time() + Milliseconds(timeout);
    while timer.get_time() < max_time {
        match rx.try_recv() {
            Err(_) => (),
            Ok(message) => return Ok(message),
        }
    }
    Err(Error::NoMessage)
}