/*----------*/

#define     PUZZLE_SIZE     4
#define     PUZZLE_PANELS   (PUZZLE_SIZE * PUZZLE_SIZE)
#define     PUZZLE_SHUFFLE  (PUZZLE_SIZE * PUZZLE_SIZE * 4)

enum {
    KEY_INIT    = 0,
    KEY_LEFT,
    KEY_RIGHT,
    KEY_UP,
    KEY_DOWN
};

/*----------*/

typedef struct puzzle_struct {
    char    num[PUZZLE_PANELS];
    short   pos;
    short   direct;
    short   match;
} PUZZLE_STRUCT;

/*----------*/

void    move_puzzle(PUZZLE_STRUCT* puzzle, int key);
void    init_puzzle(PUZZLE_STRUCT* puzzle);
void    slide_panel(PUZZLE_STRUCT* puzzle);
void    draw_puzzle(PUZZLE_STRUCT* puzzle);
void    draw_panel(PUZZLE_STRUCT* puzzle, int pos);
int     Random();

/*----------*/

int     main()
{
    PUZZLE_STRUCT   puzzle;

    move_puzzle(&puzzle, KEY_INIT);
    /*  Main Loop   */

    return 0;
}


void    move_puzzle(PUZZLE_STRUCT* puzzle, int key)
{
    switch (key) {

        case KEY_INIT:
            puzzle->direct = 0;
            init_puzzle(puzzle);
            draw_puzzle(puzzle);
            break;

        case KEY_LEFT:
            if (puzzle->pos % PUZZLE_SIZE > 0) {
                puzzle->direct = -1;
                slide_panel(puzzle);
                draw_puzzle(puzzle);
            }
            break;

        case KEY_RIGHT:
            if (puzzle->pos % PUZZLE_SIZE < PUZZLE_SIZE - 1) {
                puzzle->direct = 1;
                slide_panel(puzzle);
                draw_puzzle(puzzle);
            }
            break;

        case KEY_UP:
            if (puzzle->pos > PUZZLE_SIZE - 1) {
                puzzle->direct = -PUZZLE_SIZE;
                slide_panel(puzzle);
                draw_puzzle(puzzle);
            }
            break;

        case KEY_DOWN:
            if (puzzle->pos < PUZZLE_PANELS - PUZZLE_SIZE) {
                puzzle->direct = PUZZLE_SIZE;
                slide_panel(puzzle);
                draw_puzzle(puzzle);
            }
            break;

        default:
            break;
    }

    return;
}

void    init_puzzle(PUZZLE_STRUCT* puzzle)
{
    int     i;
    int     tmp;

    for (i = 0; i < PUZZLE_PANELS; i++) {
        puzzle->num[i] = i;
    }
    puzzle->pos     = PUZZLE_PANELS - 1;
    puzzle->match   = PUZZLE_PANELS - 1;

    for (i = 0; i < PUZZLE_SHUFFLE; i++) {
        tmp = Random() % PUZZLE_SIZE;
        while ((puzzle->pos % PUZZLE_SIZE) != tmp) {
            puzzle->direct = ((puzzle->pos % PUZZLE_SIZE) > tmp) ? -1 : 1;
            slide_panel(puzzle);
        }
        tmp = Random() % PUZZLE_SIZE;
        while ((puzzle->pos / PUZZLE_SIZE) != tmp) {
            puzzle->direct = ((puzzle->pos / PUZZLE_SIZE) > tmp) ? -PUZZLE_SIZE : PUZZLE_SIZE;
            slide_panel(puzzle);
        }
    }

    return;
};

void    slide_panel(PUZZLE_STRUCT* puzzle)
{
    if (puzzle->num[puzzle->pos] == puzzle->pos) {
        puzzle->match++;
    }

    puzzle->num[puzzle->pos] = puzzle->num[puzzle->pos + puzzle->direct];
    puzzle->pos += puzzle->direct;
    puzzle->num[puzzle->pos] = PUZZLE_PANELS - 1;

    if (puzzle->num[puzzle->pos - puzzle->direct] == puzzle->pos) {
        puzzle->match--;
    }

    return;
}

void    draw_puzzle(PUZZLE_STRUCT* puzzle)
{
    int     i;

    if (puzzle->direct) {
        draw_panel(puzzle, puzzle->pos);
        draw_panel(puzzle, puzzle->pos - puzzle->direct);
    } else {
        for (i = 0; i < PUZZLE_PANELS; i++) {
            draw_panel(puzzle, i);
        }
    }
}

void    draw_panel(PUZZLE_STRUCT* puzzle, int pos)
{
    /*  Draw a panel    */
    return;
}

int     Random()
{
    /*  Return a random value   */
    return 0;
}