/*
 * GraphLCD tool lcdtestpattern
 *
 * lcdtestpattern.c  -  a tool to display some testpattern on an GLCD
 *
 * based on showpic.c of graphlcd-base
 *   (c) 2004 Andreas Regel <andreas.regel AT powarman.de>
 *
 * This file is released under the GNU General Public License. Refer
 * to the COPYING file distributed with this package.
 *
 * (c) 2007 Alexander Rieger (Alexander.Rieger AT inka.de)
 */

//-----------------------------------------------------------------------------
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <getopt.h>
#include <dlfcn.h>
#include <unistd.h>
#include <syslog.h>
#include <signal.h>

#include <string>

#include <glcdgraphics/bitmap.h>
#include <glcdgraphics/glcd.h>
#include <glcdgraphics/image.h>
#include <glcddrivers/config.h>
#include <glcddrivers/common.h>
#include <glcddrivers/driver.h>
#include <glcddrivers/drivers.h>

//-----------------------------------------------------------------------------
static const char *prgname = "lcdtestpattern";
static const char *version = "0.1.0";

static const int kDefaultSleepMs = 0;
static const char * kDefaultConfigFile = "/etc/graphlcd.conf";

static volatile bool stopProgramm = false;

//-----------------------------------------------------------------------------
static void sighandler(int signal)
{
	switch (signal)
	{
		case SIGINT:
		case SIGQUIT:
		case SIGTERM:
			stopProgramm = true;
	} // switch
} // sighandler()

//-----------------------------------------------------------------------------
void usage()
{
    fprintf(stdout, "\n");
    fprintf(stdout, "%s v%s\n", prgname, version);
    fprintf(stdout, "%s is a tool to show test patterns on a LCD.\n", prgname);
    fprintf(stdout, "\n");
    fprintf(stdout, "  Usage: %s [-c CONFIGFILE] [-d DISPLAY] [-s SLEEP] [-uie]\n\n", prgname);
    fprintf(stdout, "  -c  --config      specifies the location of the config file\n");
    fprintf(stdout, "                    (default: /etc/graphlcd.conf)\n");
    fprintf(stdout, "  -d  --display     specifies the output display (default is the first one)\n");
    fprintf(stdout, "  -u  --upsidedown  rotates the output by 180 degrees (default: no)\n");
    fprintf(stdout, "  -i  --invert      inverts the output (default: no)\n");
    fprintf(stdout, "  -e  --endless     show all images in endless loop (default: no)\n");
    fprintf(stdout, "  -s  --sleep       set sleeptime between two patterns [ms] (default: %d ms)\n", kDefaultSleepMs);
    fprintf(stdout, "  -b  --brightness  set brightness for display if driver support it [%%]\n");
    fprintf(stdout, "                    (default: config file value)\n");
    fprintf(stdout, "\n" );
    fprintf(stdout, "  examples: %s -c /etc/graphlcd.conf\n", prgname);
    fprintf(stdout, "            %s -c /etc/graphlcd.conf -d LCD_T6963 -u -i\n", prgname);
    fprintf(stdout, "\n" );
} // usage()

