/* Android console command implementation.
 *
 * Copyright (c) 2014 Linaro Limited
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2 or later, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "android-console.h"
#include "monitor/monitor.h"
#include "qemu/sockets.h"
#include "net/slirp.h"
#include "slirp/libslirp.h"
#include "qmp-commands.h"
#include "hw/misc/goldfish_battery.h"
#include "hw/input/goldfish_events.h"
#include "sysemu/sysemu.h"
#include "hmp.h"

typedef struct {
    int is_udp;
    int host_port;
    int guest_port;
} RedirRec;

GList *redir_list;

void android_monitor_print_error(Monitor *mon, const char *fmt, ...)
{
    /* Print an error (typically a syntax error from the parser), with
     * the required "KO: " prefix.
     */
    va_list ap;

    monitor_printf(mon, "KO: ");
    va_start(ap, fmt);
    monitor_vprintf(mon, fmt, ap);
    va_end(ap);
}

void android_console_kill(Monitor *mon, const QDict *qdict)
{
    monitor_printf(mon, "OK: killing emulator, bye bye\n");
    monitor_suspend(mon);
    qmp_quit(NULL);
}

void android_console_quit(Monitor *mon, const QDict *qdict)
{
    /* Don't print an OK response for success, just close the connection */
    if (monitor_disconnect(mon)) {
        monitor_printf(mon, "KO: this connection doesn't support quitting\n");
    }
}

#ifdef CONFIG_SLIRP
void android_console_redir_list(Monitor *mon, const QDict *qdict)
{
    if (!redir_list) {
        monitor_printf(mon, "no active redirections\n");
    } else {
        GList *l;

        for (l = redir_list; l; l = l->next) {
            RedirRec *r = l->data;

            monitor_printf(mon, "%s:%-5d => %-5d\n", r->is_udp ? "udp" : "tcp",
                           r->host_port, r->guest_port);
        }
    }
    monitor_printf(mon, "OK\n");
}

static int parse_proto(const char *s)
{
    if (!strcmp(s, "tcp")) {
        return 0;
    } else if (!strcmp(s, "udp")) {
        return 1;
    } else {
        return -1;
    }
}

static int parse_port(const char *s)
{
    char *end;
    int port;

    port = strtol(s, &end, 10);
    if (*end != 0 || port < 1 || port > 65535) {
        return 0;
    }
    return port;
}

void android_console_redir_add(Monitor *mon, const QDict *qdict)
{
    const char *arg = qdict_get_str(qdict, "arg");
    char **tokens;
    int is_udp, host_port, guest_port;
    Slirp *slirp;
    Error *err = NULL;
    struct in_addr host_addr = { .s_addr = htonl(INADDR_LOOPBACK) };
    struct in_addr guest_addr = { .s_addr = 0 };
    RedirRec *redir;

    slirp = net_slirp_lookup(NULL, NULL, &err);
    if (err) {
        monitor_printf(mon, "KO: %s\n", error_get_pretty(err));
        error_free(err);
        return;
    }

    /* Argument syntax: "proto:hostport:guestport" */
    tokens = g_strsplit(arg, ":", 0);

    if (g_strv_length(tokens) != 3) {
        goto fail_syntax;
    }

    is_udp = parse_proto(tokens[0]);
    host_port = parse_port(tokens[1]);
    guest_port = parse_port(tokens[2]);

    if (is_udp < 0 || host_port == 0 || guest_port == 0) {
        goto fail_syntax;
    }

    g_strfreev(tokens);

    if (slirp_add_hostfwd(slirp, is_udp, host_addr, host_port,
                          guest_addr, guest_port) < 0) {
        monitor_printf(mon, "KO: can't setup redirection, "
                       "port probably used by another program on host\n");
        return;
    }

    redir = g_new0(RedirRec, 1);
    redir->is_udp = is_udp;
    redir->host_port = host_port;
    redir->guest_port = guest_port;
    redir_list = g_list_append(redir_list, redir);

    monitor_printf(mon, "OK\n");
    return;

fail_syntax:
    monitor_printf(mon, "KO: bad redirection format, try "
                   "(tcp|udp):hostport:guestport\n");
    g_strfreev(tokens);
}

