/**
 * Copyright (C) 2020  Evgeny Zinoviev
 * This file is part of isv <https://github.com/gch1p/isv>.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that 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 <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <getopt.h>
#include <stdarg.h>
#include <assert.h>

#include "variant.h"
#include "p18.h"
#include "util.h"
#include "print.h"
#include "libvoltronic/voltronic_dev_usb.h"

#define COMMAND_BUF_LENGTH  128
#define RESPONSE_BUF_LENGTH 128

#define PRINT(msg_type) \
    { \
        P18_MSG_T(msg_type) m = P18_UNPACK_FN_NAME(msg_type)(buffer+5); \
        PRINT_FN_NAME(msg_type)(&m, g_format); \
    }

#define GET_ARGS(len) \
    get_args(argc, (const char **)argv, a, (len))

bool g_verbose = false;
print_format_t g_format = PRINT_FORMAT_TABLE;

static void usageintlist(const int *list, size_t size)
{
    for (size_t i = 0; i < size; i++) {
        printf("%d", list[i]);
        if (i < size-1)
            printf(", ");
    }
}

static void usagestrlist(const char **list, size_t size)
{
    for (size_t i = 0; i < size; i++) {
        printf("%s", list[i]);
        if (i < size-1)
            printf(", ");
    }
}

static void write_num(char *buf, int n)
{
    assert(n <= 9);
    *buf++ = n + '0';
    *buf++ = '\0';
}

static void usage(const char *progname)
{
    printf("Usage: %s OPTIONS\n", progname);
    printf("\n"
           "Options:\n"
           "    -h, --help:          print this help\n"
           "    -r <COMMAND>,\n"
           "    --raw <COMMAND>:     execute arbitrary command and print inverter's\n"
           "                         response. Command example: ^P005PI\n"
           "    -t <TIMEOUT>,\n"
           "    --timeout <TIMEOUT>: device read timeout, in milliseconds\n"
           "    -v, --verbose:       print debug information, like hexdumps of\n"
           "                         communication traffic with inverter\n"
           "    -p, --pretend:       do not actually execute command on inverter,\n"
           "                         but output some debug info\n"
           "    -f <FORMAT>,\n"
           "    --format <FORMAT>:   output format for --get and --set options, see below\n"
           "\n"
           "Options to get data from inverter:\n"
           "    --get-protocol-id\n"
           "    --get-date-time\n"
           "    --get-total-generated\n"
           "    --get-year-generated <YYYY>\n"
           "    --get-month-generated <YYYY> <MM>\n"
           "    --get-day-generated <YYYY> <MM> <DD>\n"
           "    --get-series-number\n"
           "    --get-cpu-version\n"
           "    --get-rated-information\n"
           "    --get-general-status\n"
           "    --get-working-mode\n"
           "    --get-faults-warnings\n"
           "    --get-flags\n"
           "    --get-defaults\n"
           "    --get-max-charging-current-selectable-values\n"
           "    --get-max-ac-charging-current-selectable-values\n"
           "    --get-parallel-rated-information <ID>\n"
           "        ID: parallel machine ID\n"
           "\n"
           "    --get-parallel-general-status <ID>\n"
           "        ID: parallel machine ID\n"
           "\n"
           "    --get-ac-charge-time-bucket\n"
           "    --get-ac-supply-load-time-bucket\n"
           "\n"
           "Options to set inverter's configuration:\n"
           "    --set-loads-supply 0|1\n"
           "    --set-flag <FLAG> 0|1\n"
           "    --set-defaults\n"
           "    --set-battery-max-charging-current <ID> <AMPS>\n"
           "      ID: parallel machine ID (use 0 for a single model)\n"
           "      AMPS: use --get-max-charging-current-selectable-values\n"
           "            to see a list of allowed current values\n"
           "\n"
           "    --set-battery-max-ac-charging-current <ID> <AMPS>\n"
           "      ID: parallel machine ID (use 0 for a single model)\n"
           "      AMPS: use --get-max-ac-charging-current-selectable-values\n"
           "            to see a list of allowed current values\n"
           "\n"
           "    --set-ac-output-freq 50|60\n"
           "    --set-battery-max-charging-voltage <CV> <FV>\n"
           "        CV: constant voltage (48.0~58.4)\n"
           "        FV: float voltage (48.0~58.4)\n"
           "\n"
           "    --set-ac-output-rated-voltage <V>\n"
           "        V: one of: "
           );
    usageintlist(p18_ac_output_rated_voltages,
                 ARRAY_SIZE(p18_ac_output_rated_voltages));
    printf("\n\n"
           "    --set-output-source-priority SUB|SBU\n"
           "        SUB for %s\n"
           "        SBU for %s\n",
           p18_output_source_priority_label(P18_OSP_SOLAR_UTILITY_BATTERY),
           p18_output_source_priority_label(P18_OSP_SOLAR_BATTERY_UTILITY));
    printf("\n"
           "    --set-battery-charging-thresholds <CV> <DV>\n"
           "        Sets battery re-charging and re-discharigng voltages when\n"
           "        utility is available.\n"
           "\n"
           "        CV: re-charging voltage\n"
           "            for 12V unit, one of: ");
    usagestrlist(p18_battery_util_recharging_voltages_12v_unit,
                 ARRAY_SIZE(p18_battery_util_recharging_voltages_12v_unit));
    printf("\n"
           "            for 24V unit, one of: ");
    usagestrlist(p18_battery_util_recharging_voltages_24v_unit,
                 ARRAY_SIZE(p18_battery_util_recharging_voltages_24v_unit));
    printf("\n"
           "            for 48V unit, one of: ");
    usagestrlist(p18_battery_util_recharging_voltages_48v_unit,
                 ARRAY_SIZE(p18_battery_util_recharging_voltages_48v_unit));
    printf("\n"
           "        DV: re-discharging voltage\n"
           "            for 12V unit, one of: ");
    usagestrlist(p18_battery_util_redischarging_voltages_12v_unit,
                 ARRAY_SIZE(p18_battery_util_redischarging_voltages_12v_unit));
    printf("\n"
           "            for 24V unit, one of: ");
    usagestrlist(p18_battery_util_redischarging_voltages_24v_unit,
                 ARRAY_SIZE(p18_battery_util_redischarging_voltages_24v_unit));
    printf("\n"
           "            for 48V unit, one of: ");
    usagestrlist(p18_battery_util_redischarging_voltages_48v_unit,
                 ARRAY_SIZE(p18_battery_util_redischarging_voltages_48v_unit));
    printf("\n\n"
           "    --set-charging-source-priority <ID> <PRIORITY>\n"
           "        ID: parallel machine ID (use 0 for a single model)\n"
           "        PRIORITY:\n"
           "            SF: %s,\n"
           "            SU: %s,\n"
           "            S: %s\n",
           p18_charge_source_priority_label(P18_CSP_SOLAR_FIRST),
           p18_charge_source_priority_label(P18_CSP_SOLAR_AND_UTILITY),
           p18_charge_source_priority_label(P18_CSP_SOLAR_ONLY));
    printf("\n"
           "    --set-solar-power-priority BLU|LBU\n"
           "        BLU: %s\n"
           "        LBU: %s\n",
           p18_solar_power_priority_label(P18_SPP_BATTERY_LOAD_UTILITY),
           p18_solar_power_priority_label(P18_SPP_LOAD_BATTERY_UTILITY));
    printf("\n"
           "    --set-ac-input-voltage-range APPLIANCE|UPS\n"
           "    --set-battery-type AGM|FLOODED|USER\n"
           "    --set-output-model <ID> <MODEL>\n"
           "        ID: parallel machine ID (use 0 for a single model)\n"
           "        MODEL:\n"
           "            SM: %s\n"
           "            P: %s\n"
           "            P1: %s\n"
           "            P2: %s\n"
           "            P3: %s\n",
           p18_output_model_setting_label(P18_OMS_SINGLE_MODULE),
           p18_output_model_setting_label(P18_OMS_PARALLEL_OUTPUT),
           p18_output_model_setting_label(P18_OMS_PHASE1_OF_3PHASE_OUTPUT),
           p18_output_model_setting_label(P18_OMS_PHASE2_OF_3PHASE_OUTPUT),
           p18_output_model_setting_label(P18_OMS_PHASE3_OF_3PHASE_OUTPUT));
    printf("\n"
           "    --set-battery-cutoff-voltage <V>\n"
           "        V: cut-off voltage (40.0~48.0)\n"
           "\n"
           "    --set-solar-configuration <ID>\n"
           "        ID: serial number\n"
           "\n"
           "    --clear-generated-data\n"
           "        Clears all data of generated energy.\n"
           "\n"
           "    --set-date-time <YYYY> <MM> <DD> <hh> <mm> <ss>\n"
           "        YYYY: year\n"
           "        MM: month\n"
           "        DD: day\n"
           "        hh: hours\n"
           "        mm: minutes\n"
           "        ss: seconds\n"
           "\n"
           "    --set-ac-charge-time-bucket <START> <END>\n"
           "        START: starting time, hh:mm format\n"
           "        END: ending time, hh:mm format\n"
           "\n"
           "    --set-ac-supply-load-time-bucket <START> <END>\n"
           "        START: starting time, hh:mm format\n"
           "        END: ending time, hh:mm format\n"
           "\n"
    );
    printf("Flags:\n");

    size_t len = ARRAY_SIZE(p18_flags_printable_list);
    for (size_t i = 0; i < len; i++) {
        p18_flag_printable_list_item_t item = p18_flags_printable_list[i];
        printf("    %s: %s\n", item.key, item.title);
    }

    printf("\n"
           "Formats:\n"
           "    table          human-readable table\n"
           "    parsable-table conveniently-parsable table\n"
           "    json           JSON object, like {\"ac_output_voltage\":230}\n"
           "    json-w-units   JSON object with units, like:\n"
           "                   {\"ac_output_voltage\":[230,\"V\"]}\n"
    );

    exit(1);
}

static void exit_with_error(int code, char *fmt, ...)
{
    static const size_t buf_size = 256;
    char buf[buf_size];
    va_list args;
    va_start(args, fmt);
    size_t len = vsnprintf(buf, buf_size, fmt, args);
    va_end(args);
    buf[MIN(len, buf_size-1)] = '\0';
    ERROR("error: %s\n", buf);
    if (g_format == PRINT_FORMAT_JSON || g_format == PRINT_FORMAT_JSON_W_UNITS) {
        print_item_t items[] = {
            {.key= "error", .value= variant_string(buf)}
        };
        print_json(items, 1, false);
    }
    exit(code);
}

static void get_args(int argc, const char **argv, const char **arguments_dst, size_t count)
{
    size_t i = 0;
    arguments_dst[i++] = optarg;
    for (; i < count; i++) {
        if (optind < argc && *argv[optind] != '-')
            arguments_dst[i] = argv[optind++];
        else
            exit_with_error(1, "option %s requires %zu arguments",
                            argv[optind-i-1], count);
    }
}

static void execute_raw(voltronic_dev_t dev, const char *command, int timeout)
{
    char buffer[RESPONSE_BUF_LENGTH];
    int result = voltronic_dev_execute(dev, 0, command, strlen(command),
                                   buffer, sizeof(buffer), NULL, timeout);
    if (result <= 0)
        exit_with_error(2, "failed to execute %s: %s", command, strerror(errno));
    printf("%s\n", buffer);
}

static void query(voltronic_dev_t dev,
          int command_key,
          int timeout,
          const char **args,
          size_t args_size,
          bool pretend)
{
    char buffer[RESPONSE_BUF_LENGTH];
    char command[COMMAND_BUF_LENGTH];

    if (!p18_build_command(command_key, args, args_size, command))
        exit_with_error(1, "invalid query command %d", command_key);

    if (pretend) {
        size_t command_len = strlen(command);
        LOG("would write %zu+3 %s:\n",
            command_len, (command_len > 1 ? "bytes" : "byte"));
        HEXDUMP(command, command_len);
        return;
    }

    size_t received;
    int result = voltronic_dev_execute(dev, 0, command, strlen(command),
                                           buffer, sizeof(buffer), &received,
                                           timeout);
    if (result <= 0)
        exit_with_error(2, "failed to execute %s: %s", command, strerror(errno));

    if (command_key < P18_SET_CMDS_ENUM_OFFSET) {
        size_t data_size;
        if (!p18_validate_query_response(buffer, received, &data_size))
            exit_with_error(2, "invalid response");

        if (command_key == P18_QUERY_PROTOCOL_ID)
            PRINT(protocol_id)
        else if (command_key == P18_QUERY_CURRENT_TIME)
            PRINT(current_time)
        else if (command_key == P18_QUERY_TOTAL_GENERATED)
            PRINT(total_generated)
        else if (command_key == P18_QUERY_YEAR_GENERATED)
            PRINT(year_generated)
        else if (command_key == P18_QUERY_MONTH_GENERATED)
            PRINT(month_generated)
        else if (command_key == P18_QUERY_DAY_GENERATED)
            PRINT(day_generated)
        else if (command_key == P18_QUERY_SERIES_NUMBER)
            PRINT(series_number)
        else if (command_key == P18_QUERY_CPU_VERSION)
            PRINT(cpu_version)
        else if (command_key == P18_QUERY_RATED_INFORMATION)
            PRINT(rated_information)
        else if (command_key == P18_QUERY_GENERAL_STATUS)
            PRINT(general_status)
        else if (command_key == P18_QUERY_WORKING_MODE)
            PRINT(working_mode)
        else if (command_key == P18_QUERY_FAULTS_WARNINGS)
            PRINT(faults_warnings)
        else if (command_key == P18_QUERY_FLAGS_STATUSES)
            PRINT(flags_statuses)
        else if (command_key == P18_QUERY_DEFAULTS)
            PRINT(defaults)
        else if (command_key == P18_QUERY_MAX_CHARGING_CURRENT_SELECTABLE_VALUES)
            PRINT(max_charging_current_selectable_values)
        else if (command_key == P18_QUERY_MAX_AC_CHARGING_CURRENT_SELECTABLE_VALUES)
            PRINT(max_ac_charging_current_selectable_values)
        else if (command_key == P18_QUERY_PARALLEL_RATED_INFORMATION)
            PRINT(parallel_rated_information)
        else if (command_key == P18_QUERY_PARALLEL_GENERAL_STATUS)
            PRINT(parallel_general_status)
        else if (command_key == P18_QUERY_AC_CHARGE_TIME_BUCKET)
            PRINT(ac_charge_time_bucket)
        else if (command_key == P18_QUERY_AC_SUPPLY_LOAD_TIME_BUCKET)
            PRINT(ac_supply_load_time_bucket)
    } else {
        bool success = p18_set_result(buffer, received);
        print_set_result(success, g_format);
        if (!success)
            exit(2);
    }
}

static void validate_date_args(const char *ys, const char *ms, const char *ds)
{
    static char *err_year = "invalid year";
    static char *err_month = "invalid month";
    static char *err_day = "invalid day";

    int y, m = 0, d = 0;

    /* validate year */
    if (!isnumeric(ys) || strlen(ys) != 4)
        exit_with_error(1, err_year);
    y = (int)strtoul(ys, NULL, 10);
    if (y < 2000 || y > 2099) {
        ERROR("%s\n", err_year);
        exit(1);
    }

    /* validate month */
    if (ms != NULL) {
        if (!isnumeric(ms) || strlen(ms) > 2)
            exit_with_error(1, err_month);
        m = (int)strtoul(ms, NULL, 10);
        if (m < 1 || m > 12)
            exit_with_error(1, err_month);
    }

    /* validate day */
    if (ds != NULL) {
        if (!isnumeric(ds) || strlen(ds) > 2)
            exit_with_error(1, err_day);
        d = (int) strtoul(ds, NULL, 10);
        if (d < 1 || d > 31)
            exit_with_error(1, err_day);
    }

    if (y != 0 && m != 0 && d != 0) {
        if (!isdatevalid(y, m, d))
            exit_with_error(1, "invalid date");
    }
}

