/*---------------------------------------------------------*\
| cli.cpp                                                   |
|                                                           |
|   OpenRGB command line interface                          |
|                                                           |
|   This file is part of the OpenRGB project                |
|   SPDX-License-Identifier: GPL-2.0-only                   |
\*---------------------------------------------------------*/

#include <vector>
#include <cstring>
#include <string>
#include <tuple>
#include <iostream>
#include "AutoStart.h"
#include "filesystem.h"
#include "ProfileManager.h"
#include "ResourceManager.h"
#include "RGBController.h"
#include "i2c_smbus.h"
#include "NetworkClient.h"
#include "NetworkServer.h"
#include "LogManager.h"
#include "Colors.h"

/*-------------------------------------------------------------*\
| Quirk for MSVC; which doesn't support this case-insensitive   |
| function                                                      |
\*-------------------------------------------------------------*/
#ifdef _WIN32
#include <shellapi.h>
    #define strcasecmp strcmpi
#endif

using namespace std::chrono_literals;

static std::string                 profile_save_filename = "";
const unsigned int                 brightness_percentage = 100;
const unsigned int                 speed_percentage      = 100;

static int preserve_argc = 0;
static char** preserve_argv = nullptr;

enum
{
    RET_FLAG_PRINT_HELP         = 1,
    RET_FLAG_START_GUI          = 2,
    RET_FLAG_I2C_TOOLS          = 4,
    RET_FLAG_START_MINIMIZED    = 8,
    RET_FLAG_NO_DETECT          = 16,
    RET_FLAG_CLI_POST_DETECTION = 32,
    RET_FLAG_START_SERVER       = 64,
    RET_FLAG_NO_AUTO_CONNECT    = 128,
};

struct DeviceOptions
{
    int             device;
    int             zone            = -1;
    std::vector<std::tuple<unsigned char, unsigned char, unsigned char>> colors;
    std::string     mode;
    unsigned int    speed           = 100;
    unsigned int    brightness      = 100;
    unsigned int    size;
    bool            random_colors   = false;
    bool            hasSize         = false;
    bool            hasOption       = false;
};

struct ServerOptions
{
    bool start = false;
    unsigned short  port = OPENRGB_SDK_PORT;
};

struct Options
{
    std::vector<DeviceOptions>  devices;

    /*---------------------------------------------------------*\
    | If hasDevice is false, devices above is empty and         |
    | allDeviceOptions shall be applied to all available devices|
    | except in the case that a profile was loaded.             |
    \*---------------------------------------------------------*/
    bool                        hasDevice        = false;
    bool                        profile_loaded  = false;
    DeviceOptions               allDeviceOptions;
    ServerOptions               servOpts;
};

/*---------------------------------------------------------------------------------------------------------*\
| Support a common subset of human colors; for easier typing: https://www.w3.org/TR/css-color-3/#svg-color  |
\*---------------------------------------------------------------------------------------------------------*/
struct HumanColors { uint32_t rgb; const char* keyword; } static const human_colors[] =
{
    { COLOR_BLACK, "black" },
    { COLOR_NAVY, "navy" },
    { COLOR_DARKBLUE, "darkblue" },
    { COLOR_MEDIUMBLUE, "mediumblue" },
    { COLOR_BLUE, "blue" },
    { COLOR_DARKGREEN, "darkgreen" },
    { COLOR_GREEN, "green" },
    { COLOR_TEAL, "teal" },
    { COLOR_DARKCYAN, "darkcyan" },
    { COLOR_DEEPSKYBLUE, "deepskyblue" },
    { COLOR_DARKTURQUOISE, "darkturquoise" },
    { COLOR_MEDIUMSPRINGGREEN, "mediumspringgreen" },
    { COLOR_LIME, "lime" },
    { COLOR_SPRINGGREEN, "springgreen" },
    { COLOR_AQUA, "aqua" },
    { COLOR_CYAN, "cyan" },
    { COLOR_MIDNIGHTBLUE, "midnightblue" },
    { COLOR_DODGERBLUE, "dodgerblue" },
    { COLOR_LIGHTSEAGREEN, "lightseagreen" },
    { COLOR_FORESTGREEN, "forestgreen" },
    { COLOR_SEAGREEN, "seagreen" },
    { COLOR_DARKSLATEGRAY, "darkslategray" },
    { COLOR_DARKSLATEGREY, "darkslategrey" },
    { COLOR_LIMEGREEN, "limegreen" },
    { COLOR_MEDIUMSEAGREEN, "mediumseagreen" },
    { COLOR_TURQUOISE, "turquoise" },
    { COLOR_ROYALBLUE, "royalblue" },
    { COLOR_STEELBLUE, "steelblue" },
    { COLOR_DARKSLATEBLUE, "darkslateblue" },
    { COLOR_MEDIUMTURQUOISE, "mediumturquoise" },
    { COLOR_INDIGO, "indigo" },
    { COLOR_DARKOLIVEGREEN, "darkolivegreen" },
    { COLOR_CADETBLUE, "cadetblue" },
    { COLOR_CORNFLOWERBLUE, "cornflowerblue" },
    { COLOR_MEDIUMAQUAMARINE, "mediumaquamarine" },
    { COLOR_DIMGRAY, "dimgray" },
    { COLOR_DIMGREY, "dimgrey" },
    { COLOR_SLATEBLUE, "slateblue" },
    { COLOR_OLIVEDRAB, "olivedrab" },
    { COLOR_SLATEGRAY, "slategray" },
    { COLOR_SLATEGREY, "slategrey" },
    { COLOR_LIGHTSLATEGRAY, "lightslategray" },
    { COLOR_LIGHTSLATEGREY, "lightslategrey" },
    { COLOR_MEDIUMSLATEBLUE, "mediumslateblue" },
    { COLOR_LAWNGREEN, "lawngreen" },
    { COLOR_CHARTREUSE, "chartreuse" },
    { COLOR_AQUAMARINE, "aquamarine" },
    { COLOR_MAROON, "maroon" },
    { COLOR_PURPLE, "purple" },
    { COLOR_ELECTRIC_ULTRAMARINE, "electricultramarine" },
    { COLOR_OLIVE, "olive" },
    { COLOR_GRAY, "gray" },
    { COLOR_GREY, "grey" },
    { COLOR_SKYBLUE, "skyblue" },
    { COLOR_LIGHTSKYBLUE, "lightskyblue" },
    { COLOR_BLUEVIOLET, "blueviolet" },
    { COLOR_DARKRED, "darkred" },
    { COLOR_DARKMAGENTA, "darkmagenta" },
    { COLOR_SADDLEBROWN, "saddlebrown" },
    { COLOR_DARKSEAGREEN, "darkseagreen" },
    { COLOR_LIGHTGREEN, "lightgreen" },
    { COLOR_MEDIUMPURPLE, "mediumpurple" },
    { COLOR_DARKVIOLET, "darkviolet" },
    { COLOR_PALEGREEN, "palegreen" },
    { COLOR_DARKORCHID, "darkorchid" },
    { COLOR_YELLOWGREEN, "yellowgreen" },
    { COLOR_SIENNA, "sienna" },
    { COLOR_BROWN, "brown" },
    { COLOR_DARKGRAY, "darkgray" },
    { COLOR_DARKGREY, "darkgrey" },
    { COLOR_LIGHTBLUE, "lightblue" },
    { COLOR_GREENYELLOW, "greenyellow" },
    { COLOR_PALETURQUOISE, "paleturquoise" },
    { COLOR_LIGHTSTEELBLUE, "lightsteelblue" },
    { COLOR_POWDERBLUE, "powderblue" },
    { COLOR_FIREBRICK, "firebrick" },
    { COLOR_DARKGOLDENROD, "darkgoldenrod" },
    { COLOR_MEDIUMORCHID, "mediumorchid" },
    { COLOR_ROSYBROWN, "rosybrown" },
    { COLOR_DARKKHAKI, "darkkhaki" },
    { COLOR_SILVER, "silver" },
    { COLOR_MEDIUMVIOLETRED, "mediumvioletred" },
    { COLOR_INDIANRED, "indianred" },
    { COLOR_PERU, "peru" },
    { COLOR_CHOCOLATE, "chocolate" },
    { COLOR_TAN, "tan" },
    { COLOR_LIGHTGRAY, "lightgray" },
    { COLOR_LIGHTGREY, "lightgrey" },
    { COLOR_THISTLE, "thistle" },
    { COLOR_ORCHID, "orchid" },
    { COLOR_GOLDENROD, "goldenrod" },
    { COLOR_PALEVIOLETRED, "palevioletred" },
    { COLOR_CRIMSON, "crimson" },
    { COLOR_GAINSBORO, "gainsboro" },
    { COLOR_PLUM, "plum" },
    { COLOR_BURLYWOOD, "burlywood" },
    { COLOR_LIGHTCYAN, "lightcyan" },
    { COLOR_LAVENDER, "lavender" },
    { COLOR_DARKSALMON, "darksalmon" },
    { COLOR_VIOLET, "violet" },
    { COLOR_PALEGOLDENROD, "palegoldenrod" },
    { COLOR_LIGHTCORAL, "lightcoral" },
    { COLOR_KHAKI, "khaki" },
    { COLOR_ALICEBLUE, "aliceblue" },
    { COLOR_HONEYDEW, "honeydew" },
    { COLOR_AZURE, "azure" },
    { COLOR_SANDYBROWN, "sandybrown" },
    { COLOR_WHEAT, "wheat" },
    { COLOR_BEIGE, "beige" },
    { COLOR_WHITESMOKE, "whitesmoke" },
    { COLOR_MINTCREAM, "mintcream" },
    { COLOR_GHOSTWHITE, "ghostwhite" },
    { COLOR_SALMON, "salmon" },
    { COLOR_ANTIQUEWHITE, "antiquewhite" },
    { COLOR_LINEN, "linen" },
    { COLOR_LIGHTGOLDENRODYELLOW, "lightgoldenrodyellow" },
    { COLOR_OLDLACE, "oldlace" },
    { COLOR_RED, "red" },
    { COLOR_FUCHSIA, "fuchsia" },
    { COLOR_MAGENTA, "magenta" },
    { COLOR_DEEPPINK, "deeppink" },
    { COLOR_ORANGERED, "orangered" },
    { COLOR_TOMATO, "tomato" },
    { COLOR_HOTPINK, "hotpink" },
    { COLOR_CORAL, "coral" },
    { COLOR_DARKORANGE, "darkorange" },
    { COLOR_LIGHTSALMON, "lightsalmon" },
    { COLOR_ORANGE, "orange" },
    { COLOR_LIGHTPINK, "lightpink" },
    { COLOR_PINK, "pink" },
    { COLOR_GOLD, "gold" },
    { COLOR_PEACHPUFF, "peachpuff" },
    { COLOR_NAVAJOWHITE, "navajowhite" },
    { COLOR_MOCCASIN, "moccasin" },
    { COLOR_BISQUE, "bisque" },
    { COLOR_MISTYROSE, "mistyrose" },
    { COLOR_BLANCHEDALMOND, "blanchedalmond" },
    { COLOR_PAPAYAWHIP, "papayawhip" },
    { COLOR_LAVENDERBLUSH, "lavenderblush" },
    { COLOR_SEASHELL, "seashell" },
    { COLOR_CORNSILK, "cornsilk" },
    { COLOR_LEMONCHIFFON, "lemonchiffon" },
    { COLOR_FLORALWHITE, "floralwhite" },
    { COLOR_SNOW, "snow" },
    { COLOR_YELLOW, "yellow" },
    { COLOR_LIGHTYELLOW, "lightyellow" },
    { COLOR_IVORY, "ivory" },
    { COLOR_WHITE, "white" },
    { 0, NULL }
};

