typedef enum {
    IDLE,
    MWEST,
    MEAST,
    MNORTH,
    MSOUTH,
    FIRING
} action;

typedef struct gamestate {
    int x, y;
    action act;

    keyseq **seqs;
    unsigned int seqcount;
} gamestate;

typedef struct keyseq {
    SDLKey *key;
    unsigned int max;
    unsigned int counter;
    void (*action)(void);
} keyseq;

keyseq *initkeyseq(SDLKey *key, unsigned int length, void (*action)(void)) {
    keyseq *seq;

    if(key == NULL)
        return(NULL);

    seq = malloc(sizeof(keyseq));
    if(seq == NULL)
        return(NULL);

    seq->max = length;
    seq->counter = 0;
    seq->action = action;

    seq->key = malloc(sizeof(SDLKey) * length);
    if(seq->key == NULL) {
        free(seq);
        return(NULL);
    }

    memcpy(seq->key, key, sizeof(SDLKey) * length);

    return(seq);
}

void freekeyseq(keyseq *seq) {
    free(seq->key);
    free(seq);
}

void resetkeyseq(keyseq *seq) {
    seq->counter = 0;
}

unsigned int updatekeyseq(keyseq *seq, SDLKey key) {
    unsigned int remain;

    if(seq->key[counter] == key)
        seq->counter++;

    remain = seq->max - seq->counter;
    if(remain == 0) {
        resetkeyseq(seq);
        if(seq->action != NULL)
            seq->action();
        return(0);
    }

    return(remain);
}

unsigned int handleinput(gamestate *state) {
    SDL_Event ev;
    unsigned int i;

    while(SDL_PollEvent(&ev)) {
        switch(ev.type) {
            case SDL_KEYDOWN:
                switch(ev.key.keysym.sym) {
                    case SDLK_UP:
                        state->action = MNORTH;
                        break;
                    case SDLK_DOWN:
                        state->action = MSOUTH;
                        break;
                    case SDLK_LEFT:
                        state->action = MWEST;
                        break;
                    case SDLK_RIGHT:
                        state->action = MEAST;
                        break;
                    default:
                        break;
                }
                break;
            case SDL_KEYUP:
                switch(ev.key.keysym.sym) {
                    case SDLK_UP:
                        if(state->action == MNORTH)
                            state->action = IDLE;
                        break;
                    case SDLK_DOWN:
                        if(state->action == MSOUTH)
                            state->action = IDLE;
                        break;
                    case SDLK_LEFT:
                        if(state->action == MWEST)
                            state->action = IDLE;
                        break;
                    case SDLK_RIGHT:
                        if(state->action == MEAST)
                            state->action = IDLE;
                        break;
                    default:
                        break;
                }
                for(i = 0; i < state->seqcount; i++) {
                    if(updatekeyseq(state->seq[i], ev.key.keysym.sym) == 0)
                        fprintf(debug, "Key sequence %u caught.\n", i);
                }
                break;
            default:
                break;
        }
    }

    return(0);
}