#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdbool.h>

#define SPI_PORT PORTB
#define SPI_DDR DDRB
#define SPI_SCK PB5
#define SPI_MOSI PB3
#define SPI_SS PB2

#define LCD_CD PB0
#define LCD_RST PB1

#define ENC_A (PINB & (1 << PB6))
#define ENC_B (PINB & (1 << PB7))

static const uint8_t sacred_chao[200] = { 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF0, 0xF8, 0xFC, 0xFC, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFE, 0xFC, 0xFC, 0xF8, 0xF0, 0xF0, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00,
                                          0x80, 0xF0, 0xFC, 0xFE, 0xFF, 0xFF, 0x7F, 0x3F, 0x1F, 0x3F, 0x3F, 0x7F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x1F, 0x0F, 0x0F, 0x07, 0x07, 0x07, 0x03, 0xC3, 0xE3, 0x73, 0x37, 0x17, 0x07, 0x0F, 0x1E, 0x3C, 0xF0, 0x80,
                                          0xFF, 0xFF, 0xFF, 0xE7, 0xC3, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0xFC, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFC, 0x30, 0x00, 0x00, 0xFF,
                                          0x01, 0x0F, 0x3F, 0x4F, 0x9F, 0x3F, 0x3E, 0x3C, 0x7C, 0x7C, 0x7C, 0x7C, 0x3E, 0x3E, 0x3E, 0x1F, 0x1F, 0x0F, 0x07, 0x01, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x07, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x07, 0x07, 0x03, 0x81, 0x40, 0x30, 0x0E, 0x01,
                                          0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x08, 0x08, 0x10, 0x20, 0x20, 0x40, 0x40, 0x40, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x40, 0x40, 0x40, 0x20, 0x20, 0x10, 0x08, 0x08, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00 };

static const uint8_t onders_org[96] = { 0xE0, 0x60, 0xE0, 0x00, 0x00, 0xE0, 0x60, 0xE0, 0x00, 0x00, 0xE0, 0x60, 0xF8, 0x00, 0x00, 0xE0, 0xA0, 0xE0, 0x00, 0x00, 0xE0, 0x20, 0x60, 0x00, 0x00, 0xE0, 0xA0, 0xA0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x60, 0xE0, 0x00, 0x00, 0xE0, 0x20, 0x60, 0x00, 0x00, 0xE0, 0x60, 0xE0,
                                        0x03, 0x02, 0x03, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x03, 0x02, 0x03, 0x00, 0x00, 0x03, 0x02, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x02, 0x03, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x0A, 0x0F};

struct symbol {
    uint8_t length;
    uint8_t symbol[];
};

static const struct symbol sym_c = { 5, { 0xF8, 0xFC, 0x0C, 0x1C, 0x18,
                                          0x1F, 0x3F, 0x30, 0x38, 0x18 } };
static const struct symbol sym_h = { 6, { 0xFC, 0xFC, 0x80, 0x80, 0xFC, 0xFC,
                                          0x3F, 0x3F, 0x01, 0x01, 0x3F, 0x3F } };

static const struct symbol sym_0 = { 5, { 0xF8, 0xFC, 0x0C, 0xFC, 0xF8,
                                          0x1F, 0x3F, 0x30, 0x3F, 0x1F } };
static const struct symbol sym_1 = { 5, { 0x30, 0x30, 0xFC, 0xFC, 0x00,
                                          0x30, 0x30, 0x3F, 0x3F, 0x30 } };
static const struct symbol sym_2 = { 5, { 0x18, 0x1C, 0x8C, 0xFC, 0xF8,
                                          0x38, 0x3E, 0x3F, 0x33, 0x30 } };
static const struct symbol sym_3 = { 5, { 0x18, 0x9C, 0x8C, 0xFC, 0x78,
                                          0x18, 0x39, 0x31, 0x3F, 0x1E } };
static const struct symbol sym_4 = { 5, { 0x80, 0xE0, 0x78, 0xFC, 0xFC,
                                          0x07, 0x07, 0x06, 0x3F, 0x3F } };
static const struct symbol sym_5 = { 5, { 0xFC, 0xFC, 0x8C, 0x8C, 0x0C,
                                          0x1C, 0x3D, 0x31, 0x3F, 0x1F } };
static const struct symbol sym_6 = { 5, { 0xF8, 0xFC, 0x8C, 0xBC, 0x38,
                                          0x1F, 0x3F, 0x31, 0x3F, 0x1F } };
static const struct symbol sym_7 = { 5, { 0x0C, 0x0C, 0xEC, 0xFC, 0x1C,
                                          0x00, 0x3E, 0x3F, 0x01, 0x00 } };
static const struct symbol sym_8 = { 5, { 0x78, 0xFC, 0x8C, 0xFC, 0x78,
                                          0x1E, 0x3F, 0x31, 0x3F, 0x1E } };