bool ParseColors(std::string colors_string, DeviceOptions *options)
{
    while (colors_string.length() > 0)
    {
        size_t    rgb_end = colors_string.find_first_of(',');
        std::string color = colors_string.substr(0, rgb_end);
        int32_t rgb = 0;

        bool parsed = false;

        if (color.length() <= 0)
            break;

        /*-----------------------------------------------------------------*\
        | This will set correct colour mode for modes with a                |
        |   MODE_COLORS_RANDOM else generate a random colour from the       |
        |   human_colors list above                                         |
        \*-----------------------------------------------------------------*/
        if (color == "random")
        {
            options->random_colors = true;
            srand((unsigned int)time(NULL));
            int index = rand() % (sizeof(human_colors) / sizeof(human_colors[0])) + 1; //Anything other than black
            rgb = human_colors[index].rgb;
            parsed = true;
        }
        else
        {
            /* swy: (A) try interpreting it as text; as human keywords, otherwise strtoul() will pick up 'darkgreen' as 0xDA */
            for (const struct HumanColors *hc = human_colors; hc->keyword != NULL; hc++)
            {
                if (strcasecmp(hc->keyword, color.c_str()) != 0)
                    continue;

                rgb = hc->rgb; parsed = true;

                break;
            }
        }

        /* swy: (B) no luck, try interpreting it as an hexadecimal number instead */
        if (!parsed)
        {
            if (color.length() == 6)
            {
                const char *colorptr = color.c_str(); char *endptr = NULL;

                rgb = strtoul(colorptr, &endptr, 16);

                /* swy: check that strtoul() has advanced the read pointer until the end (NULL terminator);
                        that means it has read the whole thing */
                if (colorptr != endptr && endptr && *endptr == '\0')
                    parsed = true;
            }
        }

        /* swy: we got it, save the 32-bit integer as a tuple of three RGB bytes */
        if (parsed)
        {
            options->colors.push_back(std::make_tuple(
                (rgb >> (8 * 2)) & 0xFF, /* RR.... */
                (rgb >> (8 * 1)) & 0xFF, /* ..GG.. */
                (rgb >> (8 * 0)) & 0xFF  /* ....BB */
            ));
        }
        else
        {
            std::cout << "Error: Unknown color: '" + color + "', skipping." << std::endl;
        }

        // If there are no more colors
        if (rgb_end == std::string::npos)
            break;

        // Remove the current color and the next color's leading comma
        colors_string = colors_string.substr(color.length() + 1);
    }

    return options->colors.size() > 0;
}

