/*
Copyright (c) 2023 Bad Diode

Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE.
*/

// TODO: A list of features I would like to get to implement in the near future.
//
// UI tweaks.
//  - Add custom user themes
//  - Animations for cursor movement/current step highlight. (A fade out maybe?)
//
// Quality of life improvements.
//  - When not on play mode, adjusting a note or a parameter triggers the sound.
//    This could get annoying, so maybe it should be a configuration option to
//    enable it?
//  - Undo/Redo.
//
//  Advanced
//  - Add tap tempo for BPM.
//  - Allow "marking" several trigs to be able to copy/paste them and/or adjust
//    their parameters.
//  - Add an envelope to ch3, would need to work with a timer in order to make
//    it work I think.
//  - Sync via MIDI via arduinoboy or something similar.
//  - Per trig LFO? How would we go about this? There is at least one empty slot
//    in all channels. LFO amount? LFO speed? Would need a dedicated page for
//    configuring LFOs
//  - Per-channel N steps to create polymeters?
//  - Study how to better embed data into the cart that doesn't involve the
//    build system to generate .c files. Just use the linker to put binary data
//    into the ROM.
//
//  WIP (1.7)
//  - Scale mode for entering notes.
//  - Improve SRAM saving to make room for longer patterns and/or more banks.
//  - Add CLEAR ALL to the settings menu.
//  - Higher resolution clock to allow for microtiming and more accurate tempo.
//  - Multiple pattern chains per bank that we can toggle between, gotta study
//    if they fit in the SRAM.
//  - Make sure bank switching is queued like patterns.
//  - Add settings for "performance mode" in which banks are not saved by
//    default while changing patterns.
//  - Make sure sync works with the same cable for in/out.
//  - Improve "grey" cursor with dithering instead.
//  - Remove thin cursor option and make the fat one default, it's just better.
//  - Settings page overhaul.
//  - Make sure there is an ALL notification when modifying channel params so
//    that it's clear it's affecting all triggers.
//  - Blank patterns could show up as empty on the pattern view for better
//    separation and section organization.
//  - Study more improvements for a "performance mode".
//

#include "gba/gba.h"

#include "renderer_m0.c"
#include "globals.c"
#include "settings.c"
#include "dsound.c"
#include "sequencer.c"

#define PROF_ENABLE 0
#include "profiling.c"

void
render_sequencer(void) {
    if (redraw_trigs) {
        PROF(draw_triggers(), draw_trigs_cycles);
        redraw_trigs = false;
    }
    if (redraw_channels) {
        PROF(draw_channels(), draw_btn_cycles);
        redraw_channels = false;
    }
    if (redraw_pattern_buttons) {
        PROF(draw_pattern_buttons(), draw_btn_cycles);
        redraw_pattern_buttons = false;
    }
    if (redraw_bank_buttons) {
        PROF(draw_bank_buttons(), draw_btn_cycles);
        redraw_bank_buttons = false;
    }
    if (redraw_bpm) {
        PROF(draw_bpm(), draw_btn_cycles);
        redraw_bpm = false;
    }
    if (redraw_play_pause) {
        PROF(draw_play(), draw_btn_cycles);
        PROF(draw_stop(), draw_btn_cycles);
        // TODO: Move to separate if condition
        PROF(draw_settings(), draw_btn_cycles);
        PROF(draw_scale(), draw_btn_cycles);
        redraw_play_pause = false;
    }
    if (redraw_piano_note) {
        PROF(draw_piano_notes(), draw_piano_cycles);
        redraw_piano_note = false;
    }
    if (redraw_params) {
        PROF(draw_parameters(), draw_param_cycles);
        redraw_params = false;
    }

    if (input_handler == handle_pattern_selection ||
            input_handler == handle_pattern_chain) {
        draw_pattern_chain();
    }

    // TODO: redraw_notif?
    draw_notif_bar();
    PROF(draw_cursors(), draw_cursor_cycles);
}

void
render_settings(void) {
    txt_drawf_small("settings", 11, 5, COL_FG)
    txt_printf("\n\n\n");
    txt_printf("  SYNC:   %s\n\n", sync_setting_str[settings.sync]);
    txt_printf("  THEME:  %s\n\n", theme_setting_str[settings.theme]);
    txt_printf("  CURSOR: %s\n\n", cursor_setting_str[settings.cursor]);
    txt_printf("  HELP:   %s\n\n", help_setting_str[settings.help]);
    txt_render();
    txt_clear();
    PROF(draw_settings_cursor(), draw_cursor_cycles);
}

void
render(void) {
    if (clear_screen) {
        PROF(screen_fill(COL_BG), clear_cycles);
        clear_screen = false;
    }
    switch (scene) {
        case SCENE_SETTINGS: {
            render_settings();
        } break;
        case SCENE_SEQUENCER: {
            render_sequencer();
        } break;
    }
    // DEBUG: Ensuring the saved data don't exceed SRAM size (32k).
    txt_drawf("SIZE: %lu", 0, 0, COL_ACC_1, sizeof(Metadata) + sizeof(patterns) * 6 + sizeof(chain) * 6);
}

void
handle_input(void) {
    switch (scene) {
        case SCENE_SETTINGS: {
            handle_settings_input();
        } break;
        case SCENE_SEQUENCER: {
            handle_sequencer_input();
        } break;
    }
}

void
update(void) {
    if (next_scene != scene) {
        scene = next_scene;
        clear_screen = true;
        redraw_trigs = true;
        redraw_channels = true;
        redraw_pattern_buttons = true;
        redraw_bank_buttons = true;
        redraw_bpm = true;
        redraw_play_pause = true;
        redraw_piano_note = true;
        redraw_params = true;
    }
    last_trig_loc = trig_selection_loc;
    last_channel_loc = channel_selection_loc;
    last_pattern_loc = pattern_selection_loc;
    last_right_col_loc = right_col_selection_loc;
    if (update_bpm) {
        set_time(patterns[current_pattern].bpm);
        update_bpm = false;
    }
    if (audio_sync_click) {
        play_click();
    }
    if (notif.time > 0) {
        notif.time--;
    }
    rng_state++;
}

int
main(void) {
    // Adjust system wait times.
    SYSTEM_WAIT = SYSTEM_WAIT_CARTRIDGE;

    // Initialize renderer.
    renderer_init();

    // Register interrupts.
    irq_init();
    irs_set(IRQ_VBLANK, sound_vsync);

    // Initialize sequencer.
    sequencer_init();
    txt_spacing(6);

    // Main loop.
    while (true) {
        poll_keys();
        bios_vblank_wait();
        PROF_SHOW();
        FRAME_START();
        PROF(flip_buffer(), flip_cycles);
        PROF(update(), update_cycles);
        PROF(handle_input(), input_cycles);
        PROF(render(), render_cycles);
        FRAME_END();
    }

    return 0;
}