#include "definition.h"
#include "alt_types.h"
#include "altera_avalon_pio_regs.h"
#include "sys/alt_irq.h"
//#include "sys/alt_timestamp.h"
#include <io.h>
#include <system.h>
#include <stdint.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/alt_alarm.h>

#define LIGHTS_NUM 7
#define HEX_NUM 6

int currentTime = 0;

typedef enum STATES {
    NONE,
    FIRST_TYPE,
    SECOND_TYPE,
    ERROR
} STATES;

typedef struct IOreg {
    uint32_t sliders;
    uint32_t leds[LIGHTS_NUM];
    uint32_t hex[HEX_NUM];
} IOreg;

STATES currentState = NONE;

void clear_led(IOreg* regs) {
    for (int i = 0; i < LIGHTS_NUM; ++i)
        regs->leds[i] = 0x00000000;
}

void clear_hex(IOreg* regs) {
    for (int i = 0; i < HEX_NUM; ++i)
        regs->hex[i] = 0x00000000;
}

void read_IO(IOreg* regs) {
    regs->sliders = IORD(SW_SLIDERS_BASE, 0);
}

STATES get_state(IOreg* regs) {
    int state = regs->sliders;
    STATES previousState = currentState;

    switch (state) {
        case SW0:
        case SW2:
        case SW4:
        case SW5:
        case SW0 | SW2:
        case SW0 | SW4:
        case SW0 | SW5:
        case SW2 | SW4:
        case SW2 | SW5:
        case SW4 | SW5:
        case SW0 | SW2 | SW4:
        case SW0 | SW2 | SW5:
        case SW2 | SW4 | SW5:
        case SW0 | SW2 | SW4 | SW5:
            if (currentState != FIRST_TYPE &&
                    currentTime + alt_ticks_per_second() <= alt_nticks()) {
                currentTime = alt_nticks();
            }

            currentState = FIRST_TYPE;
            break;
        case SW1:
        case SW3:
        case SW6:
        case SW1 | SW3:
        case SW1 | SW6:
        case SW3 | SW6:
        case SW1 | SW3 | SW6:
            if (currentState != SECOND_TYPE &&
                    currentTime + alt_ticks_per_second() <= alt_nticks()) {
                currentTime = alt_nticks();
            }

            currentState = SECOND_TYPE;
            break;
        case 0:
            currentState = NONE;
            break;
        default:
            currentState = ERROR;
            break;
        }

    if (previousState == ERROR && previousState != currentState) {
        currentTime = alt_nticks();
    }

    return currentState;
}

void update(STATES state, IOreg* regs) {
    switch (state) {
    case NONE:
        if (currentTime + alt_ticks_per_second() <= alt_nticks()) {
            clear_led(regs);
            clear_hex(regs);
        }
        break;
    case FIRST_TYPE:
        if (currentTime + alt_ticks_per_second() <= alt_nticks()) {
            regs->leds[0] = LED0;
            regs->leds[2] = LED2;
            regs->leds[4] = LED4;
            regs->leds[5] = LED5;
            regs->hex[5] = HEX_ONE;
        }
        break;
    case SECOND_TYPE:
        if (currentTime + alt_ticks_per_second() <= alt_nticks()) {
            regs->leds[1] = LED1;
            regs->leds[3] = LED3;
            regs->leds[6] = LED6;
            regs->hex[3] = HEX_TWO;
        }
        break;
    case ERROR:
        if (currentTime + alt_ticks_per_second() <= alt_nticks()) {
            for (int i = 0; i < LIGHTS_NUM; i++)
                regs->leds[i] = LED9;

            regs->hex[1] = HEX_E;
            regs->hex[0] = HEX_R;
        }
        break;
    default:
        if (currentTime + alt_ticks_per_second() <= alt_nticks()) {
            clear_led(regs);
            clear_hex(regs);
        }
        break;
    }
}

void write_IO(IOreg* regs) {
    for (int i = 0; i < LIGHTS_NUM; i++)
        IOWR(LEDS_BASE, 0, regs->leds[i]);

    for (int i = 0; i < HEX_NUM; i++)
        IOWR(HEX_BASE, i, regs->hex[i]);
}

int main(void) {
    IOreg regs = { 0 };

    clear_led(&regs);
    clear_hex(&regs);
    write_IO(&regs);

    while (1) {
        read_IO(&regs);
        update(get_state(&regs), &regs);
        write_IO(&regs);
    }
    return 0;
}