/*********************************************************************************
 *      Copyright:  (C) 2018 LingYun IoT System Studio
 *                  All rights reserved.
 *
 *       Filename:  monitord.c
 *    Description:  This file is the monitord program, which use infrared to detect human 
 *                  incoming, then turn on the LED by relay and take a photo for it.
 *                 
 *        Version:  1.0.0(2018年05月29日)
 *         Author:  Guo Wenxue <guowenxue@gmail.com>
 *      ChangeLog:  1, Release initial version on "2018年05月29日 21时03分54秒"
 *                 
 ********************************************************************************/

#include <unistd.h>
#include <libgen.h>
#include <getopt.h>
#include "monitord.h"
#include "cp_logger.h"
#include "cp_proc.h"


/* Show program version information, can used by 'monitord --version or monitord -v'*/
static inline void prog_version(const char *progname)
{
    printf("%s Version 1.0.0 Build(%s)\n", progname, __DATE__);
    return ;
}


/* Show program help information, can used by 'monitord --help or monitord -h'*/
static void prog_usage(const char *progname)
{
    prog_version(progname);
    
    printf("Usage: %s [OPTION]...\n", progname);
    printf("Receive date from a serial port and transfer the data to remote server by socket.\n");
    printf("\nMandatory arguments to long options are mandatory for short options too:\n");

    printf(" -d[debug   ]  Running in debug mode\n");
    printf(" -l[level   ]  Set the log level as [0..%d]\n", LOG_LEVEL_MAX-1);
    printf(" -s[server  ]  Socket connect server host and port, format as: Hostname:Port, default as 127.0.0.1:8900\n");

    printf(" -v[version ]  Display program version\n");
    printf(" -h[help    ]  Display this help information\n");
    return ;
}

void *infrared_worker(void *arg);

int main (int argc, char **argv)
{
    const char             *progname=NULL;

    int                    opt;
    int                    debug = 0;            /* program running information log to stdard output */
    char                   pid_file[64] = { 0 }; /*   The file used to record the PID */
    int                    log_level = LOG_LEVEL_TRACE;  /* program running information log to file level  */
    cp_logger             *logger;
    char                  *log_file="monitord.log";        /* program running information log file name  */

    char                  *server="127.0.0.1:8900";    /* default connect server address, can use '-s' option to change */

    int                    rv;
    pthread_t              tid;

    /* progranm command options  */
    struct option long_options[] = { 
        {"debug", no_argument, NULL, 'd'},          /* monitord -d or monitord --debug, log to standard output or not */
        {"level", required_argument, NULL, 'l'},    /* monitord -l 7, specify log to file level */
        {"server", required_argument, NULL, 's'},   /* monitord -s 192.168.0.5:9999, specify server address and port */
        {"version", no_argument, NULL, 'v'},        /* monitord -v or monitord --version to check program version information */
        {"help", no_argument, NULL, 'h'},           /* monitord -h or monitord --help to get program help information  */
        {NULL, 0, NULL, 0}                          /* array end flag */
    }; 


    progname = basename(argv[0]);

    /* Parser the command line options */
    while ((opt = getopt_long(argc, argv, "s:dl:vh", long_options, NULL)) != -1)
    {
        switch (opt)
        {
            case 'd': /* monitord -d or monitord --debug */
                debug = 1;
                log_file = DBG_LOG_FILE;
                break;

            case 'l': /* monitord -l 7 */
                rv = atoi(optarg);
                log_level = rv>LOG_LEVEL_MAX ? LOG_LEVEL_MAX-1 : rv;
                break;

            case 'v':  /* monitord -v */
                prog_version(progname); 
                return EXIT_SUCCESS;

            case 'h':  /* monitord -h */
                prog_usage(progname);
                return 0;

            default:
                break;
        } /*  end of "switch(opt)" */
    }


    /* parser hostname and port by server*/
    {
        char       *ptr;

        ptr=strchr(server, ':');
        if( !ptr )
        {
            printf("Invalid server host[%s], which format should be [HostName:Port] such as \"127.0.0.1:8900\"", server);
            return -1;
        }
    }

    

    /* check program already running on background or not */
    if( !debug )
    {   
        snprintf(pid_file, sizeof(pid_file), "/var/run/%s.pid", progname);
        if( check_daemon_running(pid_file) )
        {   
            printf("Programe already running, exit now.\n");
            return -1; 
        }   
    }
    
    /* initialise logger system  */
    if( !(logger=cp_log_init(NULL, log_file, log_level, 0)) || cp_log_open()<0  )
    {
        printf("Init logger system failed, program exit now...\n");
        return -1;
    }
    /* set program running in background */
    if( !debug )
    {
        if( set_daemon_running(pid_file) )
        {
            log_fatal("Set program \"%s\" running as daemon failure.\n", progname);
            return -2;
        }
    }

    /* install signal process handler  */
    cp_install_proc_signal();

    /* start infrared detected thread */
    thread_start(&tid, infrared_worker, NULL); 
    
    while( !g_cp_signal.stop )
    {
        /* control/main thread do nothing here  */
        sleep(1);
    }

    return 0;
} 

void *infrared_worker(void *arg)
{
    int                    rv = 0;

#if 0
    if( !arg ) 
    {
        log_err("Invalid arguments\n");
        return NULL;
    }
#endif

    log_nrml("Thread worker for infrared start\n");

    while( !g_cp_signal.stop )
    {
    }

    return NULL;
}