unsigned int ParseMode(DeviceOptions& options, std::vector<RGBController *> &rgb_controllers)
{
    // no need to check if --mode wasn't passed
    if (options.mode.size() == 0)
    {
        return rgb_controllers[options.device]->active_mode;
    }

    /*---------------------------------------------------------*\
    | Search through all of the device modes and see if there is|
    | a match.  If no match is found, print an error message.   |
    \*---------------------------------------------------------*/
    for(unsigned int mode_idx = 0; mode_idx < rgb_controllers[options.device]->modes.size(); mode_idx++)
    {
        if (strcasecmp(rgb_controllers[options.device]->modes[mode_idx].name.c_str(), options.mode.c_str()) == 0)
        {
            return mode_idx;
        }
    }

    std::cout << "Error: Mode '" + options.mode + "' not available for device '" + rgb_controllers[options.device]->name + "'" << std::endl;
    return false;
}

DeviceOptions* GetDeviceOptionsForDevID(Options *opts, int device)
{
    if (device == -1)
    {
        return &opts->allDeviceOptions;
    }

    for (unsigned int i = 0; i < opts->devices.size(); i++)
    {
        if (opts->devices[i].device == device)
        {
            return &opts->devices[i];
        }
    }

    // should never happen
    std::cout << "Internal error: Tried setting an option on a device that wasn't specified" << std::endl;
    abort();
}

std::string QuoteIfNecessary(std::string str)
{
    if (str.find(' ') == std::string::npos)
    {
        return str;
    }
    else
    {
        return "'" + str + "'";
    }
}

/*---------------------------------------------------------------------------------------------------------*\
| Option processing functions                                                                               |
\*---------------------------------------------------------------------------------------------------------*/

void OptionHelp()
{
    std::string help_text;
    help_text += "OpenRGB ";
    help_text += VERSION_STRING;
    help_text += ", for controlling RGB lighting.\n";
    help_text += "Usage: OpenRGB (--device [--mode] [--color])...\n";
    help_text += "\n";
    help_text += "Options:\n";
    help_text += "--gui                                    Shows the GUI. GUI also appears when not passing any parameters\n";
    help_text += "--startminimized                         Starts the GUI minimized to tray. Implies --gui, even if not specified\n";
    help_text += "--client [IP]:[Port]                     Starts an SDK client on the given IP:Port (assumes port 6742 if not specified)\n";
    help_text += "--server                                 Starts the SDK's server\n";
    help_text += "--server-host                            Sets the SDK's server host. Default: 0.0.0.0 (all network interfaces)\n";
    help_text += "--server-port                            Sets the SDK's server port. Default: 6742 (1024-65535)\n";
    help_text += "-l,  --list-devices                      Lists every compatible device with their number\n";
    help_text += "-d,  --device [0-9 | \"name\"]             Selects device to apply colors and/or effect to, or applies to all devices if omitted\n";
    help_text += "                                           Basic string search is implemented 3 characters or more\n";
    help_text += "                                           Can be specified multiple times with different modes and colors\n";
    help_text += "-z,  --zone [0-9]                        Selects zone to apply colors and/or sizes to, or applies to all zones in device if omitted\n";
    help_text += "                                           Must be specified after specifying a device\n";
    help_text += "-c,  --color [random | FFFFF,00AAFF ...] Sets colors on each device directly if no effect is specified, and sets the effect color if an effect is specified\n";
    help_text += "                                           If there are more LEDs than colors given, the last color will be applied to the remaining LEDs\n";
    help_text += "-m,  --mode [breathing | static | ...]   Sets the mode to be applied, check --list-devices to see which modes are supported on your device\n";
    help_text += "-b,  --brightness [0-100]                Sets the brightness as a percentage if the mode supports brightness\n";
    help_text += "-s, --speed [0-100]                      Sets the speed as a percentage if the mode supports speed\n";
    help_text += "-sz,  --size [0-N]                       Sets the new size of the specified device zone.\n";
    help_text += "                                           Must be specified after specifying a zone.\n";
    help_text += "                                           If the specified size is out of range, or the zone does not offer resizing capability, the size will not be changed\n";
    help_text += "-V,  --version                           Display version and software build information\n";
    help_text += "-p,  --profile filename[.orp]            Load the profile from filename/filename.orp\n";
    help_text += "-sp, --save-profile filename.orp         Save the given settings to profile filename.orp\n";
    help_text += "--i2c-tools                              Shows the I2C/SMBus Tools page in the GUI. Implies --gui, even if not specified.\n";
    help_text += "                                           USE I2C TOOLS AT YOUR OWN RISK! Don't use this option if you don't know what you're doing!\n";
    help_text += "                                           There is a risk of bricking your motherboard, RGB controller, and RAM if you send invalid SMBus/I2C transactions.\n";
    help_text += "--localconfig                            Use the current working directory instead of the global configuration directory.\n";
    help_text += "--config path                            Use a custom path instead of the global configuration directory.\n";
    help_text += "--nodetect                               Do not try to detect hardware at startup.\n";
    help_text += "--noautoconnect                          Do not try to autoconnect to a local server at startup.\n";
    help_text += "--loglevel [0-6 | error | warning ...]   Set the log level (0: fatal to 6: trace).\n";
    help_text += "--print-source                           Print the source code file and line number for each log entry.\n";
    help_text += "-v,  --verbose                           Print log messages to stdout.\n";
    help_text += "-vv, --very-verbose                      Print debug messages and log messages to stdout.\n";
    help_text += "--autostart-check                        Check if OpenRGB starting at login is enabled.\n";
    help_text += "--autostart-disable                      Disable OpenRGB starting at login.\n";
    help_text += "--autostart-enable arguments             Enable OpenRGB to start at login. Requires arguments to give to OpenRGB at login.\n";

    std::cout << help_text << std::endl;
}

void OptionVersion()
{
    std::string version_text;
    version_text += "OpenRGB ";
    version_text += VERSION_STRING;
    version_text += ", for controlling RGB lighting.\n";
    version_text += "  Version:\t\t ";
    version_text += VERSION_STRING;
    version_text += "\n  Build Date\t\t ";
    version_text += BUILDDATE_STRING;
    version_text += "\n  Git Commit ID\t\t ";
    version_text += GIT_COMMIT_ID;
    version_text += "\n  Git Commit Date\t ";
    version_text += GIT_COMMIT_DATE;
    version_text += "\n  Git Branch\t\t ";
    version_text += GIT_BRANCH;
    version_text += "\n";

    std::cout << version_text << std::endl;
}