static gint redir_cmp(gconstpointer a, gconstpointer b)
{
    const RedirRec *ra = a;
    const RedirRec *rb = b;

    /* For purposes of list deletion, only protocol and host port matter */
    if (ra->is_udp != rb->is_udp) {
        return ra->is_udp - rb->is_udp;
    }
    return ra->host_port - rb->host_port;
}

void android_console_redir_del(Monitor *mon, const QDict *qdict)
{
    const char *arg = qdict_get_str(qdict, "arg");
    char **tokens;
    int is_udp, host_port;
    Slirp *slirp;
    Error *err = NULL;
    struct in_addr host_addr = { .s_addr = INADDR_ANY };
    RedirRec rr;
    GList *entry;

    slirp = net_slirp_lookup(NULL, NULL, &err);
    if (err) {
        monitor_printf(mon, "KO: %s\n", error_get_pretty(err));
        error_free(err);
        return;
    }

    /* Argument syntax: "proto:hostport" */
    tokens = g_strsplit(arg, ":", 0);

    if (g_strv_length(tokens) != 2) {
        goto fail_syntax;
    }

    is_udp = parse_proto(tokens[0]);
    host_port = parse_port(tokens[1]);

    if (is_udp < 0 || host_port == 0) {
        goto fail_syntax;
    }

    g_strfreev(tokens);

    rr.is_udp = is_udp;
    rr.host_port = host_port;
    entry = g_list_find_custom(redir_list, &rr, redir_cmp);

    if (!entry || slirp_remove_hostfwd(slirp, is_udp, host_addr, host_port)) {
        monitor_printf(mon, "KO: can't remove unknown redirection (%s:%d)\n",
                       is_udp ? "udp" : "tcp", host_port);
        return;
    }

    g_free(entry->data);
    redir_list = g_list_delete_link(redir_list, entry);

    monitor_printf(mon, "OK\n");
    return;

fail_syntax:
    monitor_printf(mon, "KO: bad redirection format, try (tcp|udp):hostport\n");
    g_strfreev(tokens);
}

#else /* not CONFIG_SLIRP */
void android_console_redir_list(Monitor *mon, const QDict *qdict)
{
    monitor_printf(mon, "KO: emulator not built with CONFIG_SLIRP\n");
}

void android_console_redir_add(Monitor *mon, const QDict *qdict)
{
    monitor_printf(mon, "KO: emulator not built with CONFIG_SLIRP\n");
}

void android_console_redir_remove(Monitor *mon, const QDict *qdict)
{
    monitor_printf(mon, "KO: emulator not built with CONFIG_SLIRP\n");
}
#endif

enum {
    CMD_REDIR,
    CMD_REDIR_LIST,
    CMD_REDIR_ADD,
    CMD_REDIR_DEL,
};

static const char *redir_help[] = {
    /* CMD_REDIR */
    "allows you to add, list and remove UDP and/or PORT redirection "
    "from the host to the device\n"
    "as an example, 'redir  tcp:5000:6000' will route any packet sent "
    "to the host's TCP port 5000\n"
    "to TCP port 6000 of the emulated device\n"
    "\n"
    "available sub-commands:\n"
    "    list             list current redirections\n"
    "    add              add new redirection\n"
    "    del              remove existing redirection\n",
    /* CMD_REDIR_LIST */
    "list current port redirections. use 'redir add' and 'redir del' to add "
    "and remove them",
    /* CMD_REDIR_ADD */
    "add a new port redirection, arguments must be:\n"
    "\n"
    "  redir add <protocol>:<host-port>:<guest-port>\n"
    "\n"
    "where:   <protocol>     is either 'tcp' or 'udp'\n"
    "         <host-port>    a number indicating which "
    "port on the host to open\n"
    "         <guest-port>   a number indicating which "
    "port to route to on the device\n"
    "\n"
    "as an example, 'redir  tcp:5000:6000' will allow any packets sent to\n"
    "the host's TCP port 5000 to be routed to TCP port 6000 of the "
    "emulated device",
    /* CMD_REDIR_DEL */
    "remove a port redirecion that was created with 'redir add', "
    "arguments must be:\n"
    "  redir  del <protocol>:<host-port>\n\n"
    "see the 'help redir add' for the meaning of <protocol> and <host-port>",
};

