/*
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?)
//  - Should the channel parameters reset after leaving them? Is it more or
//    less confusing this way?
//
// 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?
//  - Channel params should show if there are some already on all triggers and
//    modify only the selected parameter, not all of them.
//  - Should scale mode be toggleable?
//  - Improve SRAM saving to make room for longer patterns and/or more banks.
//  - Higher resolution clock to allow for microtiming and more accurate tempo.
//  - Add clipboard sharing between banks.
//
//  WIP (1.7)
//  + Improve "grey" cursor with dithering instead.
//  + New channel icons.
//  + Update rcol UI and cursor management.
//  + Fix bug: Copy/paste don't update the BMP drawing.
//  + Blank patterns could show up as empty on the pattern view for better
//    separation and section organization.
//  + Pattern can be cleared on pattern view with (SEL + L + R). This is
//    reversible with the same combination unless the pattern is modified.
//  + Make sure there is an ALL notification when modifying channel params so
//    that it's clear it's affecting all triggers.
//  + Fix keyboard note drawing bugs.
//  + Fix stop button behaviour.
//  + Scale mode for entering notes.
//  + Make sure bank switching is queued like patterns.
//  + If we are on sync in, BPM should display SYNC
//  + Visual feedback for scale/root note adjustment.
//  + Settings page overhaul.
//  + Add global mutes option.
//  + Add global bpm option.
//  + Add auto-save option.
//  + Remove thin cursor option and make the fat one default, it's just better.
//  + Restore black keys when not on scale mode
//  + Enable pattern chain toggling.
//  + Enable pattern chain clearing.
//  + Enable pattern chain randomizing.
//  + Check to make sure parameters are fully clearing the screen, the cursor
//    can hang (need to clear the cursor parameter position when moving to/from
//    patterns to channels)
//  + If select random chain patterns when nothing there chain is propagated but
//    play head doesn’t begin at first chain pattern. User must manually place
//    a pattern to start chain.
//  + Random chain just places A- doesn’t check if which patterns have content
//    in bank for random placement.
//  + Add help for scale parameters and banks E/F (consider auto-save settings
//    for notification)
//  + Default should be help is on
//  + Cursor on bank can wrap around (up/down) but the same can't be done on
//    patterns.
//  + Add help for pattern chain
//  - Add CREDITS to the documentation for now, should probably be a menu item
//    later.
//  - Make sure sync works with the same cable for in/out.

#include "gba/gba.h"

#include "renderer_m0.c"
#include "globals.c"
#include "settings.c"
#include "dsound.c"
#include "scale.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);
        PROF(draw_settings(), draw_btn_cycles);
        redraw_play_pause = false;
    }
    if (redraw_scale) {
        PROF(draw_scale(), draw_btn_cycles);
        redraw_scale = 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();
    }

    draw_notif_bar();
    PROF(draw_piano_notes(), draw_piano_cycles);
    PROF(draw_cursors(), draw_cursor_cycles);
}

void
render_settings(void) {
    size_t x0 = 8;
    size_t x1 = x0 + 64;
    size_t y0 = 6;

    // Header.
    txt_drawf("SETTINGS", x0, y0, COL_FG)
    draw_wrench(SCREEN_WIDTH - 32, y0, COL_FG);
    y0 = 16;
    draw_filled_rect(x0, y0 - 1, SCREEN_WIDTH - 9,  y0, COL_FG);
    y0 = 20;

    // Globals.
    txt_drawf("GLOBAL", x0, y0, COL_FG);
    draw_line(x0, y0 + 9, SCREEN_WIDTH - 9,  y0 + 9, COL_FG);
    y0 += 17;
    draw_rect(x0, y0, x1, y0 + 10, COL_FG);
    txt_drawf("MUTE", x0 + 2, y0 + 1, COL_FG);
    txt_drawf("%s", x1 + 8, y0 + 1, COL_FG, toggle_settings_str[settings.global_mute]);
    y0 += 17;
    draw_rect(x0, y0, x1, y0 + 10, COL_FG);
    txt_drawf("BPM", x0 + 2, y0 + 1, COL_FG);
    txt_drawf("%s", x1 + 8, y0 + 1, COL_FG, toggle_settings_str[settings.global_bpm]);
    y0 += 17;

    txt_drawf("GENERAL", x0, y0, COL_FG);
    draw_line(x0, y0 + 9, SCREEN_WIDTH - 9,  y0 + 9, COL_FG);
    y0 += 17;
    draw_rect(x0, y0, x1, y0 + 10, COL_FG);
    txt_drawf("AUTO-SAVE", x0 + 2, y0 + 1, COL_FG);
    txt_drawf("%s", x1 + 8, y0 + 1, COL_FG, toggle_settings_str[settings.auto_save]);
    y0 += 17;
    draw_rect(x0, y0, x1, y0 + 10, COL_FG);
    txt_drawf("SYNC", x0 + 2, y0 + 1, COL_FG);
    txt_drawf("%s", x1 + 8, y0 + 1, COL_FG, sync_setting_str[settings.sync]);
    y0 += 17;
    draw_rect(x0, y0, x1, y0 + 10, COL_FG);
    txt_drawf("THEME", x0 + 2, y0 + 1, COL_FG);
    txt_drawf("%s", x1 + 8, y0 + 1, COL_FG, theme_setting_str[settings.theme]);
    y0 += 17;
    draw_rect(x0, y0, x1, y0 + 10, COL_FG);
    txt_drawf("HELP", x0 + 2, y0 + 1, COL_FG);
    txt_drawf("%s", x1 + 8, y0 + 1, COL_FG, toggle_settings_str[settings.help]);

    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_params = true;
        redraw_scale = 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) {
        if (settings.global_bpm) {
            set_time(settings.bpm);
        } else {
            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;
}