void OptionListDevices(std::vector<RGBController *>& rgb_controllers)
{
    ResourceManager::get()->WaitForDeviceDetection();

    for(std::size_t controller_idx = 0; controller_idx < rgb_controllers.size(); controller_idx++)
    {
        RGBController *controller = rgb_controllers[controller_idx];

        /*---------------------------------------------------------*\
        | Print device name                                         |
        \*---------------------------------------------------------*/
        std::cout << controller_idx << ": " << controller->name << std::endl;

        /*---------------------------------------------------------*\
        | Print device type                                         |
        \*---------------------------------------------------------*/
            std::cout << "  Type:           " << device_type_to_str(controller->type) << std::endl;

        /*---------------------------------------------------------*\
        | Print device description                                  |
        \*---------------------------------------------------------*/
        if(!controller->description.empty())
        {
            std::cout << "  Description:    " << controller->description << std::endl;
        }

        /*---------------------------------------------------------*\
        | Print device version                                      |
        \*---------------------------------------------------------*/
        if(!controller->version.empty())
        {
            std::cout << "  Version:        " << controller->version << std::endl;
        }

        /*---------------------------------------------------------*\
        | Print device location                                     |
        \*---------------------------------------------------------*/
        if(!controller->location.empty())
        {
            std::cout << "  Location:       " << controller->location << std::endl;
        }

        /*---------------------------------------------------------*\
        | Print device serial                                       |
        \*---------------------------------------------------------*/
        if(!controller->serial.empty())
        {
            std::cout << "  Serial:         " << controller->serial << std::endl;
        }

        /*---------------------------------------------------------*\
        | Print device modes                                        |
        \*---------------------------------------------------------*/
        if(!controller->modes.empty())
        {
            std::cout << "  Modes:";

            int current_mode = controller->GetMode();
            for(std::size_t mode_idx = 0; mode_idx < controller->modes.size(); mode_idx++)
            {
                std::string modeStr = QuoteIfNecessary(controller->modes[mode_idx].name);

                if(current_mode == (int)mode_idx)
                {
                    modeStr = "[" + modeStr + "]";
                }
                std::cout << " " << modeStr;
            }
            std::cout << std::endl;
        }

        /*---------------------------------------------------------*\
        | Print device zones                                        |
        \*---------------------------------------------------------*/
        if(!controller->zones.empty())
        {
            std::cout << "  Zones:";

            for(std::size_t zone_idx = 0; zone_idx < controller->zones.size(); zone_idx++)
            {
                std::cout << " " << QuoteIfNecessary(controller->zones[zone_idx].name);
            }
            std::cout << std::endl;
        }

        /*---------------------------------------------------------*\
        | Print device LEDs                                         |
        \*---------------------------------------------------------*/
        if(!controller->leds.empty())
        {
            std::cout << "  LEDs:";

            for(std::size_t led_idx = 0; led_idx < controller->leds.size(); led_idx++)
            {
                std::cout << " " << QuoteIfNecessary(controller->leds[led_idx].name);
            }
            std::cout << std::endl;
        }

        std::cout << std::endl;
    }
}

bool OptionDevice(std::vector<DeviceOptions>* current_devices, std::string argument, Options* options, std::vector<RGBController *>& rgb_controllers)
{
    bool found = false;
    ResourceManager::get()->WaitForDeviceDetection();

    try
    {
        int current_device = std::stoi(argument);

        if((current_device >= static_cast<int>(rgb_controllers.size())) || (current_device < 0))
        {
            throw nullptr;
        }

        DeviceOptions newDev;
        newDev.device = current_device;

        if(!options->hasDevice)
        {
            options->hasDevice = true;
        }

        current_devices->push_back(newDev);

        found = true;
    }
    catch(...)
    {
        if(argument.length() > 1)
        {
            for(unsigned int i = 0; i < rgb_controllers.size(); i++)
            {
                /*---------------------------------------------------------*\
                | If the argument is not a number then check all the        |
                |   controllers names for a match                           |
                \*---------------------------------------------------------*/
                std::string name            = rgb_controllers[i]->name;
                std::transform(name.begin(), name.end(), name.begin(), ::tolower);
                std::transform(argument.begin(), argument.end(), argument.begin(), ::tolower);

                if(name.find(argument) != std::string::npos)
                {
                    found                   = true;

                    DeviceOptions newDev;
                    newDev.device           = i;

                    if(!options->hasDevice)
                    {
                        options->hasDevice  = true;
                    }

                    current_devices->push_back(newDev);
                }
            }
        }
        else
        {
            std::cout << "Error: Invalid device ID: " + argument << std::endl;
            return false;
        }
    }

    return found;
}

bool OptionZone(std::vector<DeviceOptions>* current_devices, std::string argument, Options* /*options*/, std::vector<RGBController *>& rgb_controllers)
{
    bool found = false;
    ResourceManager::get()->WaitForDeviceDetection();

    try
    {
        int current_zone = std::stoi(argument);

        for(size_t i = 0; i < current_devices->size(); i++)
        {
            int current_device = current_devices->at(i).device;

            if(current_zone >= static_cast<int>(rgb_controllers[current_device]->zones.size()) || (current_zone < 0))
            {
                throw nullptr;
            }

            current_devices->at(i).zone = current_zone;
            found = true;
        }
    }
    catch(...)
    {
        std::cout << "Error: Invalid zone ID: " + argument << std::endl;
        return false;
    }

    return found;
}

bool CheckColor(std::string argument, DeviceOptions* currentDevOpts)
{
    if(ParseColors(argument, currentDevOpts))
    {
        currentDevOpts->hasOption = true;
        return true;
    }
    else
    {
        std::cout << "Error: Invalid color value: " + argument << std::endl;
        return false;
    }
}

bool OptionColor(std::vector<DeviceOptions>* current_devices, std::string argument, Options* options)
{
    /*---------------------------------------------------------*\
    | If a device is not selected  i.e. size() == 0             |
    |   then add color to allDeviceOptions                      |
    \*---------------------------------------------------------*/
    bool found                      = false;
    DeviceOptions* currentDevOpts   = &options->allDeviceOptions;

    if(current_devices->size() == 0)
    {
        found = CheckColor(argument, currentDevOpts);
    }
    else
    {
        for(size_t i = 0; i < current_devices->size(); i++)
        {
            currentDevOpts = &current_devices->at(i);

            found = CheckColor(argument, currentDevOpts);
        }
    }

    return found;
}

bool OptionMode(std::vector<DeviceOptions>* current_devices, std::string argument, Options* options)
{
    if(argument.size() == 0)
    {
        std::cout << "Error: --mode passed with no argument" << std::endl;
        return false;
    }

    /*---------------------------------------------------------*\
    | If a device is not selected  i.e. size() == 0             |
    |   then add mode to allDeviceOptions                       |
    \*---------------------------------------------------------*/
    bool found                      = false;
    DeviceOptions* currentDevOpts   = &options->allDeviceOptions;

    if(current_devices->size() == 0)
    {
        currentDevOpts->mode = argument;
        currentDevOpts->hasOption = true;
        found = true;
    }
    else
    {
        for(size_t i = 0; i < current_devices->size(); i++)
        {
            currentDevOpts = &current_devices->at(i);

            currentDevOpts->mode = argument;
            currentDevOpts->hasOption = true;
            found = true;
        }
    }

    return found;
}

bool OptionSpeed(std::vector<DeviceOptions>* current_devices, std::string argument, Options* options)
{
    if(argument.size() == 0)
    {
        std::cout << "Error: --speed passed with no argument" << std::endl;
        return false;
    }

    /*---------------------------------------------------------*\
    | If a device is not selected  i.e. size() == 0             |
    |   then add speed to allDeviceOptions                 |
    \*---------------------------------------------------------*/
    bool found                      = false;
    DeviceOptions* currentDevOpts   = &options->allDeviceOptions;

    if(current_devices->size() == 0)
    {
        currentDevOpts->speed  = std::min(std::max(std::stoi(argument), 0),(int)speed_percentage);
        currentDevOpts->hasOption   = true;
        found = true;
    }
    else
    {
        for(size_t i = 0; i < current_devices->size(); i++)
        {
            DeviceOptions* currentDevOpts   = &current_devices->at(i);

            currentDevOpts->speed      = std::min(std::max(std::stoi(argument), 0),(int)speed_percentage);
            currentDevOpts->hasOption       = true;
            found = true;
        }
    }

    return found;
}