static const struct symbol sym_9 = { 5, { 0xF8, 0xFC, 0x8C, 0xFC, 0xF8,
                                          0x1C, 0x3D, 0x31, 0x3F, 0x1F } };

static const struct symbol sym_setup = { 19, { 0xF8, 0x98, 0xB8, 0x00, 0xF8, 0x98, 0x18, 0x00, 0x18, 0xF8, 0x18, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0xF8, 0x98, 0xF8,
                                               0x1D, 0x19, 0x1F, 0x00, 0x1F, 0x19, 0x18, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x1F, 0x18, 0x1F, 0x00, 0x1F, 0x01, 0x01 } };

enum input {cw, ccw};

static enum state {home} current_state = home;
static enum home_state {ch1, ch2, ch3, setup} current_home_state = ch1;

static uint8_t enc = 0;

void spi_init(void) {
    SPI_DDR |= (1 << SPI_SCK) | (1 << SPI_MOSI) | (1 << SPI_SS);
    SPI_PORT |= (1 << SPI_SS);
    SPCR = (1 << SPE) | (1 << MSTR);
    SPSR = (1 << SPI2X);
}

uint8_t spi_byte(uint8_t data) {
   SPDR = data;
   while(!(SPSR & (1 << SPIF)));
   return SPDR;
 }

void lcd_write(uint8_t data) {
    SPI_PORT &= ~(1 << SPI_SS);
    spi_byte(data);
    SPI_PORT |= (1 << SPI_SS);
}

void lcd_init(void) {
    SPI_DDR |= (1 << LCD_CD) | (1 << LCD_RST);
    _delay_ms(1);
    SPI_PORT |= (1 << LCD_RST);
    _delay_ms(5);

    lcd_write(0x40); // (6)  Set Scroll Line: Display start line 0
    lcd_write(0xA1); // (13) Set SEG direction: SEG reverse
    lcd_write(0xC0); // (14) Set COM direction: Normal COM0 - COM63
    lcd_write(0xA6); // (11) Set Inverse Display: Display inverse off
    lcd_write(0xA2); // (17) Set LCD Bias Ratio: Set Bias 1/9 (Duty 1/65)
    lcd_write(0x2F); // (5)  Set Power Control: Booster, Regulator and Follower on
    lcd_write(0x27); // (8)  Set VLCD Resistor Ratio: Set Contrast
    lcd_write(0x81); // (9)  Set Electronic Volume: Set Contrast
    lcd_write(0x10); // (9)  Set Electronic Volume: Set Contrast
    lcd_write(0xAF); // (12) Set Display Enable: Display on
}

void lcd_fill(uint8_t data) {
    for (uint8_t i = 0; i < 8; i++) {
        SPI_PORT &= ~(1 << LCD_CD);
        lcd_write(0x00);
        lcd_write(0x10);
        lcd_write(0xB0 + i);
        SPI_PORT |= (1 << LCD_CD);

        for (uint8_t j = 0; j < 102; j++)
            lcd_write(data);
    }
}

static void lcd_write_kerning(const uint8_t length,
                              const bool invert) {
    for (uint8_t i = 0; i < length; i++)
        if (invert)
            lcd_write(0xFF);
        else
            lcd_write(0x00);
}

static void lcd_write_symbol_page(const struct symbol* sym,
                                  uint8_t page,
                                  bool invert) {
    for (uint8_t i = 0; i < sym->length; i++)
        if (invert)
            lcd_write(~sym->symbol[page * sym->length + i]);
        else
            lcd_write(sym->symbol[page * sym->length + i]);
}

void lcd_splash(void) {
    lcd_fill(0x00);

    for (uint8_t i = 0; i < 5; i++) {
        SPI_PORT &= ~(1 << LCD_CD);
        lcd_write(0x0F);
        lcd_write(0x11);
        lcd_write(0xB1 + i);
        SPI_PORT |= (1 << LCD_CD);

        for (uint8_t j = 0; j < 40; j++)
            lcd_write(sacred_chao[i * 40 + j]);

    }

    for (uint8_t i = 0; i < 2; i++) {
        SPI_PORT &= ~(1 << LCD_CD);
        lcd_write(0x0A);
        lcd_write(0x11);
        lcd_write(0xB6 + i);
        SPI_PORT |= (1 << LCD_CD);

        for (uint8_t j = 0; j < 48; j++)
            lcd_write(onders_org[i * 48 + j]);
    }
}