static void validate_time_args(const char *hs, const char *ms, const char *ss)
{
    static char *err_hour = "invalid hour";
    static char *err_minute = "invalid minute";
    static char *err_second = "invalid second";

    unsigned int h, m, s;

    if (!isnumeric(hs) || strlen(hs) > 2)
        exit_with_error(1, err_hour);
    h = (unsigned int)strtoul(hs, NULL, 10);
    if (h > 23)
        exit_with_error(1, err_hour);

    if (!isnumeric(ms) || strlen(ms) > 2)
        exit_with_error(1, err_minute);
    m = (unsigned int)strtoul(ms, NULL, 10);
    if (m > 59)
        exit_with_error(1, err_minute);

    if (!isnumeric(ss) || strlen(ss) > 2)
        exit_with_error(1, err_second);
    s = (unsigned int)strtoul(ss, NULL, 10);
    if (s > 59)
        exit_with_error(1, err_second);
}

static bool get_float(const char *s, float *fptr)
{
    char *endptr;
    float f = strtof(s, &endptr);
    if (endptr == s)
        return false;
    if (fptr != NULL)
        *fptr = f;
    return true;
}

static bool get_uint(const char *s, unsigned int *iptr)
{
    char *endptr;
    unsigned int i = (unsigned int)strtoul(s, &endptr, 10);
    if (endptr == s)
        return false;
    if (iptr != NULL)
        *iptr = i;
    return true;
}