bool OptionBrightness(std::vector<DeviceOptions>* current_devices, std::string argument, Options* options)
{
    if(argument.size() == 0)
    {
        std::cout << "Error: --brightness passed with no argument" << std::endl;
        return false;
    }

    /*---------------------------------------------------------*\
    | If a device is not selected  i.e. size() == 0             |
    |   then add brightness to allDeviceOptions                 |
    \*---------------------------------------------------------*/
    bool found                      = false;
    DeviceOptions* currentDevOpts   = &options->allDeviceOptions;

    if(current_devices->size() == 0)
    {
        currentDevOpts->brightness  = std::min(std::max(std::stoi(argument), 0),(int)brightness_percentage);
        currentDevOpts->hasOption   = true;
        found = true;
    }
    else
    {
        for(size_t i = 0; i < current_devices->size(); i++)
        {
            DeviceOptions* currentDevOpts   = &current_devices->at(i);

            currentDevOpts->brightness      = std::min(std::max(std::stoi(argument), 0),(int)brightness_percentage);
            currentDevOpts->hasOption       = true;
            found = true;
        }
    }

    return found;
}

bool OptionSize(std::vector<DeviceOptions>* current_devices, std::string argument, Options* /*options*/, std::vector<RGBController *>& rgb_controllers)
{
    const unsigned int new_size = std::stoi(argument);

    ResourceManager::get()->WaitForDeviceDetection();

    for(size_t i = 0; i < current_devices->size(); i++)
    {
        int current_device      = current_devices->at(i).device;
        int current_zone        = current_devices->at(i).zone;

        /*---------------------------------------------------------*\
        | Fail out if device, zone, or size are out of range        |
        \*---------------------------------------------------------*/
        if((current_device >= static_cast<int>(rgb_controllers.size())) || (current_device < 0))
        {
            std::cout << "Error: Device is out of range" << std::endl;
            return false;
        }
        else if((current_zone >= static_cast<int>(rgb_controllers[current_device]->zones.size())) || (current_zone < 0))
        {
            std::cout << "Error: Zone is out of range" << std::endl;
            return false;
        }
        else if((new_size < rgb_controllers[current_device]->zones[current_zone].leds_min) || (new_size > rgb_controllers[current_device]->zones[current_zone].leds_max))
        {
            std::cout << "Error: New size is out of range" << std::endl;
        }

        /*---------------------------------------------------------*\
        | Resize the zone                                           |
        \*---------------------------------------------------------*/
        rgb_controllers[current_device]->ResizeZone(current_zone, new_size);

        /*---------------------------------------------------------*\
        | Save the profile                                          |
        \*---------------------------------------------------------*/
        ResourceManager::get()->GetProfileManager()->SaveProfile("sizes", true);
    }

    return true;
}

bool OptionProfile(std::string argument, std::vector<RGBController *>& rgb_controllers)
{
    ResourceManager::get()->WaitForDeviceDetection();

    /*---------------------------------------------------------*\
    | Attempt to load profile                                   |
    \*---------------------------------------------------------*/
    if(ResourceManager::get()->GetProfileManager()->LoadProfile(argument))
    {
        /*-----------------------------------------------------*\
        | Change device mode if profile loading was successful  |
        \*-----------------------------------------------------*/
        for(std::size_t controller_idx = 0; controller_idx < rgb_controllers.size(); controller_idx++)
        {
            RGBController* device = rgb_controllers[controller_idx];

            device->DeviceUpdateMode();
            LOG_DEBUG("[CLI] Updating mode for %s to %i", device->name.c_str(), device->active_mode);

            if(device->modes[device->active_mode].color_mode == MODE_COLORS_PER_LED)
            {
                device->DeviceUpdateLEDs();
                LOG_DEBUG("[CLI] Mode uses per-LED color, also updating LEDs");
            }
        }

        std::cout << "Profile loaded successfully" << std::endl;
        return true;
    }
    else
    {
        std::cout << "Profile failed to load" << std::endl;
        return false;
    }
}

bool OptionSaveProfile(std::string argument)
{
    /*---------------------------------------------------------*\
    | Set save profile filename                                 |
    \*---------------------------------------------------------*/
    profile_save_filename = argument;
    return(true);
}

