/*
 * Simple USB Serial Echo Program with Timeout, Reconnect, and Backspace Logic.
 * Converted to C++ so the project can use the `pico-ssd1306` C++ library.
 */

#include "pico/stdlib.h"
#include "pico/time.h" // Needed for time_us_64()
#include <stdio.h>
#include <ctype.h>

#include "hardware/i2c.h"
#include "hardware/gpio.h"
#include "pico-ssd1306/ssd1306.h"
#include "pico-ssd1306/textRenderer/TextRenderer.h"

using namespace pico_ssd1306;

// Global display pointer so helper functions can update the OLED
static SSD1306 *g_display = nullptr;

// Holds last echoed line for display
static char g_last_echo[128] = "";
// Scrolling state for last echo (marquee)
static size_t g_last_echo_scroll_index = 0;
static uint64_t g_last_echo_last_scroll_ms = 0;
static const uint64_t SCROLL_INTERVAL_MS = 300; // milliseconds between scroll steps
static const size_t LAST_ECHO_VISIBLE_CHARS = 10; // visible chars for 12x16 font on 128px width

// Refresh OLED with current input (line 0) and last echoed text (line 2)
static void refresh_display(const char *current_input, const char *last_echo) {
    if (!g_display) return;
    g_display->clear();

    // If current input is longer than 10 chars, use smaller font to fit more text
    size_t input_len = current_input ? strlen(current_input) : 0;
    const unsigned char *input_font = (input_len > 10) ? font_5x8 : font_12x16;

    // Draw current input using chosen font
    pico_ssd1306::drawText(g_display, input_font, current_input, 0, 0);

    // Draw last echoed text using the larger font for readability
    // If the last echo is longer than visible chars, create a scrolling window
    size_t last_len = last_echo ? strlen(last_echo) : 0;
    if (last_len > LAST_ECHO_VISIBLE_CHARS) {
        char window[LAST_ECHO_VISIBLE_CHARS + 1];
        // copy up to visible chars starting at scroll index, wrapping as needed
        for (size_t i = 0; i < LAST_ECHO_VISIBLE_CHARS; ++i) {
            size_t src = (g_last_echo_scroll_index + i) % last_len;
            window[i] = last_echo[src];
        }
        window[LAST_ECHO_VISIBLE_CHARS] = '\0';
        pico_ssd1306::drawText(g_display, font_12x16, window, 0, 20);
    } else {
        pico_ssd1306::drawText(g_display, font_12x16, last_echo, 0, 20);
    }

    g_display->sendBuffer();
}

// Define the maximum size for the input string buffer
#define MAX_INPUT_LEN 64
// Define the timeout period: 5 seconds in microseconds
#define TIMEOUT_US 5000000
// ASCII code for Backspace (often sent as 0x08)
#define ASCII_BACKSPACE 8

// Helper function to handle the echoing and resetting of the buffer
void echo_and_reset(char* buffer, int* index_ptr) {
    if (*index_ptr > 0) {
        buffer[*index_ptr] = '\0';
        // Print to USB serial (ALL CAPS)
        printf("\nEchoed (ALL CAPS): ");
        for (int i = 0; buffer[i] != '\0'; i++) {
            char ch = toupper(buffer[i]);
            printf("%c", ch);
        }
        printf("\n");

        // Save last echoed (all caps) for display
        size_t i = 0;
        for (; buffer[i] != '\0' && i < sizeof(g_last_echo) - 1; ++i) {
            g_last_echo[i] = (char)toupper(buffer[i]);
        }
        g_last_echo[i] = '\0';
        // reset scrolling state whenever last echo changes
        g_last_echo_scroll_index = 0;
        g_last_echo_last_scroll_ms = time_us_64() / 1000;
    }

    *index_ptr = 0;
    printf("> ");
    // Update OLED to show cleared input and last echo
    refresh_display("", g_last_echo);
}

void wait_for_usb_connection() {
    printf("Waiting for USB host to connect...\n");
    while (!stdio_usb_connected()) {
        sleep_ms(100);
    }
    printf("\nConnection Established! Starting Echo Session...\n");
}

void run_echo_session() {
    char input_buffer[MAX_INPUT_LEN];
    int buffer_index = 0;
    uint64_t last_char_time = time_us_64();

    printf("--- Pico USB String Echo Program Started ---\n");
    printf("Type a sentence (up to %d chars). It will echo on Enter/Timeout.\n", MAX_INPUT_LEN - 2);
    printf("--------------------------------------------\n");
    printf("> ");

    while (stdio_usb_connected()) {
        int c = getchar_timeout_us(0);
        if (c != PICO_ERROR_TIMEOUT) {
            last_char_time = time_us_64();
            char input_char = (char)c;
            if (input_char == ASCII_BACKSPACE || input_char == 127) {
                if (buffer_index > 0) {
                    buffer_index--;
                    printf("\b \b");
                    // update display to reflect removed char
                    input_buffer[buffer_index] = '\0';
                    refresh_display(input_buffer, g_last_echo);
                }
            } else if (input_char == '\r' || input_char == '\n') {
                echo_and_reset(input_buffer, &buffer_index);
                // after echo_and_reset the display is refreshed inside it
            } else if (buffer_index < (MAX_INPUT_LEN - 1) && isprint(input_char)) {
                printf("%c", input_char);
                input_buffer[buffer_index] = input_char;
                buffer_index++;
                // update OLED with current input
                input_buffer[buffer_index] = '\0';
                refresh_display(input_buffer, g_last_echo);
            }
        }

        if (buffer_index > 0 && (time_us_64() - last_char_time) > TIMEOUT_US) {
            printf("\n--- Timeout Reached (5.0s silence) ---\n");
            echo_and_reset(input_buffer, &buffer_index);
            last_char_time = time_us_64();
        }

        // Advance marquee for last echoed text if needed
        size_t last_len = strlen(g_last_echo);
        uint64_t now_ms = time_us_64() / 1000;
        if (last_len > LAST_ECHO_VISIBLE_CHARS) {
            if (now_ms - g_last_echo_last_scroll_ms >= SCROLL_INTERVAL_MS) {
                g_last_echo_scroll_index = (g_last_echo_scroll_index + 1) % last_len;
                g_last_echo_last_scroll_ms = now_ms;
                // refresh display to show new window
                refresh_display(input_buffer, g_last_echo);
            }
        }

        sleep_us(100);
    }

    printf("\nHost disconnected. Ending Echo Session.\n");
}

int main() {
    stdio_init_all();

    // Initialize I2C for the SSD1306 display (common pins: SDA=GPIO4, SCL=GPIO5)
    i2c_init(i2c0, 400 * 1000);
    gpio_set_function(4, GPIO_FUNC_I2C);
    gpio_set_function(5, GPIO_FUNC_I2C);
    gpio_pull_up(4);
    gpio_pull_up(5);

    // Create display object (address 0x3C is common). Adjust size/address if needed.
    SSD1306 display(i2c0, 0x3C, Size::W128xH64);
    // rotate display 180 degrees (flip). setOrientation(1) flips screen orientation
    display.setOrientation(false);
    display.clear();
    display.sendBuffer();

    // set global pointer and show initial prompt using larger font
    g_display = &display;
    g_last_echo[0] = '\0';
    refresh_display("> ", g_last_echo);


    while (true) {
        wait_for_usb_connection();
        run_echo_session();
    }

    return 0;
}