// Copyright 2024 The ChromiumOS Authors

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

//! Virtio console device control queue handling.

use std::collections::VecDeque;

use std::io::Write;

use anyhow::anyhow;

use anyhow::Context;

use base::debug;

use base::error;

use zerocopy::IntoBytes;

use crate::virtio::console::worker::WorkerPort;

use crate::virtio::device_constants::console::virtio_console_control;

use crate::virtio::device_constants::console::VIRTIO_CONSOLE_CONSOLE_PORT;

use crate::virtio::device_constants::console::VIRTIO_CONSOLE_DEVICE_ADD;

use crate::virtio::device_constants::console::VIRTIO_CONSOLE_DEVICE_READY;

use crate::virtio::device_constants::console::VIRTIO_CONSOLE_PORT_NAME;

use crate::virtio::device_constants::console::VIRTIO_CONSOLE_PORT_OPEN;

use crate::virtio::device_constants::console::VIRTIO_CONSOLE_PORT_READY;

use crate::virtio::Queue;

use crate::virtio::Reader;

pub type ControlMsgBytes = Box<[u8]>;

fn control_msg(id: u32, event: u16, value: u16, extra_bytes: &[u8]) -> ControlMsgBytes {

    virtio_console_control {

        id: id.into(),

        event: event.into(),

        value: value.into(),

    }

    .as_bytes()

    .iter()

    .chain(extra_bytes.iter())

    .copied()

    .collect()

}

fn process_control_msg(

    reader: &mut Reader,

    ports: &[WorkerPort],

    pending_receive_control_msgs: &mut VecDeque<ControlMsgBytes>,

) -> anyhow::Result<()> {

    let ctrl_msg: virtio_console_control =

        reader.read_obj().context("failed to read from reader")?;

    let id = ctrl_msg.id.to_native();

    let event = ctrl_msg.event.to_native();

    let value = ctrl_msg.value.to_native();

    match event {

        VIRTIO_CONSOLE_DEVICE_READY => {

            // value of 1 indicates success, and 0 indicates failure

            if value != 1 {

                return Err(anyhow!("console device ready failure ({value})"));

            }

            for (index, port) in ports.iter().enumerate() {

                let port_id = index as u32;

                // TODO(dverkamp): cap the size of `pending_receive_control_msgs` somehow

                pending_receive_control_msgs.push_back(control_msg(

                    port_id,

                    VIRTIO_CONSOLE_DEVICE_ADD,

                    0,

                    &[],

                ));

                if let Some(name) = port.name() {

                    pending_receive_control_msgs.push_back(control_msg(

                        port_id,

                        VIRTIO_CONSOLE_PORT_NAME,

                        0,

                        name.as_bytes(),

                    ));

                }

            }

            Ok(())

        }

        VIRTIO_CONSOLE_PORT_READY => {

            // value of 1 indicates success, and 0 indicates failure

            if value != 1 {

                return Err(anyhow!("console port{id} ready failure ({value})"));

            }

            let port = ports

                .get(id as usize)

                .with_context(|| format!("invalid port id {id}"))?;

            pending_receive_control_msgs.push_back(control_msg(

                id,

                VIRTIO_CONSOLE_PORT_OPEN,

                1,

                &[],

            ));

            if port.is_console() {

                pending_receive_control_msgs.push_back(control_msg(

                    id,

                    VIRTIO_CONSOLE_CONSOLE_PORT,

                    1,

                    &[],

                ));

            }

            Ok(())

        }

        VIRTIO_CONSOLE_PORT_OPEN => {

            match value {

                // Currently, port state change is not supported, default is open.

                // And only print debug info here.

                0 => debug!("console port{id} close"),

                1 => debug!("console port{id} open"),

                _ => error!("console port{id} unknown value {value}"),

            }

            Ok(())

        }

        _ => Err(anyhow!("unexpected control event {}", event)),

    }

}

pub fn process_control_transmit_queue(

    queue: &mut Queue,

    ports: &[WorkerPort],

    pending_receive_control_msgs: &mut VecDeque<ControlMsgBytes>,

) {

    let mut needs_interrupt = false;

    while let Some(mut avail_desc) = queue.pop() {

        if let Err(e) =

            process_control_msg(&mut avail_desc.reader, ports, pending_receive_control_msgs)

        {

            error!("failed to handle control msg: {:#}", e);

        }

        queue.add_used(avail_desc);

        needs_interrupt = true;

    }

    if needs_interrupt {

        queue.trigger_interrupt();

    }

}

pub fn process_control_receive_queue(

    queue: &mut Queue,

    pending_receive_control_msgs: &mut VecDeque<ControlMsgBytes>,

) {

    let mut needs_interrupt = false;

    while !pending_receive_control_msgs.is_empty() {

        let Some(mut avail_desc) = queue.pop() else {

            break;

        };

        // Get a reply to copy into `avail_desc`. This should never fail since we check that

        // `pending_receive_control_msgs` is not empty in the loop condition.

        let reply = pending_receive_control_msgs

            .pop_front()

            .expect("missing reply");

        let len = match avail_desc.writer.write_all(&reply) {

            Ok(()) => avail_desc.writer.bytes_written() as u32,

            Err(e) => {

                error!("failed to write control receiveq reply: {}", e);

                0

            }

        };

        queue.add_used_with_bytes_written(avail_desc, len);

        needs_interrupt = true;

    }

    if needs_interrupt {

        queue.trigger_interrupt();

    }

}