/*
 *  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 2 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 Library General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * RDMHelper.cpp
 * Various misc RDM functions.
 * Copyright (C) 2010 Simon Newton
 *
 * At some point we may want to localize this file.
 */

#include <sstream>
#include <string>
#include "ola/rdm/RDMHelper.h"

namespace ola {
namespace rdm {


using std::string;
using std::stringstream;


/**
 * Convert a uint8_t representing a lamp mode to a human-readable string.
 * @param type the lamp mode value
 */
string DataTypeToString(uint8_t type) {
  switch (type) {
    case DS_NOT_DEFINED:
      return "Not defined";
    case DS_BIT_FIELD:
      return "Bit field";
    case DS_ASCII:
      return "ASCII";
    case DS_UNSIGNED_BYTE:
      return "uint8";
    case DS_SIGNED_BYTE:
      return "int8";
    case DS_UNSIGNED_WORD:
      return "uint16";
    case DS_SIGNED_WORD:
      return "int16";
    case DS_UNSIGNED_DWORD:
      return "uint32 ";
    case DS_SIGNED_DWORD:
      return "int32 ";
    default:
      stringstream str;
      str << "Unknown, was " << static_cast<int>(type);
      return str.str();
  }
}


/**
 * Convert a uint8_t representing a lamp mode to a human-readable string.
 * @param lamp_mode the lamp mode value
 */
string LampModeToString(uint8_t lamp_mode) {
  switch (lamp_mode) {
    case LAMP_ON_MODE_OFF:
      return "Off";
    case LAMP_ON_MODE_DMX:
      return "DMX";
    case LAMP_ON_MODE_ON:
      return "On";
    case LAMP_ON_MODE_AFTER_CAL:
      return "On after calibration";
    default:
      stringstream str;
      str << "Unknown, was " << static_cast<int>(lamp_mode);
      return str.str();
  }
}


/**
 * Convert a uint8_t representing a lamp mode to a human-readable string.
 * @param lamp_state the lamp mode value
 */
string LampStateToString(uint8_t lamp_state) {
  switch (lamp_state) {
    case LAMP_OFF:
      return "Off";
    case LAMP_ON:
      return "On";
    case LAMP_STRIKE:
      return "Strike";
    case LAMP_STANDBY:
      return "Standby";
    case LAMP_NOT_PRESENT:
      return "Lamp not present";
    case LAMP_ERROR:
      return "Error";
    default:
      stringstream str;
      str << "Unknown, was " << static_cast<int>(lamp_state);
      return str.str();
  }
}


/**
 * Convert a uint16_t representing a nack reason to a human-readable string.
 * @param reason the nack reason value
 */
string NackReasonToString(uint16_t reason) {
  switch (reason) {
    case NR_UNKNOWN_PID:
      return "Unknown PID";
    case NR_FORMAT_ERROR:
      return "Format error";
    case NR_HARDWARE_FAULT:
      return "Hardware fault";
    case NR_PROXY_REJECT:
      return "Proxy reject";
    case NR_WRITE_PROTECT:
      return "Write protect";
    case NR_UNSUPPORTED_COMMAND_CLASS:
      return "Unsupported command class";
    case NR_DATA_OUT_OF_RANGE:
      return "Data out of range";
    case NR_BUFFER_FULL:
      return "Buffer full";
    case NR_PACKET_SIZE_UNSUPPORTED:
      return "Packet size unsupported";
    case NR_SUB_DEVICE_OUT_OF_RANGE:
      return "Sub device out of range";
    default:
      stringstream str;
      str << "Unknown, was " << reason;
      return str.str();
  }
}


/**
 * Convert a uint8_t representing a power state to a human-readable string.
 * @param power_state the power state value
 */
string PowerStateToString(uint8_t power_state) {
  switch (power_state) {
    case POWER_STATE_FULL_OFF:
      return "Full Off";
    case POWER_STATE_SHUTDOWN:
      return "Shutdown";
    case POWER_STATE_STANDBY:
      return "Standby";
    case POWER_STATE_NORMAL:
      return "Normal";
    default:
      stringstream str;
      str << "Unknown, was " << static_cast<int>(power_state);
      return str.str();
  }
}


/**
 * Safely convert a uint8_t to a rdm_power_state
 */
bool UIntToPowerState(uint8_t state, rdm_power_state *power_state) {
  switch (state) {
    case POWER_STATE_FULL_OFF:
      *power_state = POWER_STATE_FULL_OFF;
      return true;
    case POWER_STATE_SHUTDOWN:
      *power_state = POWER_STATE_SHUTDOWN;
      return true;
    case POWER_STATE_STANDBY:
      *power_state = POWER_STATE_STANDBY;
      return true;
    case POWER_STATE_NORMAL:
      *power_state = POWER_STATE_NORMAL;
      return true;
    default:
      return false;
  }
}


/**
 * Convert a uint8 representing a prefix to a human-readable string.
 * @param prefix the prefix value
 */
string PrefixToString(uint8_t prefix) {
  switch (prefix) {
    case PREFIX_NONE:
      return "";
    case PREFIX_DECI:
      return "Deci";
    case PREFIX_CENTI:
      return "Centi";
    case PREFIX_MILLI:
      return "Milli";
    case PREFIX_MICRO:
      return "Micro";
    case PREFIX_NANO:
      return "Nano";
    case PREFIX_PICO:
      return "Pico";
    case PREFIX_FEMPTO:
      return "Fempto";
    case PREFIX_ATTO:
      return "Atto";
    case PREFIX_ZEPTO:
      return "Zepto";
    case PREFIX_YOCTO:
      return "Yocto";
    case PREFIX_DECA:
      return "Deca";
    case PREFIX_HECTO:
      return "Hecto";
    case PREFIX_KILO:
      return "Kilo";
    case PREFIX_MEGA:
      return "Mega";
    case PREFIX_GIGA:
      return "Giga";
    case PREFIX_TERRA:
      return "Terra";
    case PREFIX_PETA:
      return "Peta";
    case PREFIX_EXA:
      return "Exa";
    case PREFIX_ZETTA:
      return "Zetta";
    case PREFIX_YOTTA:
      return "Yotta";
    default:
      stringstream str;
      str << "Unknown, was " << static_cast<int>(prefix);
      return str.str();
  }
}


/**
 * Convert a uint16_t representing a product category to a human-readable
 *   string.
 * @param category the product category value
 */
string ProductCategoryToString(uint16_t category) {
  switch (category) {
    case PRODUCT_CATEGORY_NOT_DECLARED:
      return "Not declared";
    case PRODUCT_CATEGORY_FIXTURE:
      return "Fixture";
    case PRODUCT_CATEGORY_FIXTURE_FIXED:
      return "Fixed fixture";
    case PRODUCT_CATEGORY_FIXTURE_MOVING_YOKE:
      return "Moving yoke fixture";
    case PRODUCT_CATEGORY_FIXTURE_MOVING_MIRROR:
      return "Moving mirror fixture";
    case PRODUCT_CATEGORY_FIXTURE_OTHER:
      return "Fixture other";
    case PRODUCT_CATEGORY_FIXTURE_ACCESSORY:
      return "Fixture accessory";
    case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_COLOR:
      return "Fixture accessory color";
    case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_YOKE:
      return "Fixture accessory yoke";
    case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_MIRROR:
      return "Fixture accessory mirror";
    case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_EFFECT:
      return "Fixture accessory effect";
    case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_BEAM:
      return "Fixture accessory beam";
    case PRODUCT_CATEGORY_FIXTURE_ACCESSORY_OTHER:
      return "Fixture accessory other";
    case PRODUCT_CATEGORY_PROJECTOR:
      return "Projector";
    case PRODUCT_CATEGORY_PROJECTOR_FIXED:
      return "Projector fixed";
    case PRODUCT_CATEGORY_PROJECTOR_MOVING_YOKE:
      return "Projector moving yoke";
    case PRODUCT_CATEGORY_PROJECTOR_MOVING_MIRROR:
      return "Projector moving mirror";
    case PRODUCT_CATEGORY_PROJECTOR_OTHER:
      return "Projector other";
    case PRODUCT_CATEGORY_ATMOSPHERIC:
      return "Atmospheric";
    case PRODUCT_CATEGORY_ATMOSPHERIC_EFFECT:
      return "Atmospheric effect";
    case PRODUCT_CATEGORY_ATMOSPHERIC_PYRO:
      return "Atmospheric pyro";
    case PRODUCT_CATEGORY_ATMOSPHERIC_OTHER:
      return "Atmospheric other";
    case PRODUCT_CATEGORY_DIMMER:
      return "Dimmer";
    case PRODUCT_CATEGORY_DIMMER_AC_INCANDESCENT:
      return "Dimmer AC incandescent";
    case PRODUCT_CATEGORY_DIMMER_AC_FLUORESCENT:
      return "Dimmer AC fluorescent";
    case PRODUCT_CATEGORY_DIMMER_AC_COLDCATHODE:
      return "Dimmer AC cold cathode";
    case PRODUCT_CATEGORY_DIMMER_AC_NONDIM:
      return "Dimmer AC no dim";
    case PRODUCT_CATEGORY_DIMMER_AC_ELV:
      return "Dimmer AC ELV";
    case PRODUCT_CATEGORY_DIMMER_AC_OTHER:
      return "Dimmer AC other";
    case PRODUCT_CATEGORY_DIMMER_DC_LEVEL:
      return "Dimmer DC level";
    case PRODUCT_CATEGORY_DIMMER_DC_PWM:
      return "Dimmer DC PWM";
    case PRODUCT_CATEGORY_DIMMER_CS_LED:
      return "Dimmer DC led";
    case PRODUCT_CATEGORY_DIMMER_OTHER:
      return "Dimmer other";
    case PRODUCT_CATEGORY_POWER:
      return "Power";
    case PRODUCT_CATEGORY_POWER_CONTROL:
      return "Power control";
    case PRODUCT_CATEGORY_POWER_SOURCE:
      return "Power source";
    case PRODUCT_CATEGORY_POWER_OTHER:
      return "Power other";
    case PRODUCT_CATEGORY_SCENIC:
      return "Scenic";
    case PRODUCT_CATEGORY_SCENIC_DRIVE:
      return "Scenic drive";
    case PRODUCT_CATEGORY_SCENIC_OTHER:
      return "Scenic other";
    case PRODUCT_CATEGORY_DATA:
      return "Data";
    case PRODUCT_CATEGORY_DATA_DISTRIBUTION:
      return "Data distribution";
    case PRODUCT_CATEGORY_DATA_CONVERSION:
      return "Data conversion";
    case PRODUCT_CATEGORY_DATA_OTHER:
      return "Data other";
    case PRODUCT_CATEGORY_AV:
      return "A/V";
    case PRODUCT_CATEGORY_AV_AUDIO:
      return "A/V audio";
    case PRODUCT_CATEGORY_AV_VIDEO:
      return "A/V video";
    case PRODUCT_CATEGORY_AV_OTHER:
      return "AV other";
    case PRODUCT_CATEGORY_MONITOR:
      return "monitor";
    case PRODUCT_CATEGORY_MONITOR_ACLINEPOWER:
      return "AC line power monitor";
    case PRODUCT_CATEGORY_MONITOR_DCPOWER:
      return "DC power monitor";
    case PRODUCT_CATEGORY_MONITOR_ENVIRONMENTAL:
      return "Environmental monitor";
    case PRODUCT_CATEGORY_MONITOR_OTHER:
      return "Other monitor";
    case PRODUCT_CATEGORY_CONTROL:
      return "Control";
    case PRODUCT_CATEGORY_CONTROL_CONTROLLER:
      return "Controller";
    case PRODUCT_CATEGORY_CONTROL_BACKUPDEVICE:
      return "Backup device";
    case PRODUCT_CATEGORY_CONTROL_OTHER:
      return "Other control";
    case PRODUCT_CATEGORY_TEST:
      return "Test";
    case PRODUCT_CATEGORY_TEST_EQUIPMENT:
      return "Test equipment";
    case PRODUCT_CATEGORY_TEST_EQUIPMENT_OTHER:
      return "Test equipment other";
    case PRODUCT_CATEGORY_OTHER:
      return "Other";
    default:
      stringstream str;
      str << "Unknown, was " << static_cast<int>(category);
      return str.str();
  }
}


/**
 * Convert a uint16_t representing a product detail to a human-readable string.
 * @param detail the product detail value.
 */
string ProductDetailToString(uint16_t detail) {
  switch (detail) {
    case PRODUCT_DETAIL_NOT_DECLARED:
      return "Not declared";
    case PRODUCT_DETAIL_ARC:
      return "Arc Lamp";
    case PRODUCT_DETAIL_METAL_HALIDE:
      return "Metal Halide Lamp";
    case PRODUCT_DETAIL_INCANDESCENT:
      return "Incandescent Lamp";
    case PRODUCT_DETAIL_LED:
      return "LED";
    case PRODUCT_DETAIL_FLUROESCENT:
      return "Fluroescent";
    case PRODUCT_DETAIL_COLDCATHODE:
      return "Cold Cathode";
    case PRODUCT_DETAIL_ELECTROLUMINESCENT:
      return "Electro-luminescent";
    case PRODUCT_DETAIL_LASER:
      return "Lase";
    case PRODUCT_DETAIL_FLASHTUBE:
      return "Flash Tube";
    case PRODUCT_DETAIL_COLORSCROLLER:
      return "Color Scroller";
    case PRODUCT_DETAIL_COLORWHEEL:
      return "Color Wheel";
    case PRODUCT_DETAIL_COLORCHANGE:
      return "Color Changer (Semaphore or other type)";
    case PRODUCT_DETAIL_IRIS_DOUSER:
      return "Iris";
    case PRODUCT_DETAIL_DIMMING_SHUTTER:
      return "Dimming Shuttle";
    case PRODUCT_DETAIL_PROFILE_SHUTTER:
      return "Profile Shuttle";
    case PRODUCT_DETAIL_BARNDOOR_SHUTTER:
      return "Barndoor Shuttle";
    case PRODUCT_DETAIL_EFFECTS_DISC:
      return "Effects Disc";
    case PRODUCT_DETAIL_GOBO_ROTATOR:
      return "Gobo Rotator";
    case PRODUCT_DETAIL_VIDEO:
      return "Video";
    case PRODUCT_DETAIL_SLIDE:
      return "Slide";
    case PRODUCT_DETAIL_FILM:
      return "Film";
    case PRODUCT_DETAIL_OILWHEEL:
      return "Oil Wheel";
    case PRODUCT_DETAIL_LCDGATE:
      return "LCD Gate";
    case PRODUCT_DETAIL_FOGGER_GLYCOL:
      return "Fogger, Glycol";
    case PRODUCT_DETAIL_FOGGER_MINERALOIL:
      return "Fogger, Mineral Oil";
    case PRODUCT_DETAIL_FOGGER_WATER:
      return "Fogger, Water";
    case PRODUCT_DETAIL_CO2:
      return "Dry Ice/ Carbon Dioxide Device";
    case PRODUCT_DETAIL_LN2:
      return "Nitrogen based";
    case PRODUCT_DETAIL_BUBBLE:
      return "Bubble or Foam Machine";
    case PRODUCT_DETAIL_FLAME_PROPANE:
      return "Propane Flame";
    case PRODUCT_DETAIL_FLAME_OTHER:
      return "Other Flame";
    case PRODUCT_DETAIL_OLEFACTORY_STIMULATOR:
      return "Scents";
    case PRODUCT_DETAIL_SNOW:
      return "Snow Machine";
    case PRODUCT_DETAIL_WATER_JET:
      return "Water Jet";
    case PRODUCT_DETAIL_WIND:
      return "Wind Machine";
    case PRODUCT_DETAIL_CONFETTI:
      return "Confetti Machine";
    case PRODUCT_DETAIL_HAZARD:
      return "Hazard (Any form of pyrotechnic control or device.)";
    case PRODUCT_DETAIL_PHASE_CONTROL:
      return "Phase Control";
    case PRODUCT_DETAIL_REVERSE_PHASE_CONTROL:
      return "Phase Angle";
    case PRODUCT_DETAIL_SINE:
      return "Sine";
    case PRODUCT_DETAIL_PWM:
      return "PWM";
    case PRODUCT_DETAIL_DC:
      return "DC";
    case PRODUCT_DETAIL_HFBALLAST:
      return "HF Ballast";
    case PRODUCT_DETAIL_HFHV_NEONBALLAST:
      return "HFHV Neon/Argon";
    case PRODUCT_DETAIL_HFHV_EL:
      return "HFHV Electroluminscent";
    case PRODUCT_DETAIL_MHR_BALLAST:
      return "Metal Halide Ballast";
    case PRODUCT_DETAIL_BITANGLE_MODULATION:
      return "Bit Angle Modulation";
    case PRODUCT_DETAIL_FREQUENCY_MODULATION:
      return "Frequency Modulation";
    case PRODUCT_DETAIL_HIGHFREQUENCY_12V:
      return "High Frequency 12V";
    case PRODUCT_DETAIL_RELAY_MECHANICAL:
      return "Mechanical Relay";
    case PRODUCT_DETAIL_RELAY_ELECTRONIC:
      return "Electronic Relay";
    case PRODUCT_DETAIL_SWITCH_ELECTRONIC:
      return "Electronic Switch";
    case PRODUCT_DETAIL_CONTACTOR:
      return "Contactor";
    case PRODUCT_DETAIL_MIRRORBALL_ROTATOR:
      return "Mirror Ball Rotator";
    case PRODUCT_DETAIL_OTHER_ROTATOR:
      return "Other Rotator";
    case PRODUCT_DETAIL_KABUKI_DROP:
      return "Kabuki Drop";
    case PRODUCT_DETAIL_CURTAIN:
      return "Curtain";
    case PRODUCT_DETAIL_LINESET:
      return "Line Set";
    case PRODUCT_DETAIL_MOTOR_CONTROL:
      return "Motor Control";
    case PRODUCT_DETAIL_DAMPER_CONTROL:
      return "Damper Control";
    case PRODUCT_DETAIL_SPLITTER:
      return "Splitter";
    case PRODUCT_DETAIL_ETHERNET_NODE:
      return "Ethernet Node";
    case PRODUCT_DETAIL_MERGE:
      return "DMX512 Merger";
    case PRODUCT_DETAIL_DATAPATCH:
      return "Data Patch";
    case PRODUCT_DETAIL_WIRELESS_LINK:
      return "Wireless link";
    case PRODUCT_DETAIL_PROTOCOL_CONVERTOR:
      return "Protocol Convertor";
    case PRODUCT_DETAIL_ANALOG_DEMULTIPLEX:
      return "DMX512 to DC Voltage";
    case PRODUCT_DETAIL_ANALOG_MULTIPLEX:
      return "DC Voltage to DMX512";
    case PRODUCT_DETAIL_SWITCH_PANEL:
      return "Switch Panel";
    case PRODUCT_DETAIL_ROUTER:
      return "Router";
    case PRODUCT_DETAIL_FADER:
      return "Fader, Single Channel";
    case PRODUCT_DETAIL_MIXER:
      return "Mixer, Multi Channel";
    case PRODUCT_DETAIL_CHANGEOVER_MANUAL:
      return "Manual Changeover";
    case PRODUCT_DETAIL_CHANGEOVER_AUTO:
      return "Auto Changeover";
    case PRODUCT_DETAIL_TEST:
      return "Test Device";
    case PRODUCT_DETAIL_GFI_RCD:
      return "GFI / RCD Device";
    case PRODUCT_DETAIL_BATTERY:
      return "Battery";
    case PRODUCT_DETAIL_CONTROLLABLE_BREAKER:
      return "Controllable Breaker";
    case PRODUCT_DETAIL_OTHER:
      return "Other Device";
    default:
      stringstream str;
      str << "Unknown, was " << detail;
      return str.str();
  }
}


/**
 * Convert a uint8_t representing a sensor type to a human-readable string.
 * @param type the sensor type value
 */
string SensorTypeToString(uint8_t type) {
  switch (type) {
    case SENSOR_TEMPERATURE:
      return "Temperature";
    case SENSOR_VOLTAGE:
      return "Voltage";
    case SENSOR_CURRENT:
      return "Current";
    case SENSOR_FREQUENCY:
      return "Frequency";
    case SENSOR_RESISTANCE:
      return "Resistance";
    case SENSOR_POWER:
      return "Power";
    case SENSOR_MASS:
      return "Mass";
    case SENSOR_LENGTH:
      return "Length";
    case SENSOR_AREA:
      return "Area";
    case SENSOR_VOLUME:
      return "Volume";
    case SENSOR_DENSITY:
      return "Density";
    case SENSOR_VELOCITY:
      return "Velocity";
    case SENSOR_ACCELERATION:
      return "Acceleration";
    case SENSOR_FORCE:
      return "Force";
    case SENSOR_ENERGY:
      return "Energy";
    case SENSOR_PRESSURE:
      return "Pressure";
    case SENSOR_TIME:
      return "Time";
    case SENSOR_ANGLE:
      return "Angle";
    case SENSOR_POSITION_X:
      return "Position X";
    case SENSOR_POSITION_Y:
      return "Position Y";
    case SENSOR_POSITION_Z:
      return "Position Z";
    case SENSOR_ANGULAR_VELOCITY:
      return "Angular velocity";
    case SENSOR_LUMINOUS_INTENSITY:
      return "Luminous intensity";
    case SENSOR_LUMINOUS_FLUX:
      return "Luminous flux";
    case SENSOR_ILLUMINANCE:
      return "Illuminance";
    case SENSOR_CHROMINANCE_RED:
      return "Chrominance red";
    case SENSOR_CHROMINANCE_GREEN:
      return "Chrominance green";
    case SENSOR_CHROMINANCE_BLUE:
      return "Chrominance blue";
    case SENSOR_CONTACTS:
      return "Contacts";
    case SENSOR_MEMORY:
      return "Memory";
    case SENSOR_ITEMS:
      return "Items";
    case SENSOR_HUMIDITY:
      return "Humidity";
    case SENSOR_COUNTER_16BIT:
      return "16 bith counter";
    case SENSOR_OTHER:
      return "Other";
    default:
      stringstream str;
      str << "Unknown, was " << static_cast<int>(type);
      return str.str();
  }
}


/**
 * Convert a uint16_t representing a slot type to a human-readable string.
 * @param slot_type the type of the slot.
 * @param slot_label the label for the slot.
 */
string SlotInfoToString(uint8_t slot_type, uint16_t slot_label) {
  if (slot_type == ST_PRIMARY) {
    switch (slot_label) {
      case SD_INTENSITY:
        return "Primary, intensity";
      case SD_INTENSITY_MASTER:
        return "Primary, intensity master";
      case SD_PAN:
        return "Primary, pan";
      case SD_TILT:
        return "Primary, tilt";
      case SD_COLOR_WHEEL:
        return "Primary, color wheel";
      case SD_COLOR_SUB_CYAN:
        return "Primary, subtractive cyan";
      case SD_COLOR_SUB_YELLOW:
        return "Primary, subtractive yellow";
      case SD_COLOR_SUB_MAGENTA:
        return "Primary, subtractive magenta";
      case SD_COLOR_ADD_RED:
        return "Primary, additive red";
      case SD_COLOR_ADD_GREEN:
        return "Primary, additive green";
      case SD_COLOR_ADD_BLUE:
        return "Primary, additive blue";
      case SD_COLOR_CORRECTION:
        return "Primary, color correction";
      case SD_COLOR_SCROLL:
        return "Primary, scroll";
      case SD_COLOR_SEMAPHORE:
        return "Primary, color semaphone";
      case SD_STATIC_GOBO_WHEEL:
        return "Primary, static gobo wheel";
      case SD_ROTO_GOBO_WHEEL:
        return "Primary, gobo wheel";
      case SD_PRISM_WHEEL:
        return "Primary, prism wheel";
      case SD_EFFECTS_WHEEL:
        return "Primary, effects wheel";
      case SD_BEAM_SIZE_IRIS:
        return "Primary, iris size";
      case SD_EDGE:
        return "Primary, edge";
      case SD_FROST:
        return "Primary, frost";
      case SD_STROBE:
        return "Primary, strobe";
      case SD_ZOOM:
        return "Primary, zoom";
      case SD_FRAMING_SHUTTER:
        return "Primary, framing shutter";
      case SD_SHUTTER_ROTATE:
        return "Primary, shuttle rotate";
      case SD_DOUSER:
        return "Primary, douser";
      case SD_BARN_DOOR:
        return "Primary, barn door";
      case SD_LAMP_CONTROL:
        return "Primary, lamp control";
      case SD_FIXTURE_CONTROL:
        return "Primary, fixture control";
      case SD_FIXTURE_SPEED:
        return "Primary, fixture speed";
      case SD_MACRO:
        return "Primary, macro";
      case SD_UNDEFINED:
        return "Primary, undefined";
      default:
        stringstream str;
        str << "Primary unknown, was " << slot_label;
        return str.str();
    }
  } else {
    stringstream str;
    switch (slot_type) {
      case ST_SEC_FINE:
        str << "fine control for slot " << slot_label;
        break;
      case ST_SEC_TIMING:
        str << "timing control for slot " << slot_label;
        break;
      case ST_SEC_SPEED:
        str << "speed control for slot " << slot_label;
        break;
      case ST_SEC_CONTROL:
        str << "mode control for slot " << slot_label;
        break;
      case ST_SEC_INDEX:
        str << "index control for slot " << slot_label;
        break;
      case ST_SEC_ROTATION:
        str << "rotation speed control for slot " << slot_label;
        break;
      case ST_SEC_INDEX_ROTATE:
        str << "rotation index control for slot " << slot_label;
        break;
      case ST_SEC_UNDEFINED:
        str << "undefined for slot " << slot_label;
        break;
      default:
        str << "unknown for slot " << slot_label;
    }
    return str.str();
  }
}


/**
 * Convert a uint16_t representing a status message to a human-readable string.
 * @param message_id the status message value
 */
string StatusMessageIdToString(uint16_t message_id) {
  switch (message_id) {
    case STS_CAL_FAIL:
      return "Failed calibration";
    case STS_SENS_NOT_FOUND:
      return "sensor not found";
    case STS_SENS_ALWAYS_ON:
      return "sensor always on";
    case STS_LAMP_DOUSED:
      return "sensor lamp doused";
    case STS_LAMP_STRIKE:
      return "sensor lamp failed to strike";
    case STS_OVERTEMP:
      return "over temp";
    case STS_UNDERTEMP:
      return "under temp";
    case STS_SENS_OUT_RANGE:
      return "sensor out of range";
    case STS_OVERVOLTAGE_PHASE:
      return "phase over voltage";
    case STS_UNDERVOLTAGE_PHASE:
      return "phase under voltage";
    case STS_OVERCURRENT:
      return "over current";
    case STS_UNDERCURRENT:
      return "under current";
    case STS_PHASE:
      return "out of phase";
    case STS_PHASE_ERROR:
      return "phase error";
    case STS_AMPS:
      return "amps";
    case STS_VOLTS:
      return "volts";
    case STS_DIMSLOT_OCCUPIED:
      return "no dimmer";
    case STS_BREAKER_TRIP:
      return "breaker tripped";
    case STS_WATTS:
      return "watts";
    case STS_DIM_FAILURE:
      return "dimmer failure";
    case STS_DIM_PANIC:
      return "dimmer panic mode";
    case STS_READY:
      return "ready";
    case STS_NOT_READY:
      return "not ready";
    case STS_LOW_FLUID:
      return "low fluid";
    default:
      stringstream str;
      str << "Unknown, was " << message_id;
      return str.str();
  }
}


/**
 * Convert a uint8_t representing a status type to a human-readable string.
 * @param status_type the status type value
 */
string StatusTypeToString(uint8_t status_type) {
  switch (status_type) {
    case STATUS_NONE:
      return "None";
    case STATUS_GET_LAST_MESSAGE:
      return "Get last messages";
    case STATUS_ADVISORY:
      return "Advisory";
    case STATUS_WARNING:
      return "Warning";
    case STATUS_ERROR:
      return "Error";
    case STATUS_ADVISORY_CLEARED:
      return "Advisory cleared";
    case STATUS_WARNING_CLEARED:
      return "Warning cleared";
    case STATUS_ERROR_CLEARED:
      return "Error cleared";
    default:
      stringstream str;
      str << "Unknown, was " << static_cast<int>(status_type);
      return str.str();
  }
}



/**
 * Convert a uint8_t representing a unit to a human-readable string.
 * @param unit the unit value
 */
string UnitToString(uint8_t unit) {
  switch (unit) {
    case UNITS_NONE:
      return "none";
    case UNITS_CENTIGRADE:
      return "degrees C";
    case UNITS_VOLTS_DC:
      return "Volts (DC)";
    case UNITS_VOLTS_AC_PEAK:
      return "Volts (AC Peak)";
    case UNITS_VOLTS_AC_RMS:
      return "Volts (AC RMS)";
    case UNITS_AMPERE_DC:
      return "Amps (DC)";
    case UNITS_AMPERE_AC_PEAK:
      return "Amps (AC Peak)";
    case UNITS_AMPERE_AC_RMS:
      return "Amps (AC RMS)";
    case UNITS_HERTZ:
      return "Hz";
    case UNITS_OHM:
      return "ohms";
    case UNITS_WATT:
      return "W";
    case UNITS_KILOGRAM:
      return "kg";
    case UNITS_METERS:
      return "m";
    case UNITS_METERS_SQUARED:
      return "m^2";
    case UNITS_METERS_CUBED:
      return "m^3";
    case UNITS_KILOGRAMMES_PER_METER_CUBED:
      return "kg/m^3";
    case UNITS_METERS_PER_SECOND:
      return "m/s";
    case UNITS_METERS_PER_SECOND_SQUARED:
      return "m/s^2";
    case UNITS_NEWTON:
      return "newton";
    case UNITS_JOULE:
      return "joule";
    case UNITS_PASCAL:
      return "pascal";
    case UNITS_SECOND:
      return "second";
    case UNITS_DEGREE:
      return "degree";
    case UNITS_STERADIAN:
      return "steradian";
    case UNITS_CANDELA:
      return "candela";
    case UNITS_LUMEN:
      return "lumen";
    case UNITS_LUX:
      return "lux";
    case UNITS_IRE:
      return "ire";
    case UNITS_BYTE:
      return "bytes";
    default:
      stringstream str;
      str << "Unknown, was " << static_cast<int>(unit);
      return str.str();
  }
}
}  // rdm
}  //  ola