int ProcessOptions(Options* options, std::vector<RGBController *>& rgb_controllers)
{
    unsigned int ret_flags  = 0;
    int arg_index           = 1;
    std::vector<DeviceOptions> current_devices;

    options->hasDevice = false;
    options->profile_loaded = false;

#ifdef _WIN32
    int fake_argc;
    wchar_t** argvw = CommandLineToArgvW(GetCommandLineW(), &fake_argc);
#endif

    while(arg_index < preserve_argc)
    {
        std::string option   = preserve_argv[arg_index];
        std::string argument = "";
        filesystem::path arg_path;

        /*---------------------------------------------------------*\
        | Handle options that take an argument                      |
        \*---------------------------------------------------------*/
        if(arg_index + 1 < preserve_argc)
        {
            argument = preserve_argv[arg_index + 1];
#ifdef _WIN32
            arg_path = argvw[arg_index + 1];
#else
            arg_path = argument;
#endif
        }

        /*---------------------------------------------------------*\
        | -l / --list-devices (no arguments)                        |
        \*---------------------------------------------------------*/
        if(option == "--list-devices" || option == "-l")
        {
            OptionListDevices(rgb_controllers);
            exit(0);
        }

        /*---------------------------------------------------------*\
        | -d / --device                                             |
        \*---------------------------------------------------------*/
        else if(option == "--device" || option == "-d")
        {
            while(!current_devices.empty())
            {
                options->devices.push_back(current_devices.back());
                current_devices.pop_back();
            }

            if(!OptionDevice(&current_devices, argument, options, rgb_controllers))
            {
                return RET_FLAG_PRINT_HELP;
            }

            arg_index++;
        }

        /*---------------------------------------------------------*\
        | -z / --zone                                               |
        \*---------------------------------------------------------*/
        else if(option == "--zone" || option == "-z")
        {
            if(!OptionZone(&current_devices, argument, options, rgb_controllers))
            {
                return RET_FLAG_PRINT_HELP;
            }

            arg_index++;
        }

        /*---------------------------------------------------------*\
        | -c / --color                                              |
        \*---------------------------------------------------------*/
        else if(option == "--color" || option == "-c")
        {
            if(!OptionColor(&current_devices, argument, options))
            {
                return RET_FLAG_PRINT_HELP;
            }

            arg_index++;
        }

        /*---------------------------------------------------------*\
        | -m / --mode                                               |
        \*---------------------------------------------------------*/
        else if(option == "--mode" || option == "-m")
        {
            if(!OptionMode(&current_devices, argument, options))
            {
                return RET_FLAG_PRINT_HELP;
            }

            arg_index++;
        }

        /*---------------------------------------------------------*\
        | -b / --brightness                                         |
        \*---------------------------------------------------------*/
        else if(option == "--brightness" || option == "-b")
        {
            if(!OptionBrightness(&current_devices, argument, options))
            {
                return RET_FLAG_PRINT_HELP;
            }

            arg_index++;
        }

        /*---------------------------------------------------------*\
        | -s / --speed                                         |
        \*---------------------------------------------------------*/
        else if(option == "--speed" || option == "-s")
        {
            if(!OptionSpeed(&current_devices, argument, options))
            {
                return RET_FLAG_PRINT_HELP;
            }

            arg_index++;
        }

        /*---------------------------------------------------------*\
        | -sz / --size                                               |
        \*---------------------------------------------------------*/
        else if(option == "--size" || option == "-sz")
        {
            if(!OptionSize(&current_devices, argument, options, rgb_controllers))
            {
                return RET_FLAG_PRINT_HELP;
            }

            arg_index++;
        }

        /*---------------------------------------------------------*\
        | -p / --profile                                            |
        \*---------------------------------------------------------*/
        else if(option == "--profile" || option == "-p")
        {
            options->profile_loaded = OptionProfile(arg_path.generic_u8string(), rgb_controllers);

            arg_index++;
        }

        /*---------------------------------------------------------*\
        | -sp / --save-profile                                      |
        \*---------------------------------------------------------*/
        else if(option == "--save-profile" || option == "-sp")
        {
            OptionSaveProfile(arg_path.generic_u8string());

            arg_index++;
        }

        /*---------------------------------------------------------*\
        | Invalid option                                            |
        \*---------------------------------------------------------*/
        else
        {
            if((option == "--localconfig")
             ||(option == "--nodetect")
             ||(option == "--noautoconnect")
             ||(option == "--server")
             ||(option == "--gui")
             ||(option == "--i2c-tools" || option == "--yolo")
             ||(option == "--startminimized")
             ||(option == "--print-source")
             ||(option == "--verbose" || option == "-v")
             ||(option == "--very-verbose" || option == "-vv")
             ||(option == "--help" || option == "-h")
             ||(option == "--version" || option == "-V")
             ||(option == "--autostart-check")
             ||(option == "--autostart-disable"))
            {
                /*-------------------------------------------------*\
                | Do nothing, these are pre-detection arguments     |
                | and this parser should ignore them                |
                \*-------------------------------------------------*/
            }
            else if((option == "--server-port")
                  ||(option == "--server-host")
                  ||(option == "--loglevel")
                  ||(option == "--config")
                  ||(option == "--client")
                  ||(option == "--autostart-enable"))
            {
                /*-------------------------------------------------*\
                | Increment index for pre-detection arguments with  |
                | parameter                                         |
                \*-------------------------------------------------*/
                arg_index++;
            }
            else
            {
                /*-------------------------------------------------*\
                | If the argument is not a pre-detection argument,  |
                | throw an error and print help                     |
                \*-------------------------------------------------*/
                std::cout << "Error: Invalid option: " + option << std::endl;
                return RET_FLAG_PRINT_HELP;
            }
        }

        arg_index++;
    }

    /*---------------------------------------------------------*\
    | If a device was specified, check to verify that a         |
    | corresponding option was also specified                   |
    \*---------------------------------------------------------*/
    while(!current_devices.empty())
    {
        options->devices.push_back(current_devices.back());
        current_devices.pop_back();
    }

    if(options->hasDevice)
    {
        for(std::size_t option_idx = 0; option_idx < options->devices.size(); option_idx++)
        {
            if(!options->devices[option_idx].hasOption)
            {
                std::cout << "Error: Device " + std::to_string(option_idx) + " specified, but neither mode nor color given" << std::endl;
                return RET_FLAG_PRINT_HELP;
            }
        }
        return 0;
    }
    else
    {
        return ret_flags;
    }
}

void ApplyOptions(DeviceOptions& options, std::vector<RGBController *>& rgb_controllers)
{
    RGBController* device = rgb_controllers[options.device];

    /*---------------------------------------------------------*\
    | Set mode first, in case it's 'direct' (which affects      |
    | SetLED below)                                             |
    \*---------------------------------------------------------*/
    unsigned int mode = ParseMode(options, rgb_controllers);

    /*---------------------------------------------------------*\
    | If the user has specified random colours and the device   |
    |   supports that colour mode then swich to it before       |
    |   evaluating if a colour needs to be set                  |
    \*---------------------------------------------------------*/
    if(options.random_colors && (device->modes[mode].flags & MODE_FLAG_HAS_RANDOM_COLOR))
    {
        device->modes[mode].color_mode = MODE_COLORS_RANDOM;
    }

    /*---------------------------------------------------------*\
    | If the user has specified random colours and the device   |
    |   supports that colour mode then swich to it before       |
    |   evaluating if a colour needs to be set                  |
    \*---------------------------------------------------------*/
    if((device->modes[mode].flags & MODE_FLAG_HAS_BRIGHTNESS))
    {
        unsigned int new_brightness     = device->modes[mode].brightness_max - device->modes[mode].brightness_min;
        new_brightness                 *= options.brightness;
        new_brightness                 /= brightness_percentage;

        device->modes[mode].brightness  = device->modes[mode].brightness_min + new_brightness;
    }

    if((device->modes[mode].flags & MODE_FLAG_HAS_SPEED))
    {
        unsigned int new_speed     = device->modes[mode].speed_max - device->modes[mode].speed_min;
        new_speed                 *= options.speed;
        new_speed                 /= speed_percentage;

        device->modes[mode].speed  = device->modes[mode].speed_min + new_speed;
    }

    /*---------------------------------------------------------*\
    | Determine which color mode this mode uses and update      |
    | colors accordingly                                        |
    \*---------------------------------------------------------*/
    switch(device->modes[mode].color_mode)
    {
        case MODE_COLORS_NONE:
            break;

        case MODE_COLORS_RANDOM:
            break;

        case MODE_COLORS_PER_LED:
            if(options.colors.size() != 0)
            {
                std::size_t last_set_color = 0;

                RGBColor* start_from;
                unsigned int led_count;
                if(options.zone < 0)
                {
                    start_from  = &device->colors[0];
                    led_count   = (unsigned int)device->leds.size();
                }
                else
                {
                    start_from  = device->zones[options.zone].colors;
                    led_count   = device->zones[options.zone].leds_count;
                }

                for(std::size_t led_idx = 0; led_idx < led_count; led_idx++)
                {
                    if(led_idx < options.colors.size())
                    {
                        last_set_color      = led_idx;
                    }

                    start_from[led_idx]     = ToRGBColor(std::get<0>(options.colors[last_set_color]),
                                                         std::get<1>(options.colors[last_set_color]),
                                                         std::get<2>(options.colors[last_set_color]));
                }
            }
            break;

        case MODE_COLORS_MODE_SPECIFIC:
            if(options.colors.size() >= device->modes[mode].colors_min && options.colors.size() <= device->modes[mode].colors_max)
            {
                device->modes[mode].colors.resize(options.colors.size());

                for(std::size_t color_idx = 0; color_idx < options.colors.size(); color_idx++)
                {
                    device->modes[mode].colors[color_idx] = ToRGBColor(std::get<0>(options.colors[color_idx]),
                                                                       std::get<1>(options.colors[color_idx]),
                                                                       std::get<2>(options.colors[color_idx]));
                }
            }
            else
            {
                std::cout << "Wrong number of colors specified for mode " + device->modes[mode].name << std::endl;
                std::cout << "Please provide between " + std::to_string(device->modes[mode].colors_min) + " and " + std::to_string(device->modes[mode].colors_min) + " colors" << std::endl;
                exit(0);
            }
            break;
    }

    /*---------------------------------------------------------*\
    | Set device mode                                           |
    \*---------------------------------------------------------*/
    device->active_mode = mode;
    device->DeviceUpdateMode();

    /*---------------------------------------------------------*\
    | Set device per-LED colors if necessary                    |
    \*---------------------------------------------------------*/
    if(device->modes[mode].color_mode == MODE_COLORS_PER_LED)
    {
        device->DeviceUpdateLEDs();
    }
}


