#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <string.h>
#include <led_config.h>
#include <led_ioctl.h>
#include "led.h"

/*------------------------------------------------------------------------------------------*\
 *
 * OLD:
 * 1 = adsl 2 = pppoe 3 = lan 4 = wifi  5 = usb 6 = eth 7 = info  8 = power
 * 9 = AB   10 = isdn-b1    11=isdn-b2    12 = isdn-d    13 = pots    14 = sip
 *
 * NEW:
 * {adsl,usb,pppoe,wlan}
 *
\*------------------------------------------------------------------------------------------*/
struct _module_names {
    char old_name[32];
    char new_name[32];
    unsigned int instance;
};

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
#define MAX_MODULE_NAMES    32
struct _module_names module_names[MAX_MODULE_NAMES];


/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
void demon_register_name(char *ModuleName, unsigned int ModuleNr, unsigned int Instance, char *oldname) {
    DEB_TRACE("[led_demon]: register (new) name %s module %u instance %u (oldname: %s)\n",
            ModuleName, ModuleNr, Instance, oldname);
    if(ModuleNr < MAX_MODULE_NAMES) {
        strcpy(module_names[ModuleNr].old_name, oldname);
        strcpy(module_names[ModuleNr].new_name, ModuleName);
        module_names[ModuleNr].instance = Instance;
    }
}

unsigned int module_handle[MAX_MODULE_NAMES];


/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
void _led_demon(void) {
    int fd;
    int i;
    unsigned int Module, State;
    char Buffer[80];

    /*--------------------------------------------------------------------------------------*\
    \*--------------------------------------------------------------------------------------*/
    for( i = 0 ; i < MAX_MODULE_NAMES ; i++) {
        module_handle[i] = (unsigned int)-1;
    }

    /*--------------------------------------------------------------------------------------*\
    \*--------------------------------------------------------------------------------------*/
    for ( i = 0, fd = -1 ;; ) {

        /*----------------------------------------------------------------------------------*\
         * (re)open
        \*----------------------------------------------------------------------------------*/
        if(i == 0) {
            if(fd >= 0)
                close(fd);
            fd = open(LED_PIPE_FILE, O_RDONLY);
        }

        /*----------------------------------------------------------------------------------*\
         * read from pipe
        \*----------------------------------------------------------------------------------*/
        i = read(fd, Buffer, sizeof(Buffer) - 1);
        if(i > 0) {
            Buffer[i] = '\0';
            DEB_TRACE("[%s] Buffer(%u bytes)=[%s]\n", "led_demon", i, Buffer);
            if(!strncmp(Buffer, "stop", 4)) {
                int led = open(LED_DEV_FILE, O_RDWR);
                for(i = 0 ; i < MAX_MODULE_NAMES ; i++) {
                    if(module_handle[i] != (unsigned int)-1) {
                        ioctl(led, LED_RELEASE_HANDLE, (int)&module_handle[i]);
                    }
                }
                close(led);
                break;
            } else if(!strncmp(Buffer, "list", 4)) {
                unsigned int count;
                for(count = 0 ; count < MAX_MODULE_NAMES ; count++) {
                    if(module_names[count].new_name[0]) {
                        printf("Module Nr.%2u [%s] instance %u (oldname: %s)\n",
                            count, module_names[count].new_name, module_names[count].instance, module_names[count].old_name);
                    }
                }
                continue;
            }
            /*------------------------------------------------------------------------------*\
            \*------------------------------------------------------------------------------*/
            sscanf(Buffer, "%u,%u", &Module, &State);
            State--;
            DEB_TRACE("[%s]: Modul=%u State=%u\n", "led_demon", Module, State);
            if(Module > 0 && Module < MAX_MODULE_NAMES) {
                int led = open(LED_DEV_FILE, O_RDWR);
                /*--------------------------------------------------------------------------*\
                 * get module handle
                \*--------------------------------------------------------------------------*/
                if(module_handle[Module] == (unsigned int)-1) {
                    char *name = module_names[Module].new_name;
                    DEB_TRACE("[%s]: no handle for module %u (name=%s)\n", "led_demon", Module, name);

                    if(*name) {
                        LED_MODULE_T led_module;
                        led_module.name     = name;
                        led_module.instance = module_names[Module].instance;
                        if(ioctl(led, LED_GET_HANDLE, (int)&led_module) == 0) {
                            module_handle[Module] = led_module.handle;
                            DEB_TRACE("[%s]: handle 0x%x \n", "led_demon", module_handle[Module]);
                        } else {
                            DEB_ERR("led-demon: get handle for module %u (%s) instance %u failed\n",
                                    Module, module_names[Module].new_name, module_names[Module].instance);
                        }
                    }
                }
                /*--------------------------------------------------------------------------*\
                 * set state
                \*--------------------------------------------------------------------------*/
                if(module_handle[Module] != (unsigned int)-1) {
                    LED_STATE_T led_state;
                    led_state.handle = module_handle[Module];
                    led_state.state_id = State;
                    if(ioctl(led, LED_ACTION, (int)&led_state)) {
                        DEB_ERR("led-demon: set state to %u for module %u (%s) handle 0x%x instance %u failed\n",
                                    State, Module, module_names[Module].new_name, module_handle[Module], module_names[Module].instance);
                    } else {
                        DEB_TRACE("led-demon: set state to %u for module %u (%s) handle 0x%x instance %u success\n",
                                    State, Module, module_names[Module].new_name, module_handle[Module], module_names[Module].instance);
                    }
                } else {
                    DEB_ERR("[%s]: ERROR: no handle for module %u\n", "led_demon", Module);
                }
                close(led);
            } else {
                DEB_ERR("[%s]: Module out of range (0 < %u < %u)\n", "led-demon", Module, MAX_MODULE_NAMES);
            }
        } else if (i < 0) {
            break;
        }
    }
    close(fd);
    return;
}


/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
void led_demon(void) {
    pid_t pid;

    pid = fork();
    if(pid == 0) {
        _led_demon();
    } else if(pid > 0) {
        printf("led_demon started\n");
    } else {
        printf("led_demon start failed\n");
    }
}