void android_console_redir(Monitor *mon, const QDict *qdict)
{
    /* This only gets called for bad subcommands and help requests */
    const char *helptext = qdict_get_try_str(qdict, "helptext");

    /* Default to the first entry which is the parent help message */
    int cmd = CMD_REDIR;

    if (helptext) {
        if (strstr(helptext, "add")) {
            cmd = CMD_REDIR_ADD;
        } else if (strstr(helptext, "del")) {
            cmd = CMD_REDIR_DEL;
        } else if (strstr(helptext, "list")) {
            cmd = CMD_REDIR_LIST;
        }
    }

    /* If this is not a help request then we are here with a bad sub-command */
    monitor_printf(mon, "%s\n%s\n", redir_help[cmd],
                   helptext ? "OK" : "KO: missing sub-command");
}

void android_console_power_display(Monitor *mon, const QDict *qdict)
{
    goldfish_battery_display(mon);

    monitor_printf(mon, "OK\n");
}

void android_console_power_ac(Monitor *mon, const QDict *qdict)
{
    const char *arg = qdict_get_try_str(qdict, "arg");

    if (arg) {
        if (strcasecmp(arg, "on") == 0) {
            goldfish_battery_set_prop(1, POWER_SUPPLY_PROP_ONLINE, 1);
            monitor_printf(mon, "OK\n");
            return;
        }
        if (strcasecmp(arg, "off") == 0) {
            goldfish_battery_set_prop(1, POWER_SUPPLY_PROP_ONLINE, 0);
            monitor_printf(mon, "OK\n");
            return;
        }
    }

    monitor_printf(mon, "KO: Usage: \"ac on\" or \"ac off\"\n");
}

void android_console_power_status(Monitor *mon, const QDict *qdict)
{
    const char *arg = qdict_get_try_str(qdict, "arg");

    if (arg) {
        if (strcasecmp(arg, "unknown") == 0) {
            goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_STATUS,
                                      POWER_SUPPLY_STATUS_UNKNOWN);
            monitor_printf(mon, "OK\n");
            return;
        } else if (strcasecmp(arg, "charging") == 0) {
            goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_STATUS,
                                      POWER_SUPPLY_STATUS_CHARGING);
            monitor_printf(mon, "OK\n");
            return;
        } else if (strcasecmp(arg, "discharging") == 0) {
            goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_STATUS,
                                      POWER_SUPPLY_STATUS_DISCHARGING);
            monitor_printf(mon, "OK\n");
            return;
        } else if (strcasecmp(arg, "not-charging") == 0) {
            goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_STATUS,
                                      POWER_SUPPLY_STATUS_NOT_CHARGING);
            monitor_printf(mon, "OK\n");
            return;
        } else if (strcasecmp(arg, "full") == 0) {
            goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_STATUS,
                                      POWER_SUPPLY_STATUS_FULL);
            monitor_printf(mon, "OK\n");
            return;
        }
    }

    monitor_printf(mon, "KO: Usage: \"status unknown|charging|"
                   "discharging|not-charging|full\"\n");
}

void android_console_power_present(Monitor *mon, const QDict *qdict)
{
    const char *arg = qdict_get_try_str(qdict, "arg");

    if (arg) {
        if (strcasecmp(arg, "true") == 0) {
            goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_PRESENT, 1);
            monitor_printf(mon, "OK\n");
            return;
        }
        if (strcasecmp(arg, "false") == 0) {
            goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_PRESENT, 0);
            monitor_printf(mon, "OK\n");
            return;
        }
    }

    monitor_printf(mon, "KO: Usage: \"present true\" or \"present false\"\n");
}

