#include <stdbool.h>

#include <string.h>

#include <math.h>

#include "hal/hal.h"

#include "hal/flash.h"

#include "common.h"

#include "twi.h"

#include "oled.h"

#include "oled_defs.h"

#include "datasources.h"

#define DATA_BUFFER_SIZE 100

typedef struct OledDisplaySettings

{

    OledCursorPosition cursorPosition;

    FontSize fontSize;

    WrappingStyle wrappingStyle;

} OledDisplaySettings;

typedef struct OledCharacterWriteMetadata

{

    FlashChar flashChar;

    uint8_t columnStart;

    uint8_t columnEnd;

    uint8_t pageStart;

    uint8_t pageEnd;

} OledCharacterWriteMetadata;

static OledDisplaySettings oled_settings = 

{

    .cursorPosition.column = 0,

    .cursorPosition.row = 0,

    .fontSize = FONT_SMALL,

    .wrappingStyle = WRAP_NEXTLINE

};

typedef enum OLEDState

{

    OLED_IDLE,

    OLED_INIT,

    OLED_CLEAR_ADDR,

    OLED_CLEAR_DATA,

    OLED_WRITE_ADDR,

    OLED_WRITE_DATA

} OLEDState;

typedef struct OLEDContext

{

    OLEDState state;

    OLEDState requestedState;

    char string[DATA_BUFFER_SIZE];

    uint8_t index;

    OledCharacterWriteMetadata writeMetadata;

    uint8_t data[DATA_BUFFER_SIZE];

    ram_ctx_t ramContext;

    nop_ctx_t nopContext;

} OLEDContext;

static OLEDContext oled =

{

    .state = OLED_INIT,

    .requestedState = OLED_IDLE,

    .index = 0

};

void oled_init(void) 

{

    oled.ramContext.data = oled.data;

    uint8_t command[] = 

    {

        COMMAND_MODE,

        DISPLAY_OFF,

        CLOCK_DIV_RATIO, CLOCK_DIV_RATIO_RESET,

        MULTIPLEX_RATIO, MULTIPLEX_32_ROWS,

        DISPLAY_OFFSET, ZERO_BYTE,

        DISPLAY_START_LINE, ZERO_BYTE,

        CHARGE_PUMP, CHARGE_PUMP_ON,

        ADDRESSING_MODE, ADDRESSING_HORIZONTAL,

        HORIZONTAL_ORIENTATION_FLIPPED,

        VERTICAL_ORIENTATION_FLIPPED,

        COM_PINS, COM_32_ROWS,

        CONTRAST_CONTROL, CONTRAST_HIGH,

        PRE_CHARGE_PERIOD, PRE_CHARGE_DEFAULT,

        VCOMH, VCOMH_DEFAULT,

        DISPLAY_FROM_RAM,

        DISPLAY_NORMAL,

        DISPLAY_ON

    };

    memcpy(oled.data, command, sizeof(command));

    twi_write_to_slave(SSD_OLED_ADDRESS, &oled.ramContext, ram_read, sizeof(command));

}

OledCharacterWriteMetadata oled_get_display_configuration(char character)

{

    OledCharacterWriteMetadata config;

    config.flashChar.character = character;

    config.flashChar.fontSize = oled_settings.fontSize;

    flash_get_char_image(&config.flashChar);

    config.columnStart = (oled_settings.cursorPosition.column*config.flashChar.fontMetaData->dimension);

    config.columnEnd = config.columnStart + config.flashChar.fontMetaData->dimension - 1;

    config.pageStart = oled_settings.cursorPosition.row;

    config.pageEnd = config.pageStart + config.flashChar.fontMetaData->pagesPerRow - 1;

    return config;

}

void oled_send_cursor(uint8_t columnStart, uint8_t columnEnd, uint8_t pageStart, uint8_t pageEnd) 

{

    uint8_t cursorCommand[] = 

    {

        COMMAND_MODE,

        COLUMN_SELECTOR, columnStart, columnEnd,

        PAGE_SELECTOR, pageStart, pageEnd

    };

    memcpy(oled.data, cursorCommand, sizeof(cursorCommand));

    twi_write_to_slave(SSD_OLED_ADDRESS, &oled.ramContext, ram_read, sizeof(cursorCommand));

}

void oled_write_character(OledCharacterWriteMetadata config) 

{

    oled.data[0] = DATA_MODE;

    memcpy(oled.data + 1, config.flashChar.data, config.flashChar.fontMetaData->dataLength);

    twi_write_to_slave(SSD_OLED_ADDRESS, &oled.ramContext, ram_read, config.flashChar.fontMetaData->dataLength+1);

}

void oled_put_character(char character)

{

    OledCharacterWriteMetadata config = oled_get_display_configuration(character);

    oled_send_cursor(

        config.columnStart, config.columnEnd, 

        config.pageStart, config.pageEnd);

    oled_write_character(config);

}

void oled_set_cursor(OledCursorPosition cursorPosition)

{

    oled_settings.cursorPosition = cursorPosition;

}

void oled_set_font_size(FontSize fontSize)

{

    oled_settings.fontSize = fontSize;

}

void oled_set_wrapping_style(WrappingStyle wrappingStyle)

{

    oled_settings.wrappingStyle = wrappingStyle;

}

void oled_set_invert(bool invert)

{

    oled.ramContext.invert = invert;

}

void oled_clear_screen(void) 

{

    oled.nopContext.firstByte = DATA_MODE;

    twi_write_to_slave(SSD_OLED_ADDRESS, &oled.nopContext, nop_read, OLED_BYTE_SIZE+1);

}

void oled_clear_cursor(void)

{

    oled_put_character(' ');

}

void oled_fill_cursor(void)

{

    oled_set_invert(true);

    oled_put_character(' ');

    oled_set_invert(false);

}

void oled_write(char *string, uint16_t stringLength)

{

    oled.index = 0;

    memcpy(oled.string, string, stringLength);

    if(oled.string[oled.index] == STRING_END)

    {

        return;

    }

    oled.requestedState = OLED_WRITE_ADDR;

}

bool oled_update(void) 

{

    if(twi_busy)

    {

        return true;

    }

    switch (oled.state)

    {

        case OLED_IDLE:

            if(oled.requestedState != OLED_IDLE)

            {

                oled.state = oled.requestedState;

                oled.requestedState = OLED_IDLE;

            }

            return false;

            break;

        case OLED_INIT:

            oled_init();

            oled.state = OLED_CLEAR_ADDR;

            break;

        case OLED_CLEAR_ADDR:

            oled_send_cursor(ZERO_BYTE, OLED_LAST_COLUMN, ZERO_BYTE, OLED_LAST_ROW);

            oled.state = OLED_CLEAR_DATA;

            break;

        case OLED_CLEAR_DATA:

            oled_clear_screen();

            oled.state = OLED_IDLE;

            break;

        case OLED_WRITE_ADDR:

            oled.writeMetadata = oled_get_display_configuration(oled.string[oled.index]);

            oled_send_cursor(

                oled.writeMetadata.columnStart, oled.writeMetadata.columnEnd, 

                oled.writeMetadata.pageStart, oled.writeMetadata.pageEnd);

            oled.state = OLED_WRITE_DATA;

            break;

        case OLED_WRITE_DATA:

            oled_write_character(oled.writeMetadata);

            oled_settings.cursorPosition.column++;

            oled.index++;

            if(oled.string[oled.index] == STRING_END)

            {

                oled.state = OLED_IDLE;

                break;

            }

            oled.state = OLED_WRITE_ADDR;

            break;

        default:

            break;

    }

    return true;

}