unsigned int cli_pre_detection(int argc, char* argv[])
{
    /*---------------------------------------------------------*\
    | Process only the arguments that should be performed prior |
    | to detecting devices and/or starting clients              |
    \*---------------------------------------------------------*/
    int             arg_index    = 1;
    unsigned int    cfg_args     = 0;
    unsigned int    ret_flags    = 0;
    std::string     server_host  = OPENRGB_SDK_HOST;
    unsigned short  server_port  = OPENRGB_SDK_PORT;
    bool            server_start = false;
    bool            print_help   = false;

    preserve_argc = argc;
    preserve_argv = argv;

#ifdef _WIN32
    int fake_argc;
    wchar_t** argvw = CommandLineToArgvW(GetCommandLineW(), &fake_argc);
#endif

    while(arg_index < argc)
    {
        std::string option   = argv[arg_index];
        std::string argument = "";

        LOG_DEBUG("[CLI] Parsing CLI option: %s", option.c_str());

        /*---------------------------------------------------------*\
        | Handle options that take an argument                      |
        \*---------------------------------------------------------*/
        if(arg_index + 1 < argc)
        {
            argument = argv[arg_index + 1];
        }

        /*---------------------------------------------------------*\
        | --localconfig                                             |
        \*---------------------------------------------------------*/
        if(option == "--localconfig")
        {
            ResourceManager::get()->SetConfigurationDirectory("./");
            cfg_args++;
        }

        /*---------------------------------------------------------*\
        | --config                                                  |
        \*---------------------------------------------------------*/
        else if(option == "--config")
        {
            cfg_args+= 2;
            arg_index++;
#ifdef _WIN32
            filesystem::path config_path(argvw[arg_index]);
#else
            filesystem::path config_path(argument);
#endif

            if(filesystem::is_directory(config_path))
            {
                ResourceManager::get()->SetConfigurationDirectory(config_path);
                LOG_INFO("[CLI] Setting config directory to %s",argument.c_str()); // TODO: Use config_path in logs somehow
            }
            else
            {
                LOG_ERROR("[CLI] '%s' is not a valid directory",argument.c_str()); // TODO: Use config_path in logs somehow
                print_help = true;
                break;
            }
        }

        /*---------------------------------------------------------*\
        | --nodetect                                                |
        \*---------------------------------------------------------*/
        else if(option == "--nodetect")
        {
            ret_flags |= RET_FLAG_NO_DETECT;
            cfg_args++;
        }

        /*---------------------------------------------------------*\
        | --noautoconnect                                           |
        \*---------------------------------------------------------*/
        else if(option == "--noautoconnect")
        {
            ret_flags |= RET_FLAG_NO_AUTO_CONNECT;
            cfg_args++;
        }

        /*---------------------------------------------------------*\
        | --client                                                  |
        \*---------------------------------------------------------*/
        else if(option == "--client")
        {
            NetworkClient * client = new NetworkClient(ResourceManager::get()->GetRGBControllers());

            std::size_t pos = argument.find(":");
            std::string ip = argument.substr(0, pos);
            unsigned short port_val;

            if(pos == argument.npos)
            {
                port_val = OPENRGB_SDK_PORT;
            }
            else
            {
                std::string port = argument.substr(argument.find(":") + 1);
                port_val = std::stoi(port);
            }

            std::string titleString = "OpenRGB ";
            titleString.append(VERSION_STRING);

            client->SetIP(ip.c_str());
            client->SetName(titleString.c_str());
            client->SetPort(port_val);

            client->StartClient();

            for(int timeout = 0; timeout < 100; timeout++)
            {
                if(client->GetConnected())
                {
                    break;
                }
                std::this_thread::sleep_for(10ms);
            }

            ResourceManager::get()->GetClients().push_back(client);

            cfg_args++;
            arg_index++;
        }

        /*---------------------------------------------------------*\
        | --server (no arguments)                                   |
        \*---------------------------------------------------------*/
        else if(option == "--server")
        {
            server_start = true;
        }

        /*---------------------------------------------------------*\
        | --server-port                                             |
        \*---------------------------------------------------------*/
        else if(option == "--server-port")
        {
            if (argument != "")
            {
                try
                {
                    int port = std::stoi(argument);
                    if (port >= 1024 && port <= 65535)
                    {
                        server_port  = port;
                        server_start = true;
                    }
                    else
                    {
                        std::cout << "Error: Port out of range: " << port << " (1024-65535)" << std::endl;
                        print_help = true;
                        break;
                    }
                }
                catch(std::invalid_argument& /*e*/)
                {
                    std::cout << "Error: Invalid data in --server-port argument (expected a number in range 1024-65535)" << std::endl;
                    print_help = true;
                    break;
                }
            }
            else
            {
                std::cout << "Error: Missing argument for --server-port" << std::endl;
                print_help = true;
                break;
            }
            cfg_args++;
            arg_index++;
        }
        /*---------------------------------------------------------*\
        | --server-host                                             |
        \*---------------------------------------------------------*/
        else if(option == "--server-host")
        {
            if (argument != "")
            {
                std::string host = argument;

                server_host  = host;
                server_start = true;
            }
            else
            {
                std::cout << "Error: Missing argument for --server-host" << std::endl;
                print_help = true;
                break;
            }
            cfg_args++;
            arg_index++;
        }

        /*---------------------------------------------------------*\
        | --loglevel                                                |
        \*---------------------------------------------------------*/
        else if(option == "--loglevel")
        {
            if (argument != "")
            {
                try
                {
                    int level = std::stoi(argument);
                    if (level >= 0 && level <= LL_TRACE)
                    {
                        LogManager::get()->setLoglevel(level);
                    }
                    else
                    {
                        LOG_ERROR("[CLI] Loglevel out of range: %d (0-6)", level);
                        print_help = true;
                        break;
                    }
                }
                catch(std::invalid_argument& /*e*/)
                {
                    if(!strcasecmp(argument.c_str(), "fatal"))
                    {
                        LogManager::get()->setLoglevel(LL_FATAL);
                    }
                    else if(!strcasecmp(argument.c_str(), "error"))
                    {
                        LogManager::get()->setLoglevel(LL_ERROR);
                    }
                    else if(!strcasecmp(argument.c_str(), "warning"))
                    {
                        LogManager::get()->setLoglevel(LL_WARNING);
                    }
                    else if(!strcasecmp(argument.c_str(), "info"))
                    {
                        LogManager::get()->setLoglevel(LL_INFO);
                    }
                    else if(!strcasecmp(argument.c_str(), "verbose"))
                    {
                        LogManager::get()->setLoglevel(LL_VERBOSE);
                    }
                    else if(!strcasecmp(argument.c_str(), "debug"))
                    {
                        LogManager::get()->setLoglevel(LL_DEBUG);
                    }
                    else if(!strcasecmp(argument.c_str(), "trace"))
                    {
                        LogManager::get()->setLoglevel(LL_TRACE);
                    }
                    else
                    {
                        LOG_ERROR("[CLI] Invalid loglevel");
                        print_help = true;
                        break;
                    }
                }
            }
            else
            {
                LOG_ERROR("[CLI] Missing argument for --loglevel");
                print_help = true;
                break;
            }
            cfg_args+= 2;
            arg_index++;
        }

        /*---------------------------------------------------------*\
        | --autostart-check (no arguments)                          |
        \*---------------------------------------------------------*/
        else if(option == "--autostart-check")
        {
            AutoStart auto_start("OpenRGB");

            if(auto_start.IsAutoStartEnabled())
            {
                std::cout << "Autostart is enabled." << std::endl;
            }
            else
            {
                std::cout << "Autostart is disabled." << std::endl;
            }
        }

        /*---------------------------------------------------------*\
        | --autostart-disable (no arguments)                        |
        \*---------------------------------------------------------*/
        else if(option == "--autostart-disable")
        {
            AutoStart auto_start("OpenRGB");

            if(auto_start.DisableAutoStart())
            {
                std::cout << "Autostart disabled." << std::endl;
            }
            else
            {
                std::cout << "Autostart failed to disable." << std::endl;
            }
        }

        /*---------------------------------------------------------*\
        | --autostart-enable                                        |
        \*---------------------------------------------------------*/
        else if(option == "--autostart-enable")
        {
            if (argument != "")
            {
                std::string desc = "OpenRGB ";
                desc += VERSION_STRING;
                desc += ", for controlling RGB lighting.";

                AutoStart       auto_start("OpenRGB");
                AutoStartInfo   auto_start_interface;

                auto_start_interface.args        = argument;
                auto_start_interface.category    = "Utility;";
                auto_start_interface.desc        = desc;
                auto_start_interface.icon        = "OpenRGB";
                auto_start_interface.path        = auto_start.GetExePath();

                if(auto_start.EnableAutoStart(auto_start_interface))
                {
                    std::cout << "Autostart enabled." << std::endl;
                }
                else
                {
                    std::cout << "Autostart failed to enable." << std::endl;
                }
            }
            else
            {
                std::cout << "Error: Missing argument for --autostart-enable" << std::endl;
                print_help = true;
                break;
            }

            cfg_args++;
            arg_index++;
        }

        /*---------------------------------------------------------*\
        | --gui (no arguments)                                      |
        \*---------------------------------------------------------*/
        else if(option == "--gui")
        {
            ret_flags |= RET_FLAG_START_GUI;
        }

        /*---------------------------------------------------------*\
        | --i2c-tools / --yolo (no arguments)                       |
        \*---------------------------------------------------------*/
        else if(option == "--i2c-tools" || option == "--yolo")
        {
            ret_flags |= RET_FLAG_START_GUI | RET_FLAG_I2C_TOOLS;
        }

        /*---------------------------------------------------------*\
        | --startminimized (no arguments)                           |
        \*---------------------------------------------------------*/
        else if(option == "--startminimized")
        {
            ret_flags |= RET_FLAG_START_GUI | RET_FLAG_START_MINIMIZED;
        }

        /*---------------------------------------------------------*\
        | -h / --help (no arguments)                                |
        \*---------------------------------------------------------*/
        else if(option == "--help" || option == "-h")
        {
            print_help = true;
            break;
        }

        /*---------------------------------------------------------*\
        | -V / --version (no arguments)                             |
        \*---------------------------------------------------------*/
        else if(option == "--version" || option == "-V")
        {
            OptionVersion();
            exit(0);
        }

        /*---------------------------------------------------------*\
        | -v / --verbose (no arguments)                             |
        \*---------------------------------------------------------*/
        else if(option == "--verbose" || option == "-v")
        {
            LogManager::get()->setVerbosity(LL_VERBOSE);
            cfg_args++;
        }

        /*---------------------------------------------------------*\
        | -vv / --very-verbose (no arguments)                       |
        \*---------------------------------------------------------*/
        else if(option == "--very-verbose" || option == "-vv")
        {
            LogManager::get()->setVerbosity(LL_TRACE);
            cfg_args++;
        }

        /*---------------------------------------------------------*\
        | --print-source (no arguments)                             |
        \*---------------------------------------------------------*/
        else if(option == "--print-source")
        {
            LogManager::get()->setPrintSource(true);
            cfg_args++;
        }

        /*---------------------------------------------------------*\
        | Any unrecognized arguments trigger the post-detection CLI |
        \*---------------------------------------------------------*/
        else
        {
            ret_flags |= RET_FLAG_CLI_POST_DETECTION;
        }

        arg_index++;
    }

    if(print_help)
    {
        OptionHelp();
        exit(0);
    }

    if(server_start)
    {
        NetworkServer * server = ResourceManager::get()->GetServer();
        server->SetHost(server_host);
        server->SetPort(server_port);
        ret_flags |= RET_FLAG_START_SERVER;
    }

    if((argc - cfg_args) <= 1)
    {
        ret_flags |= RET_FLAG_START_GUI;
    }

    return(ret_flags);
}