void android_console_power_health(Monitor *mon, const QDict *qdict)
{
    const char *arg = qdict_get_try_str(qdict, "arg");

    if (arg) {
        if (strcasecmp(arg, "unknown") == 0) {
            goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_HEALTH,
                                      POWER_SUPPLY_HEALTH_UNKNOWN);
            monitor_printf(mon, "OK\n");
            return;
        }
        if (strcasecmp(arg, "good") == 0) {
            goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_HEALTH,
                                      POWER_SUPPLY_HEALTH_GOOD);
            monitor_printf(mon, "OK\n");
            return;
        }
        if (strcasecmp(arg, "overheat") == 0) {
            goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_HEALTH,
                                      POWER_SUPPLY_HEALTH_OVERHEAT);
            monitor_printf(mon, "OK\n");
            return;
        }
        if (strcasecmp(arg, "dead") == 0) {
            goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_HEALTH,
                                      POWER_SUPPLY_HEALTH_DEAD);
            monitor_printf(mon, "OK\n");
            return;
        }
        if (strcasecmp(arg, "overvoltage") == 0) {
            goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_HEALTH,
                                      POWER_SUPPLY_HEALTH_OVERVOLTAGE);
            monitor_printf(mon, "OK\n");
            return;
        }
        if (strcasecmp(arg, "failure") == 0) {
            goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_HEALTH,
                                      POWER_SUPPLY_HEALTH_UNSPEC_FAILURE);
            monitor_printf(mon, "OK\n");
            return;
        }
    }

    monitor_printf(mon, "KO: Usage: \"health unknown|good|overheat|"
                   "dead|overvoltage|failure\"\n");
}

void android_console_power_capacity(Monitor *mon, const QDict *qdict)
{
    const char *arg = qdict_get_try_str(qdict, "arg");

    if (arg) {
        int capacity;

        if (sscanf(arg, "%d", &capacity) == 1 &&
            capacity >= 0 && capacity <= 100) {
            goldfish_battery_set_prop(0, POWER_SUPPLY_PROP_CAPACITY, capacity);
            monitor_printf(mon, "OK\n");
            return;
        }
    }

    monitor_printf(mon, "KO: Usage: \"capacity <percentage>\"\n");
}

enum {
    CMD_POWER,
    CMD_POWER_DISPLAY,
    CMD_POWER_AC,
    CMD_POWER_STATUS,
    CMD_POWER_PRESENT,
    CMD_POWER_HEALTH,
    CMD_POWER_CAPACITY,
};

static const char *power_help[] = {
        /* CMD_POWER */
        "allows to change battery and AC power status\n"
        "\n"
        "available sub-commands:\n"
        "   power display          display battery and charger state\n"
        "   power ac               set AC charging state\n"
        "   power status           set battery status\n"
        "   power present          set battery present state\n"
        "   power health           set battery health state\n"
        "   power capacity         set battery capacity state\n",
        /* CMD_POWER_DISPLAY */
        "display battery and charger state",
        /* CMD_POWER_AC */
        "'ac on|off' allows you to set the AC charging state to on or off",
        /* CMD_POWER_STATUS */
        "'status unknown|charging|discharging|not-charging|full' allows you "
        "to set battery status",
        /* CMD_POWER_PRESENT */
        "'present true|false' allows you to set battery present state to true "
        "or false",
        /* CMD_POWER_HEALTH */
        "'health unknown|good|overheat|dead|overvoltage|failure' allows you "
        "to set battery health state",
        /* CMD_POWER_CAPACITY */
        "'capacity <percentage>' allows you to set battery capacity to a "
        "value 0 - 100",
};

void android_console_power(Monitor *mon, const QDict *qdict)
{
    /* This only gets called for bad subcommands and help requests */
    const char *helptext = qdict_get_try_str(qdict, "helptext");

    /* Default to the first entry which is the parent help message */
    int cmd = CMD_POWER;

    /* In the below command name parsing, "capacity" has to precede "ac"
     * otherwise we will hit on "ac" first.
     */
    if (helptext) {
        if (strstr(helptext, "display")) {
            cmd = CMD_POWER_DISPLAY;
        } else if (strstr(helptext, "capacity")) {
            cmd = CMD_POWER_CAPACITY;
        } else if (strstr(helptext, "ac")) {
            cmd = CMD_POWER_AC;
        } else if (strstr(helptext, "status")) {
            cmd = CMD_POWER_STATUS;
        } else if (strstr(helptext, "present")) {
            cmd = CMD_POWER_PRESENT;
        } else if (strstr(helptext, "health")) {
            cmd = CMD_POWER_HEALTH;
        }
    }

    /* If this is not a help request then we are here with a bad sub-command */
    monitor_printf(mon, "%s\n%s\n", power_help[cmd],
                   helptext ? "OK" : "KO: missing sub-command");

}