static void lcd_home(void) {
    lcd_fill(0x00);

    bool ch1_selected = false;
    bool ch2_selected = false;
    bool ch3_selected = false;
    bool setup_selected = false;

    switch(current_home_state) {
    case ch1:
        ch1_selected = true;
        break;
    case ch2:
        ch2_selected = true;
        break;
    case ch3:
        ch3_selected = true;
        break;
    default: // setup
        setup_selected = true;
        break;
    }

    for (uint8_t i = 0; i < 2; i++) {
        SPI_PORT &= ~(1 << LCD_CD);
        lcd_write(0x00);
        lcd_write(0x10);
        lcd_write(0xB0 + i);
        SPI_PORT |= (1 << LCD_CD);

        lcd_write_kerning(2, ch1_selected);
        lcd_write_symbol_page(&sym_c, i, ch1_selected);
        lcd_write_kerning(2, ch1_selected);
        lcd_write_symbol_page(&sym_h, i, ch1_selected);
        lcd_write_kerning(2, ch1_selected);
        lcd_write_symbol_page(&sym_1, i, ch1_selected);
        lcd_write_kerning(2, ch1_selected);

        SPI_PORT &= ~(1 << LCD_CD);
        lcd_write(0x00);
        lcd_write(0x10);
        lcd_write(0xB2 + i);
        SPI_PORT |= (1 << LCD_CD);

        lcd_write_kerning(2, ch2_selected);
        lcd_write_symbol_page(&sym_c, i, ch2_selected);
        lcd_write_kerning(2, ch2_selected);
        lcd_write_symbol_page(&sym_h, i, ch2_selected);
        lcd_write_kerning(2, ch2_selected);
        lcd_write_symbol_page(&sym_2, i, ch2_selected);
        lcd_write_kerning(2, ch2_selected);

        SPI_PORT &= ~(1 << LCD_CD);
        lcd_write(0x00);
        lcd_write(0x10);
        lcd_write(0xB4 + i);
        SPI_PORT |= (1 << LCD_CD);

        lcd_write_kerning(2, ch3_selected);
        lcd_write_symbol_page(&sym_c, i, ch3_selected);
        lcd_write_kerning(2, ch3_selected);
        lcd_write_symbol_page(&sym_h, i, ch3_selected);
        lcd_write_kerning(2, ch3_selected);
        lcd_write_symbol_page(&sym_3, i, ch3_selected);
        lcd_write_kerning(2, ch3_selected);

        SPI_PORT &= ~(1 << LCD_CD);
        lcd_write(0x00);
        lcd_write(0x10);
        lcd_write(0xB6 + i);
        SPI_PORT |= (1 << LCD_CD);

        lcd_write_kerning(2, setup_selected);
        lcd_write_symbol_page(&sym_setup, i, setup_selected);
        lcd_write_kerning(3, setup_selected);
    }
}

static void update_home(enum input event) {
    switch (event) {
    case cw:
        current_home_state++;
        if (current_home_state > setup)
            current_home_state = ch1;
        lcd_home();
        break;
    case ccw:
        current_home_state--;
        if (current_home_state > setup)
            current_home_state = setup;
        lcd_home();
        break;
    }
}

static void update_state(enum input event) {
    switch (current_state) {
    case home:
        update_home(event);
        break;
    }
}

static void change_state(enum state new_state) {
    switch(new_state) {
    case home:
        lcd_home();
        current_state = home;
        break;
    }
}

// Encoder rotation interrupt
ISR(PCINT0_vect) {
    cli();

    switch(enc) {
    case 0:
        if (ENC_A && !ENC_B)
            enc = 1;
        else if (!ENC_A && ENC_B)
            enc = 3;
        break;
    case 1:
        if (ENC_A && ENC_B) {
            enc = 2;
            update_state(cw);
        } else if (!ENC_A && !ENC_B) {
            enc = 0;
            update_state(ccw);
        }
        break;
    case 2:
        if (!ENC_A && ENC_B)
            enc = 3;
        else if (ENC_A && !ENC_B)
            enc = 1;
        break;
    case 3:
        if (!ENC_A && !ENC_B) {
            enc = 0;
            update_state(cw);
        } else if (ENC_A && ENC_B) {
            enc = 2;
            update_state(ccw);
        }
        break;
    }

    // TODO: proper debounce and dechattering
    _delay_us(100);

    sei();
}

int main(void) {
    // FastPWM: 1.25kHz
    // TODO: Try to get the backlit even more dim
    TCCR0A = (1 << WGM01) | (1 << WGM00) | (1 << COM0B1);
    TCCR0B = (1 << CS01) | (1 << WGM02); // prescaler = 8;
    OCR0A = 100;
    OCR0B = 0;
    DDRD |= (1 << PD5);

    // SPI setup
    spi_init();
    lcd_init();

    // Encoder setup
    PORTB |= (1 << PB6) | (1 << PB7);
    PCICR |= (1 << PCIE0);
    PCMSK0 |= (1 << PCINT6) | (1 << PCINT7);

    // Show splash screen and load the menu
    lcd_splash();
    _delay_ms(250);
    change_state(current_state);

    // Enable interrupts
    sei();

    // Run...
    for (;;);
}