unsigned int cli_post_detection()
{
    /*---------------------------------------------------------*\
    | Wait for device detection                                 |
    \*---------------------------------------------------------*/
    ResourceManager::get()->WaitForDeviceDetection();

    /*---------------------------------------------------------*\
    | Get controller list from resource manager                 |
    \*---------------------------------------------------------*/
    std::vector<RGBController *> rgb_controllers = ResourceManager::get()->GetRGBControllers();

    /*---------------------------------------------------------*\
    | Process the argument options                              |
    \*---------------------------------------------------------*/
    Options options;
    unsigned int ret_flags = ProcessOptions(&options, rgb_controllers);

    /*---------------------------------------------------------*\
    | If the return flags are set, exit CLI mode without        |
    | processing device updates from CLI input.                 |
    \*---------------------------------------------------------*/
    switch(ret_flags)
    {
        case 0:
            break;

        case RET_FLAG_PRINT_HELP:
            OptionHelp();
            exit(-1);
            break;

        default:
            return ret_flags;
            break;
    }

    /*---------------------------------------------------------*\
    | If the options has one or more specific devices, loop     |
    | through all of the specific devices and apply settings.   |
    | Otherwise, apply settings to all devices.                 |
    \*---------------------------------------------------------*/
    if (options.hasDevice)
    {
        for(unsigned int device_idx = 0; device_idx < options.devices.size(); device_idx++)
        {
            ApplyOptions(options.devices[device_idx], rgb_controllers);
        }
    }
    else if (!options.profile_loaded)
    {
        for (unsigned int device_idx = 0; device_idx < rgb_controllers.size(); device_idx++)
        {
            options.allDeviceOptions.device = device_idx;
            ApplyOptions(options.allDeviceOptions, rgb_controllers);
        }
    }

    /*---------------------------------------------------------*\
    | If there is a save filename set, save the profile         |
    \*---------------------------------------------------------*/
    if (profile_save_filename != "")
    {
        if(ResourceManager::get()->GetProfileManager()->SaveProfile(profile_save_filename))
        {
            LOG_INFO("[CLI] Profile saved successfully");
        }
        else
        {
            LOG_ERROR("[CLI] Profile saving failed");
        }
    }

    std::this_thread::sleep_for(1s);

    return 0;
}