enum {
    CMD_EVENT,
    CMD_EVENT_TYPES,
    CMD_EVENT_CODES,
    CMD_EVENT_SEND,
    CMD_EVENT_TEXT,
};

static const char *event_help[] = {
        /* CMD_EVENT */
        "allows you to send fake hardware events to the kernel\n"
        "\n"
        "available sub-commands:\n"
        "   event send             send a series of events to the kernel\n"
        "   event types            list all <type> aliases\n"
        "   event codes            list all <code> aliases for a given <type>\n"
        "   event text             simulate keystrokes from a given text\n",
        /* CMD_EVENT_TYPES */
        "'event types' list all <type> string aliases supported by the "
        "'event' subcommands",
        /* CMD_EVENT_CODES */
        "'event codes <type>' lists all <code> string aliases for a given "
        "event <type>",
        /* CMD_EVENT_SEND */
        "'event send <type>:<code>:<value> ...' allows your to send one or "
        "more hardware events\nto the Android kernel. you can use text names "
        "or integers for <type> and <code>",
        /* CMD_EVENT_TEXT */
        "'event text <message>' allows you to simulate keypresses to generate "
        "a given text\nmessage. <message> must be an utf-8 string. Unicode "
        "points will be reverse-mapped\naccording to the current device "
        "keyboard. unsupported characters will be discarded\nsilently",
};

void android_console_event_types(Monitor *mon, const QDict *qdict)
{
    int  count = gf_get_event_type_count();
    int  nn;

    monitor_printf(mon, "event <type> can be an integer or one of the"
                   "following aliases\n");

    /* Loop through and print out each type found along with the count of alias
     * codes if any.
     */
    for (nn = 0; nn < count; nn++) {
        char  tmp[16];
        char *p = tmp;
        int   code_count;
        gf_get_event_type_name(nn, p);

        code_count = gf_get_event_code_count(p);

        monitor_printf(mon, "    %-8s", p);

        if (code_count > 0) {
            monitor_printf(mon, "  (%d code aliases)", code_count);
        }

        monitor_printf(mon, "\n");
    }

    monitor_printf(mon, "OK\n");
}

void android_console_event_codes(Monitor *mon, const QDict *qdict)
{
    const char *arg = qdict_get_try_str(qdict, "arg");

    int  count, nn;

    if (!arg) {
        monitor_printf(mon, "KO: argument missing, try 'event codes <type>'\n");
        return;
    }

    count = gf_get_event_code_count(arg);

    /* If the type is invalid then bail */
    if (count < 0) {
        monitor_printf(mon,
                       "KO: bad argument, see 'event types' for valid values\n");
        return;
    }

    if (count == 0) {
        monitor_printf(mon, "no code aliases defined for this type\n");
    } else {
        monitor_printf(mon, "type '%s' accepts the following <code> aliases:\n",
                       arg);
        for (nn = 0; nn < count; nn++) {
            char  temp[20], *p = temp;
            gf_get_event_code_name(arg, nn, p);
            monitor_printf(mon, "    %-12s\r\n", p);
        }
    }

    monitor_printf(mon, "OK\n");
}

