#include <stdio.h>
#include <time.h>
#include <nds.h>
#include "devices/clock.h"
#include "devices/math.h"
#include "devices/screen.h"
#include "bang.h"
#include "core.h"
#include "main.h"

#define NUM_BR 5

Bedrock br[NUM_BR] = {};
Bedrock *br_main;
Bedrock *br_sub;
bool main_on_bottom = TRUE;

char *system_name = "bedrock-nds/0.1.0-alpha";
char *system_authors = "Ben Bridle";

u8 main_program[] = {
    #include "../include/cobalt.br.inc"
};
u8 keyboard_program[] = {
    #include "../include/keyboard.br.inc"
};


// Change to the next screen layout.
void change_layout(void) {
    lcdSwap();
    main_on_bottom = !main_on_bottom;
    if (main_on_bottom) {
        scr_unmake(&br_sub->scr);
    } else {
        scr_make_sub(&br_sub->scr);
    }
}

void receive_keyboard_byte(u8 byte) {
    if (br_main) {
        inp_receive_byte(&br_main->inp, byte);
    }
}

bool is_keyboard_open(void) {
    return !main_on_bottom;
}

void open_keyboard(void) {
    if (main_on_bottom) {
        change_layout();
    }
}

void close_keyboard(void) {
    if (!main_on_bottom) {
        change_layout();
    }
}

// Scan for input and handle emulator-specific keys.
void receive_input(void) {
    scanKeys();
    if (keysDown() & KEY_SELECT) change_layout();
}


int main(void) {
    #define ALIVE(br)  (br && br->alive)
    #define DEAD(br)   (br && !br->alive)
    #define AWAKE(br)  (br && br->alive &&  br->awake)
    #define ASLEEP(br) (br && br->alive && !br->awake)

    // Set memory identifiers and system device strings.
    for (int i=0; i<NUM_BR; i++) {
        br[i].mem.id = i+1;
        br[i].sys.name.mem = (u8*) &system_name[0];
        br[i].sys.authors.mem = (u8*) &system_authors[0];
    }

    init_screens();
    init_clock();
    init_filesystem();
    lcdMainOnBottom();

    // Load program
    start_br(&br[0], main_program, sizeof(main_program));
    start_br(&br[1], keyboard_program, sizeof(keyboard_program));
    br_main = &br[0];
    br_sub = &br[1];
    scr_make_main(&br_main->scr);

    while (1) {
        if (AWAKE(br_main)) run_br(br_main);
        if (AWAKE(br_sub))  run_br(br_sub);
        if (DEAD(br_main)) br_main = NULL;
        if (DEAD(br_sub))  br_sub  = NULL;

        bool main_flip = ASLEEP(br_main) && br_main->scr.dirty;
        bool sub_flip = ASLEEP(br_sub) && br_sub->scr.dirty;
        if (main_flip || sub_flip) swiWaitForVBlank();
        if (main_flip) { flip_buffer(br_main->scr.nds); br_main->scr.dirty = false; }
        if (sub_flip)  { flip_buffer(br_sub->scr.nds);  br_sub->scr.dirty  = false; }

        rouse:
        receive_input();
        if (ALIVE(br_main) && main_on_bottom) {
            inp_read_navigation(&br_main->inp);
            inp_read_gamepad(&br_main->inp);
            inp_read_touch(&br_main->inp);
        }
        if (ALIVE(br_sub) && !main_on_bottom) {
            inp_read_navigation(&br_sub->inp);
            inp_read_gamepad(&br_sub->inp);
            inp_read_touch(&br_sub->inp);
        }
        if (ASLEEP(br_main)) rouse_br(br_main);
        if (ASLEEP(br_sub))  rouse_br(br_sub);
        if (ASLEEP(br_main) && ASLEEP(br_sub)) {
            // Sleep until next keypad event or clock tick.
            swiIntrWait(1, IRQ_KEYS | IRQ_TIMER0);
            goto rouse;
        }

        if (!br_main) {
            systemShutDown();
            return 0;
        }
    }
}