//-----------------------------------------------------------------------------
int main(int argc, char *argv[])
{
    static struct option long_options[] =
    {
        {"config",     required_argument, NULL, 'c'},
        {"display",    required_argument, NULL, 'd'},
        {"sleep",      required_argument, NULL, 's'},
        {"endless",          no_argument, NULL, 'e'},
        {"upsidedown",       no_argument, NULL, 'u'},
        {"invert",           no_argument, NULL, 'i'},
        {"brightness", required_argument, NULL, 'b'},
        {NULL}
    };

    std::string configName = "";
    std::string displayName = "";
    bool upsideDown = false;
    bool invert = false;
    int brightness = -1;
    bool delay = false;
    int sleepMs = kDefaultSleepMs;
    bool endless = false;
    unsigned int displayNumber = 0;

    int c, option_index = 0;
    while ((c = getopt_long(argc, argv, "c:d:s:euib:", long_options, &option_index)) != -1)
    {
        switch(c)
        {
          case 'c':
              configName = optarg;
              break;

          case 'd':
              displayName = optarg;
              break;

          case 'u':
              upsideDown = true;
              break;

          case 'i':
              invert = true;
              break;

          case 's':
              sleepMs = atoi(optarg);
              delay = true;
              break;

          case 'e':
              endless = true;
              break;

          case 'b':
              brightness = atoi(optarg);
              if (brightness < 0) brightness = 0;
              if (brightness > 100) brightness = 100;
              break;

          default:
              usage();
              return 1;
        } // switch
    } // while

    if (configName.length() == 0)
    {
        configName = kDefaultConfigFile;
        syslog(LOG_INFO, "Error: No config file specified, using default (%s).\n", configName.c_str());
    } // if

    if (GLCD::Config.Load(configName) == false)
    {
        fprintf(stdout, "Error loading config file!\n");
        return 2;
    } // if

    if (GLCD::Config.driverConfigs.size() > 0)
    {
        if (displayName.length() > 0)
        {
            for (displayNumber = 0; displayNumber < GLCD::Config.driverConfigs.size(); displayNumber++)
            {
              if (GLCD::Config.driverConfigs[displayNumber].name == displayName)
                break;
            } // for

            if (displayNumber == GLCD::Config.driverConfigs.size())
            {
              fprintf(stdout, "ERROR: Specified display %s not found in config file!\n", displayName.c_str());
              return 3;
            } // if
        }
        else
        {
            fprintf(stdout, "WARNING: No display specified, using first one.\n");
            displayNumber = 0;
        } // if
    }
    else
    {
        fprintf(stdout, "ERROR: No displays specified in config file!\n");
        return 4;
    } // if

    GLCD::Config.driverConfigs[displayNumber].upsideDown ^= upsideDown;
    GLCD::Config.driverConfigs[displayNumber].invert     ^= invert;

    if (brightness != -1)
    {
        GLCD::Config.driverConfigs[displayNumber].brightness = brightness;
    } // if

    GLCD::cDriver * lcd = GLCD::CreateDriver(GLCD::Config.driverConfigs[displayNumber].id, &GLCD::Config.driverConfigs[displayNumber]);
    if (!lcd)
    {
        fprintf(stderr, "ERROR: Failed creating display object %s\n", displayName.c_str());
        return 6;
    } // if

    if (lcd->Init() != 0)
    {
        fprintf(stderr, "ERROR: Failed initializing display %s\n", displayName.c_str());
        delete lcd;
        return 7;
    } // if

    lcd->SetBrightness(GLCD::Config.driverConfigs[displayNumber].brightness);

    signal(SIGINT, sighandler);
    signal(SIGQUIT, sighandler);
    signal(SIGTERM, sighandler);
    signal(SIGHUP, sighandler);

    //----- show horizontal lines -----
    for (int aByte = 1; aByte <= 255 && !stopProgramm; ++aByte)
    {
        unsigned char aData = GLCD::ReverseBits(aByte);
        printf("clear and test byte: 0x%02X\n", aByte);
        lcd->Clear();

        for (int y = 0; y < lcd->Height() && !stopProgramm; ++y)
        {
            for (int x = 0; x < lcd->Width() && !stopProgramm; x += 8)
            {
               lcd->Set8Pixels(x, y, aData);
            } // for
        } // for

        lcd->Refresh(true);
        usleep(sleepMs * 1000);
    } // for

    //----- show vertial lines -----
    for (int aByte = 1; aByte <= 255 && !stopProgramm; ++aByte)
    {
        printf("clear and test byte: 0x%02X\n", aByte);
        lcd->Clear();

        for (int y = 0; y < lcd->Height() && !stopProgramm; ++y)
        {
            unsigned char aData = (((1 << (y % 8)) & aByte) == 0) ? 0x00 : 0xFF;
            for (int x = 0; x < lcd->Width() && !stopProgramm; x += 8)
            {
               lcd->Set8Pixels(x, y, aData);
            } // for
        } // for

        lcd->Refresh(true);
        usleep(sleepMs * 1000);
    } // for

    //----- cleanup -----
    lcd->Clear();
    lcd->Refresh(true);
    lcd->DeInit();
    delete lcd;

    return 0;
} // main()