void android_console_event_send(Monitor *mon, const QDict *qdict)
{
    const char *arg = qdict_get_try_str(qdict, "arg");
    char **substr;
    int type, code, value = -1;

    if (!arg) {
        monitor_printf(mon,
                       "KO: Usage: event send <type>:<code>:<value> ...\n");
        return;
    }

    substr = g_strsplit(arg, ":", 3);

    /* The event type can be a symbol or number.  Check that we have a valid
     * type string and get the value depending on its format.
     */
    if (g_ascii_isdigit(*substr[0])) {
        type = g_ascii_strtoull(substr[0], NULL, 0);
    } else {
        type = gf_get_event_type_value(substr[0]);
    }
    if (type == -1) {
        monitor_printf(mon, "KO: invalid event type in '%s', try 'event "
                       "list types' for valid values\n", arg);
        goto out;
    }

    /* The event code can be a symbol or number.  Check that we have a valid
     * code string and get the value depending on its format.
     */
    if (g_ascii_isdigit(*substr[1])) {
        code = g_ascii_strtoull(substr[1], NULL, 0);
    } else {
        code = gf_get_event_code_value(type, substr[1]);
    }
    if (code == -1) {
        monitor_printf(mon, "KO: invalid event code in '%s', try 'event list "
                       "codes <type>' for valid values\n", arg);
        goto out;
    }

    /* The event value can only be a numeric value.  Check that the value
     * string is value and convert it.
     */
    if (!substr[2] || !g_ascii_isdigit(*substr[2])) {
        monitor_printf(mon, "KO: invalid event value in '%s', must be an "
                       "integer\n", arg);
        goto out;
    }
    value = g_ascii_strtoull(substr[2], NULL, 0);

    gf_event_send(type, code, value);

    monitor_printf(mon, "OK\n");

out:
    g_strfreev(substr);
}

void android_console_event_text(Monitor *mon, const QDict *qdict)
{
    const char *arg = qdict_get_try_str(qdict, "arg");

    if (!arg) {
        monitor_printf(mon,
                       "KO: argument missing, try 'event text <message>'\n");
        return;
    }

    monitor_printf(mon, "KO: 'event text' is currently unsupported\n");
}

void android_console_event(Monitor *mon, const QDict *qdict)
{
    /* This only gets called for bad subcommands and help requests */
    const char *helptext = qdict_get_try_str(qdict, "helptext");

    /* Default to the first entry which is the parent help message */
    int cmd = CMD_EVENT;

    if (helptext) {
        if (strstr(helptext, "types")) {
            cmd = CMD_EVENT_TYPES;
        } else if (strstr(helptext, "codes")) {
            cmd = CMD_EVENT_CODES;
        } else if (strstr(helptext, "send")) {
            cmd = CMD_EVENT_SEND;
        } else if (strstr(helptext, "text")) {
            cmd = CMD_EVENT_TEXT;
        }
    }

    /* If this is not a help request then we are here with a bad sub-command */
    monitor_printf(mon, "%s\n%s\n", event_help[cmd],
                   helptext ? "OK" : "KO: missing sub-command");
}

enum {
    CMD_AVD,
    CMD_AVD_STOP,
    CMD_AVD_START,
    CMD_AVD_STATUS,
    CMD_AVD_NAME,
    CMD_AVD_SNAPSHOT,
    CMD_AVD_SNAPSHOT_LIST,
    CMD_AVD_SNAPSHOT_SAVE,
    CMD_AVD_SNAPSHOT_LOAD,
    CMD_AVD_SNAPSHOT_DEL,
};

static const char *avd_help[] = {
    /* CMD_AVD */
    "allows you to control (e.g. start/stop) the execution of the virtual "
    "device\n"
    "\n"
    "available sub-commands:\n"
    "   avd stop             stop the virtual device\n"
    "   avd start            start/restart the virtual device\n"
    "   avd status           query virtual device status\n"
    "   avd name             query virtual device name\n"
    "   avd snapshot         state snapshot commands\n",
    /* CMD_AVD_STOP */
    "'avd stop' stops the virtual device immediately, use 'avd start' to "
    "continue execution",
    /* CMD_AVD_START */
    "'avd start' will start or continue the virtual device, use 'avd stop' to "
    "stop it",
    /* CMD_AVD_STATUS */
    "'avd status' will indicate whether the virtual device is running or not",
    /* CMD_AVD_NAME */
    "'avd name' will return the name of this virtual device",
    /* CMD_AVD_SNAPSHOT */
    "allows you to save and restore the virtual device state in snapshots\n"
    "\n"
    "available sub-commands:\n"
    "   avd snapshot list             list available state snapshots\n"
    "   avd snapshot save             save state snapshot\n"
    "   avd snapshot load             load state snapshot\n"
    "   avd snapshot del              delete state snapshot\n",
    /* CMD_AVD_SNAPSHOT_LIST */
    "'avd snapshot list' will show a list of all state snapshots that can be "
    "loaded",
    /* CMD_AVD_SNAPSHOT_SAVE */
    "'avd snapshot save <name>' will save the current (run-time) state to a "
    "snapshot with the given name",
    /* CMD_AVD_SNAPSHOT_LOAD */
    "'avd snapshot load <name>' will load the state snapshot of the given "
    "name",
    /* CMD_AVD_SNAPSHOT_DEL */
    "'avd snapshot del <name>' will delete the state snapshot with the given "
    "name",
};