static bool is_valid_parallel_id(const char *s)
{
    return isnumeric(s) && strlen(s) == 1;
}

enum action {
    ACTION_HELP,
    ACTION_DUMP,
    ACTION_EXECUTE,
    ACTION_QUERY,
};

enum {
    OPT_HELP = 'h',
    OPT_DUMP = 'd',
    OPT_VERBOSE = 'v',
    OPT_RAW = 'r',
    OPT_PREDENT = 'p',
    OPT_TIMEOUT = 't',
    OPT_FORMAT = 'f',
};

int main(int argc, char *argv[])
{
    if (argv[1] == NULL)
        usage(argv[0]);

    enum action act = ACTION_HELP;
    int opt;
    int command_no = 0, timeout = 1000;
    bool pretend = false;
    const char *a[6] = {0}; /* p18 command arguments */
    static struct option long_options[] = {
        {"help",    no_argument,       0, OPT_HELP},
        {"dump",    no_argument,       0, OPT_DUMP},
        {"verbose", no_argument,       0, OPT_VERBOSE},
        {"raw",     required_argument, 0, OPT_RAW},
        {"pretend", required_argument, 0, OPT_PREDENT},
        {"timeout", required_argument, 0, OPT_TIMEOUT},
        {"format",  required_argument, 0, OPT_FORMAT},

        /* get queries */
        {"get-protocol-id",                               no_argument,       0, P18_QUERY_PROTOCOL_ID},
        {"get-date-time",                                 no_argument,       0, P18_QUERY_CURRENT_TIME},
        {"get-total-generated",                           no_argument,       0, P18_QUERY_TOTAL_GENERATED},
        {"get-year-generated",                            required_argument, 0, P18_QUERY_YEAR_GENERATED},
        {"get-month-generated",                           required_argument, 0, P18_QUERY_MONTH_GENERATED},
        {"get-day-generated",                             required_argument, 0, P18_QUERY_DAY_GENERATED},
        {"get-series-number",                             no_argument,       0, P18_QUERY_SERIES_NUMBER},
        {"get-cpu-version",                               no_argument,       0, P18_QUERY_CPU_VERSION},
        {"get-rated-information",                         no_argument,       0, P18_QUERY_RATED_INFORMATION},
        {"get-general-status",                            no_argument,       0, P18_QUERY_GENERAL_STATUS},
        {"get-working-mode",                              no_argument,       0, P18_QUERY_WORKING_MODE},
        {"get-faults-warnings",                           no_argument,       0, P18_QUERY_FAULTS_WARNINGS},
        {"get-flags",                                     no_argument,       0, P18_QUERY_FLAGS_STATUSES},
        {"get-defaults",                                  no_argument,       0, P18_QUERY_DEFAULTS},
        {"get-max-charging-current-selectable-values",    no_argument,       0, P18_QUERY_MAX_CHARGING_CURRENT_SELECTABLE_VALUES},
        {"get-max-ac-charging-current-selectable-values", no_argument,       0, P18_QUERY_MAX_AC_CHARGING_CURRENT_SELECTABLE_VALUES},
        {"get-parallel-rated-information",                required_argument, 0, P18_QUERY_PARALLEL_RATED_INFORMATION},
        {"get-parallel-general-status",                   required_argument, 0, P18_QUERY_PARALLEL_GENERAL_STATUS},
        {"get-ac-charge-time-bucket",                     no_argument,       0, P18_QUERY_AC_CHARGE_TIME_BUCKET},
        {"get-ac-supply-load-time-bucket",                no_argument,       0, P18_QUERY_AC_SUPPLY_LOAD_TIME_BUCKET},

        /* set queries */
        {"set-loads-supply",                    required_argument, 0, P18_SET_LOADS},
        {"set-flag",                            required_argument, 0, P18_SET_FLAG},
        {"set-defaults",                        no_argument,       0, P18_SET_DEFAULTS},
        {"set-battery-max-charging-current",    required_argument, 0, P18_SET_BAT_MAX_CHARGE_CURRENT},
        {"set-battery-max-ac-charging-current", required_argument, 0, P18_SET_BAT_MAX_AC_CHARGE_CURRENT},
        {"set-ac-output-freq",                  required_argument, 0, P18_SET_AC_OUTPUT_FREQ},
        {"set-battery-max-charging-voltage",    required_argument, 0, P18_SET_BAT_MAX_CHARGE_VOLTAGE},
        {"set-ac-output-rated-voltage",         required_argument, 0, P18_SET_AC_OUTPUT_RATED_VOLTAGE},
        {"set-output-source-priority",          required_argument, 0, P18_SET_OUTPUT_SOURCE_PRIORITY},
        {"set-battery-charging-thresholds",     required_argument, 0, P18_SET_BAT_CHARGING_THRESHOLDS_WHEN_UTILITY_AVAIL},
        {"set-charging-source-priority",        required_argument, 0, P18_SET_CHARGING_SOURCE_PRIORITY},
        {"set-solar-power-priority",            required_argument, 0, P18_SET_SOLAR_POWER_PRIORITY},
        {"set-ac-input-voltage-range",          required_argument, 0, P18_SET_AC_INPUT_VOLTAGE_RANGE},
        {"set-battery-type",                    required_argument, 0, P18_SET_BAT_TYPE},
        {"set-output-model",                    required_argument, 0, P18_SET_OUTPUT_MODEL},
        {"set-battery-cutoff-voltage",          required_argument, 0, P18_SET_BAT_CUTOFF_VOLTAGE},
        {"set-solar-configuration",             required_argument, 0, P18_SET_SOLAR_CONFIG},
        {"clear-generated-data",                no_argument      , 0, P18_SET_CLEAR_GENERATED},
        {"set-date-time",                       required_argument, 0, P18_SET_DATE_TIME},
        {"set-ac-charge-time-bucket",           required_argument, 0, P18_SET_AC_CHARGE_TIME_BUCKET},
        {"set-ac-supply-load-time-bucket",      required_argument, 0, P18_SET_AC_SUPPLY_LOAD_TIME_BUCKET},

        {0, 0, 0, 0}
    };

    bool getopt_err = false;
    while ((opt = getopt_long(argc, argv, "hdvr:pt:f:",
                              long_options, NULL)) != EOF) {
        if (opt == '?') {
            getopt_err = true;
            break;
        }

        if (opt == OPT_HELP)
            act = ACTION_HELP;

        else if (opt == OPT_DUMP)
            act = ACTION_DUMP;

        else if (opt == OPT_VERBOSE)
            g_verbose = true;

        else if (opt == OPT_PREDENT)
            pretend = true;

        else if (opt == OPT_FORMAT) {
            if (!strcmp(optarg, "json"))
                g_format = PRINT_FORMAT_JSON;
            else if (!strcmp(optarg, "json-w-units"))
                g_format = PRINT_FORMAT_JSON_W_UNITS;
            else if (!strcmp(optarg, "table"))
                g_format = PRINT_FORMAT_TABLE;
            else if (!strcmp(optarg, "parsable-table"))
                g_format = PRINT_FORMAT_PARSABLE_TABLE;
            else
                exit_with_error(1, "invalid format");
        }

        else if (opt == OPT_RAW) {
            if (strlen(optarg) > COMMAND_BUF_LENGTH - 1)
                exit_with_error(1, "command is too long");
            a[0] = optarg;
            act = ACTION_EXECUTE;
        }

        else if (opt == OPT_TIMEOUT) {
            timeout = atoi(optarg);
            if (timeout <= 0 || timeout > 60000)
                exit_with_error(1, "invalid timeout");
        }

        else if (opt >= P18_QUERY_CMDS_ENUM_OFFSET) {
            if (act == ACTION_QUERY)
                exit_with_error(1, "one query at a time, please");

            if (opt >= P18_QUERY_CMDS_ENUM_OFFSET) {
                act = ACTION_QUERY;
                command_no = opt;
            }

            switch (opt) {
                case P18_QUERY_YEAR_GENERATED:
                    GET_ARGS(1);
                    validate_date_args(a[0], NULL, NULL);
                    break;

                case P18_QUERY_MONTH_GENERATED:
                    GET_ARGS(2);
                    validate_date_args(a[0], a[1], NULL);
                    break;

                case P18_QUERY_DAY_GENERATED:
                    GET_ARGS(3);
                    validate_date_args(a[0], a[1], a[2]);
                    break;

                case P18_QUERY_PARALLEL_RATED_INFORMATION:
                case P18_QUERY_PARALLEL_GENERAL_STATUS:
                    GET_ARGS(1);
                    if (!isnumeric(a[0]) || strlen(a[0]) > 1)
                        exit_with_error(1, "invalid argument");
                    break;

                case P18_SET_LOADS:
                    GET_ARGS(1);
                    if (strcmp(a[0], "0") != 0 && strcmp(a[0], "1") != 0)
                        exit_with_error(1, "invalid argument, only 0 or 1 allowed");
                    break;

                case P18_SET_FLAG: {
                    GET_ARGS(2);
                    bool matchfound = false;
                    FOREACH (const p18_flag_printable_list_item_t *item,
                        p18_flags_printable_list) {
                        if (!strcmp(item->key, a[0])) {
                            a[0] = item->p18_key;
                            matchfound = true;
                            break;
                        }
                    }
                    if (!matchfound)
                        exit_with_error(1, "invalid flag");
                    if (strcmp(a[1], "0") != 0 &&
                        strcmp(a[1], "1") != 0)
                        exit_with_error(1, "invalid flag state, only 0 or 1 allowed");
                    break;
                }

                case P18_SET_BAT_MAX_CHARGE_CURRENT:
                case P18_SET_BAT_MAX_AC_CHARGE_CURRENT:
                    GET_ARGS(2);
                    if (!is_valid_parallel_id(a[0]))
                        exit_with_error(1, "invalid id");
                    if (!get_uint(a[1], NULL) || strlen(a[1]) > 3)
                        exit_with_error(1, "invalid argument");
                    break;

                case P18_SET_AC_OUTPUT_FREQ:
                    GET_ARGS(1);
                    if (strcmp(a[0], "50") != 0 && strcmp(a[0], "60") != 0)
                        exit_with_error(1, "invalid frequency, only 50 or 60 allowed");
                    break;

                case P18_SET_BAT_MAX_CHARGE_VOLTAGE:
                    GET_ARGS(2);
                    float cv, fv;
                    bool cvr = get_float(a[0], &cv);
                    bool fvr = get_float(a[1], &fv);
                    if (!cvr || cv < 48.0 || cv > 58.4)
                        exit_with_error(1, "invalid CV");
                    if (!fvr || fv < 48.0 || fv > 58.4)
                        exit_with_error(1, "invalid FV");
                    break;

                case P18_SET_AC_OUTPUT_RATED_VOLTAGE: {
                    GET_ARGS(1);
                    unsigned int v;
                    if (!get_uint(a[0], &v))
                        exit_with_error(1, "invalid argument");
                    bool matchfound = false;
                    FOREACH (const int *allowed_v, p18_ac_output_rated_voltages) {
                        if ((unsigned int)*allowed_v == v) {
                            matchfound = true;
                            break;
                        }
                    }
                    if (!matchfound)
                        exit_with_error(1, "invalid voltage");
                    break;

                case P18_SET_OUTPUT_SOURCE_PRIORITY:
                    GET_ARGS(1);
                    const char *allowed[] = {"SUB", "SBU"};
                    int index;
                    if (!instrarray(a[0], allowed, ARRAY_SIZE(allowed), &index))
                        exit_with_error(1, "invalid argument");
                    write_num((char *)a[0], index);
                    break;

                case P18_SET_BAT_CHARGING_THRESHOLDS_WHEN_UTILITY_AVAIL:
                    GET_ARGS(2);
                    if (   !instrarray(a[0], p18_battery_util_recharging_voltages_12v_unit, ARRAY_SIZE(p18_battery_util_recharging_voltages_12v_unit), NULL)
                        && !instrarray(a[0], p18_battery_util_recharging_voltages_24v_unit, ARRAY_SIZE(p18_battery_util_recharging_voltages_24v_unit), NULL)
                        && !instrarray(a[0], p18_battery_util_recharging_voltages_48v_unit, ARRAY_SIZE(p18_battery_util_recharging_voltages_48v_unit), NULL))
                        exit_with_error(1, "invalid CV");
                    if (      !instrarray(a[1], p18_battery_util_redischarging_voltages_12v_unit, ARRAY_SIZE(p18_battery_util_recharging_voltages_12v_unit), NULL)
                           && !instrarray(a[1], p18_battery_util_redischarging_voltages_24v_unit, ARRAY_SIZE(p18_battery_util_recharging_voltages_24v_unit), NULL)
                           && !instrarray(a[1], p18_battery_util_redischarging_voltages_48v_unit, ARRAY_SIZE(p18_battery_util_recharging_voltages_48v_unit), NULL))
                        exit_with_error(1, "invalid DV");
                    break;
                }

                case P18_SET_CHARGING_SOURCE_PRIORITY: {
                    GET_ARGS(2);
                    if (!is_valid_parallel_id(a[0]))
                        exit_with_error(1, "invalid id");
                    const char *allowed[] = {"SF", "SU", "S"};
                    int index;
                    if (!instrarray(a[1], allowed, ARRAY_SIZE(allowed), &index))
                        exit_with_error(1, "invalid priority");
                    write_num((char *)a[1], index);
                    break;
                }

                case P18_SET_SOLAR_POWER_PRIORITY: {
                    GET_ARGS(1);
                    const char *allowed[] = {"BLU", "LBU"};
                    int index;
                    if (!instrarray(a[0], allowed, ARRAY_SIZE(allowed), &index))
                        exit_with_error(1, "invalid priority");
                    write_num((char *)a[0], index);
                    break;
                }

                case P18_SET_AC_INPUT_VOLTAGE_RANGE: {
                    GET_ARGS(1);
                    const char *allowed[] = {"APPLIANCE", "UPS"};
                    int index;
                    if (!instrarray(a[0], allowed, ARRAY_SIZE(allowed), &index))
                        exit_with_error(1, "invalid argument");
                    write_num((char *)a[0], index);
                    break;
                }

                case P18_SET_BAT_TYPE: {
                    GET_ARGS(1);
                    const char *allowed[] = {"AGM", "FLOODED", "USER"};
                    int index;
                    if (!instrarray(a[0], allowed, ARRAY_SIZE(allowed), &index))
                        exit_with_error(1, "invalid type");
                    write_num((char *)a[0], index);
                    break;
                }

                case P18_SET_OUTPUT_MODEL: {
                    GET_ARGS(2);
                    if (!is_valid_parallel_id(a[0]))
                        exit_with_error(1, "invalid id");
                    const char *allowed[] = {"SM", "P", "P1", "P2", "P3"};
                    int index;
                    if (!instrarray(a[1], allowed, ARRAY_SIZE(allowed), &index))
                        exit_with_error(1, "invalid model");
                    write_num((char *)a[1], index);
                    break;
                }

                case P18_SET_BAT_CUTOFF_VOLTAGE:
                    GET_ARGS(1);
                    float v;
                    bool vr = get_float(a[0], &v);
                    if (!vr || v < 40.0 || v > 48.0)
                        exit_with_error(1, "invalid voltage");
                    break;

                case P18_SET_SOLAR_CONFIG:
                    GET_ARGS(1);
                    if (!isnumeric(a[0]) || strlen(a[0]) > 20)
                        exit_with_error(1, "invalid argument");
                    break;

                case P18_SET_DATE_TIME:
                    GET_ARGS(6);
                    validate_date_args(a[0], a[1], a[2]);
                    validate_time_args(a[3], a[4], a[5]);
                    break;

                case P18_SET_AC_CHARGE_TIME_BUCKET:
                case P18_SET_AC_SUPPLY_LOAD_TIME_BUCKET:
                    GET_ARGS(2);
                    unsigned short start_h, start_m, end_h, end_m;
                    int results;

                    results = sscanf(a[0], "%hu:%hu", &start_h, &start_m);
                    if (results != 2 || start_h > 23 || start_m > 59)
                        exit_with_error(1, "invalid start time");

                    results = sscanf(a[1], "%hu:%hu", &end_h, &end_m);
                    if (results != 2 || end_h > 23 || end_m > 59)
                        exit_with_error(1, "invalid end time");

                    char *start_col = strchr(a[0], ':');
                    char *end_col = strchr(a[1], ':');
                    *start_col = '\0';
                    *end_col = '\0';

                    char *start_m_ptr = start_col+1;
                    char *end_h_ptr = (char *)a[1];
                    char *end_m_ptr = end_col+1;

                    a[1] = start_m_ptr;
                    a[2] = end_h_ptr;
                    a[3] = end_m_ptr;
                    break;
            }
        }
    }

    if (optind < argc)
        exit_with_error(1, "extra parameter found");

    if (getopt_err)
        exit(1);

    if (act == ACTION_HELP)
        usage(argv[0]);

    voltronic_dev_t dev = voltronic_usb_create(0x0665, 0x5161);

    if (!pretend && !dev)
        exit_with_error(1, "could not open USB device: %s", strerror(errno));

    switch (act) {
        case ACTION_EXECUTE:
            execute_raw(dev, a[0], timeout);
            break;

        case ACTION_QUERY:
            query(dev, command_no, timeout, a, sizeof(a), pretend);
            break;

        default:
            exit_with_error(1, "unexpected act %d", act);
    }

    if (dev)
        voltronic_dev_close(dev);

    return 0;
}