void android_console_avd_stop(Monitor *mon, const QDict *qdict)
{
    if (!runstate_is_running()) {
        monitor_printf(mon, "KO: virtual device already stopped\n");
        return;
    }

    qmp_stop(NULL);

    monitor_printf(mon, "OK\n");
}

void android_console_avd_start(Monitor *mon, const QDict *qdict)
{
    if (runstate_is_running()) {
        monitor_printf(mon, "KO: virtual device already running\n");
        return;
    }

    qmp_cont(NULL);

    monitor_printf(mon, "OK\n");
}

void android_console_avd_status(Monitor *mon, const QDict *qdict)
{
    monitor_printf(mon, "virtual device is %s\n",
                   runstate_is_running() ? "running" : "stopped");

    monitor_printf(mon, "OK\n");
}

void android_console_avd_name(Monitor *mon, const QDict *qdict)
{
    monitor_printf(mon, "KO: 'avd name' is currently unsupported\n");
}

void android_console_avd_snapshot(Monitor *mon, const QDict *qdict)
{
    /* This only gets called for bad subcommands and help requests */
    const char *helptext = qdict_get_try_str(qdict, "helptext");

    /* Default to the first entry which is the snapshot help message */
    int cmd = CMD_AVD_SNAPSHOT;

    if (helptext) {
        if (strstr(helptext, "list")) {
            cmd = CMD_AVD_SNAPSHOT_LIST;
        } else if (strstr(helptext, "save")) {
            cmd = CMD_AVD_SNAPSHOT_SAVE;
        } else if (strstr(helptext, "load")) {
            cmd = CMD_AVD_SNAPSHOT_LOAD;
        } else if (strstr(helptext, "del")) {
            cmd = CMD_AVD_SNAPSHOT_DEL;
        }
    }

    /* If this is not a help request then we are here with a bad sub-command */
    monitor_printf(mon, "%s\n%s\n", avd_help[cmd],
                   helptext ? "OK" : "KO: missing sub-command");
}

void android_console_avd_snapshot_list(Monitor *mon, const QDict *qdict)
{
    monitor_printf(mon, "KO: 'avd snapshot list' is currently unsupported\n");
}

void android_console_avd_snapshot_save(Monitor *mon, const QDict *qdict)
{
    monitor_printf(mon, "KO: 'avd snapshot save' is currently unsupported\n");
}

void android_console_avd_snapshot_load(Monitor *mon, const QDict *qdict)
{
    monitor_printf(mon, "KO: 'avd snapshot load' is currently unsupported\n");
}

void android_console_avd_snapshot_del(Monitor *mon, const QDict *qdict)
{
    monitor_printf(mon, "KO: 'avd snapshot del' is currently unsupported\n");
}

void android_console_avd(Monitor *mon, const QDict *qdict)
{
    /* This only gets called for bad subcommands and help requests */
    const char *helptext = qdict_get_try_str(qdict, "helptext");

    /* Default to the first entry which is the parent help message */
    int cmd = CMD_AVD;

    if (helptext) {
        if (strstr(helptext, "stop")) {
            cmd = CMD_AVD_STOP;
        } else if (strstr(helptext, "start")) {
            cmd = CMD_AVD_START;
        } else if (strstr(helptext, "status")) {
            cmd = CMD_AVD_STATUS;
        } else if (strstr(helptext, "name")) {
            cmd = CMD_AVD_NAME;
        }
    }

    /* If this is not a help request then we are here with a bad sub-command */
    monitor_printf(mon, "%s\n%s\n", avd_help[cmd],
                   helptext ? "OK" : "KO: missing sub-command");
}