#include "main.h"
#include "printf.h"
#include "bitmap_fonts.h"
#include "bitmap_disp_buttons.h"
#include "bitmap_wave.h"
#include "tim.h"
#include "SEGGER_RTT.h"

#include "disp_layout.h"

#define ABS(x) ((x) < 0 ? -(x) : (x))
#define MAX(x, y) (((x) > (y)) ? (x) : (y))
#define MIN(x, y) (((x) < (y)) ? (x) : (y))

#define SEVEN_DIGIT 7
#define FOUR_DIGIT 3
#define THREE_DIGIT 2

const uint8_t btn_pos_x[DISP_BTN_MAX] = {0, 26, 52, 78, 104};
const uint8_t marker_pos_7dig[SEVEN_DIGIT] = {76, 84, 90, 96, 105, 111, 118};
const uint8_t marker_pos_4dig[FOUR_DIGIT] = {82, 94, 100};
const uint8_t marker_pos_3dig[THREE_DIGIT] = {82, 88};

// clang-format off
const GFX_bitmap_t marker_down = {05, 03, (uint8_t[]){0x01,0x03,0x07,0x03,0x01}};// res: 5x3(8)   - 5 bytes
const GFX_bitmap_t marker_up = {05, 03, (uint8_t[]){0x04,0x06,0x07,0x06,0x04}}; // res: 5x3(8)   - 5 bytes

// clang-format on

static void _drawFreqValue(GFX_display_t *disp, uint32_t freq, uint8_t pos_y)
{
    uint8_t data[8];
    snprintf((char *)data, 8, "%07u", freq);
    DISP_writeString(disp, &font5x7Info, (uint8_t[]){data[0], 0}, 76, pos_y, BM_NORMAL);
    DISP_writeString(disp, &font5x7Info, (uint8_t[]){data[1], data[2], data[3], 0}, 84, pos_y, BM_NORMAL);
    DISP_writeString(disp, &font5x7Info, (uint8_t[]){data[4], data[5], data[6], 0}, 105, pos_y, BM_NORMAL);
}

static void _drawAmplValue(GFX_display_t *disp, uint16_t ampl, uint8_t pos_y)
{
    uint8_t data[8];
    snprintf((char *)data, 8, "%02d.%02d V", ampl / 100, ampl % 100);
    DISP_writeString(disp, &font5x7Info, data, 76, pos_y, BM_NORMAL);
}

static void _drawOffsValue(GFX_display_t *disp, int16_t offs, uint8_t pos_y)
{
    uint8_t data[8];
    snprintf((char *)data, 8, "%+01d.%02d V", offs / 100, ABS(offs) % 100);
    if (offs < 0)
    {
        data[0] = '-';
    }
    DISP_writeString(disp, &font5x7Info, data, 76, pos_y, BM_NORMAL);
}

static void _drawPhasValue(GFX_display_t *disp, uint16_t phase, uint8_t pos_y)
{
    uint8_t data[8];
    snprintf((char *)data, 8, "%03u'", phase);
    DISP_writeString(disp, &font5x7Info, data, 76, pos_y, BM_NORMAL);
}

// static void _drawDutyValue(GFX_display_t *disp, uint8_t duty, uint8_t pos_y)
// {
//     uint8_t data[8];
//     snprintf((char *)data, 8, "%03u%%", duty);
//     DISP_writeString(disp, &font5x7Info, data, 76, pos_y, BM_NORMAL);
// }

static void _blinkButtons(GFX_display_t *disp, APP_data_t *app_data)
{
    // input: display buttons, invert
    BITMAP_buttonName_t bitmap_idx;
    for (LAY_dispBtn_t btn_idx = DISP_BTN_1; btn_idx < DISP_BTN_MAX; btn_idx++)
    {
        if (!(app_data->isButtonBlink & (1 << btn_idx)))
        {
            continue;
        }

        bitmap_idx = CTRL_getBitmapName(btn_idx);
        if (app_data->timer_blink[btn_idx] > 0)
        {
            DISP_drawBitmap(disp, &bitmap_btnBottom[bitmap_idx + 1], btn_pos_x[btn_idx], 53, BM_NORMAL);
            app_data->timer_blink[btn_idx]--;
        }
        else
        {
            DISP_drawBitmap(disp, &bitmap_btnBottom[bitmap_idx], btn_pos_x[btn_idx], 53, BM_NORMAL);
            app_data->isButtonBlink &= ~(1 << btn_idx);
        }
    }
}

static void _drawButtons(GFX_display_t *disp, APP_data_t *app_data)
{
    // input: display buttons, invert
    BITMAP_buttonName_t bitmap_idx;
    DISP_clearRegion(disp, 0, 53, disp->width, 11);

    for (LAY_dispBtn_t btn_idx = DISP_BTN_1; btn_idx < DISP_BTN_MAX; btn_idx++)
    {
        bitmap_idx = CTRL_getBitmapName(btn_idx);
        DISP_drawBitmap(disp, &bitmap_btnBottom[bitmap_idx], btn_pos_x[btn_idx], 53, BM_NORMAL);
    }

    app_data->isButtonChange = 0;
}

static uint8_t _calcMarkerPos(uint32_t value, uint32_t max)
{
    return ((61 * value) + (max / 2)) / max;
    // return (value < 0) ? ((62 * value) - (max / 2)) / max : ((62 * value) + (max / 2)) / max;
}

static uint8_t _calcPhaseShiftInPxl(uint32_t value, uint32_t max)
{
    return ((48 * value) + (max / 2)) / max;
}

static int32_t _calcVerticalShiftInPxl(int16_t value, int16_t max)
{
    return (value < 0) ? ((12 * value) - (max / 2)) / max : ((12 * value) + (max / 2)) / max;
}

static uint8_t _sizeOfCharArray(char *array)
{
    uint8_t size = 0;
    while (*array++)
    {
        size++;
    }
    return size;
}

static void _drawMeterHelper(GFX_display_t *disp, char *min, char *max, uint8_t pos)
{
    uint8_t max_size = _sizeOfCharArray(max);
    DISP_drawPixel(disp, 64, 40, GFX_WHITE);
    DISP_drawPixel(disp, 125, 40, GFX_WHITE);
    DISP_drawHorizontalLine(disp, 64, 41, 62, GFX_WHITE);
    DISP_writeString(disp, &font5x7Info, (uint8_t *)min, 62, 43, BM_NORMAL);
    DISP_writeString(disp, &font5x7Info, (uint8_t *)max, 127 - (6 * max_size), 43, BM_NORMAL);
    // marker 0% - 62, 100% - 123
    DISP_drawBitmap(disp, &marker_down, 62 + pos, 35, BM_NORMAL);
}

static void _drawFreqValueHelper(GFX_display_t *disp, uint32_t freq, uint8_t focus_digit)
{
    DISP_clearRegion(disp, 64, 13, 66, 40);
    DISP_writeString(disp, &font5x7Info, (uint8_t *)"F:", 64, 20, BM_NORMAL);
    _drawFreqValue(disp, freq, 20);
    DISP_drawBitmap(disp, &marker_down, marker_pos_7dig[(SEVEN_DIGIT - 1) - focus_digit], 15, BM_NORMAL);
}

static void _drawAmplValueHelper(GFX_display_t *disp, uint32_t ampl, uint8_t focus_digit)
{
    DISP_clearRegion(disp, 64, 13, 66, 40);
    DISP_writeString(disp, &font5x7Info, (uint8_t *)"A:", 64, 20, BM_NORMAL);
    _drawAmplValue(disp, ampl, 20);
    DISP_drawBitmap(disp, &marker_down, marker_pos_4dig[(FOUR_DIGIT - 1) - focus_digit], 15, BM_NORMAL);
}

static void _drawOffsValueHelper(GFX_display_t *disp, int32_t offs, uint8_t focus_digit)
{
    DISP_clearRegion(disp, 64, 13, 66, 40);
    DISP_writeString(disp, &font5x7Info, (uint8_t *)"O:", 64, 20, BM_NORMAL);
    _drawOffsValue(disp, offs, 20);
    DISP_drawBitmap(disp, &marker_down, marker_pos_4dig[(FOUR_DIGIT - 1) - focus_digit], 15, BM_NORMAL);
}

static void _drawPhaseValueHelper(GFX_display_t *disp, uint32_t phase, uint8_t focus_digit)
{
    DISP_clearRegion(disp, 64, 13, 66, 40);
    DISP_writeString(disp, &font5x7Info, (uint8_t *)"P:", 64, 20, BM_NORMAL);
    _drawPhasValue(disp, phase, 20);
    DISP_drawBitmap(disp, &marker_down, marker_pos_3dig[(THREE_DIGIT - 1) - focus_digit], 15, BM_NORMAL);
}

static void _drawFuncGenValues(GFX_display_t *disp, APP_data_t *app_data)
{
    GEN_fg_t *fun_gen = (GEN_fg_t *)app_data->generator;
    switch (app_data->curr_state_lay)
    {
    case LAY_FREQ:
        _drawFreqValueHelper(disp, fun_gen->frequency, app_data->freq_focus_digit);
        _drawMeterHelper(disp, "1", "1M", _calcMarkerPos(fun_gen->frequency, MAX_FREQ));
        break;
    case LAY_AMPL:
        _drawAmplValueHelper(disp, fun_gen->amplitude, app_data->ampl_focus_digit);
        _drawMeterHelper(disp, "0V", "5V", _calcMarkerPos(fun_gen->amplitude, MAX_VOLT_POS));
        break;
    case LAY_OFFS:
        _drawOffsValueHelper(disp, fun_gen->offset, app_data->offs_focus_digit);
        _drawMeterHelper(disp, "-5V", "+5V", _calcMarkerPos(MAX_VOLT_POS + fun_gen->offset, MAX_VOLT_POS * 2));
        break;
    case LAY_PHAS:
        _drawPhaseValueHelper(disp, fun_gen->phase, app_data->phas_focus_digit);
        _drawMeterHelper(disp, "0", "360", _calcMarkerPos(fun_gen->phase, MAX_PHAS));
        break;
    case LAY_MAIN:
        DISP_clearRegion(disp, 62, 13, 66, 40);
        DISP_writeString(disp, &font5x7Info, (uint8_t *)"F:", 64, 13, BM_NORMAL);
        DISP_writeString(disp, &font5x7Info, (uint8_t *)"A:", 64, 23, BM_NORMAL);
        DISP_writeString(disp, &font5x7Info, (uint8_t *)"O:", 64, 33, BM_NORMAL);
        DISP_writeString(disp, &font5x7Info, (uint8_t *)"P:", 64, 43, BM_NORMAL);

        _drawFreqValue(disp, fun_gen->frequency, 13);
        _drawAmplValue(disp, fun_gen->amplitude, 23);
        _drawOffsValue(disp, fun_gen->offset, 33);
        _drawPhasValue(disp, fun_gen->phase, 43);
        break;

    default:
        // focus
        break;
    }
}

static void _drawPwmGenValues(GFX_display_t *disp, APP_data_t *app_data)
{
    // GEN_pwm_t *pwm_gen = app_data->generator;
}

static void _drawValues(GFX_display_t *disp, APP_data_t *app_data)
{
    // input: frequency(value), amplitiude(value), offset(value), phase(value), duty(value), invert(info), position(value)
    switch (app_data->curr_gen_type)
    {
    case GEN_FG_TYPE:
        _drawFuncGenValues(disp, app_data);
        break;
    case GEN_PWM_TYPE:
        _drawPwmGenValues(disp, app_data);
        break;

    default:
        break;
    }

    app_data->isValueChange = 0;
}

static void _drawOffsetLine(GFX_display_t *disp, int16_t offs, uint32_t ampl)
{
    int8_t vert_shift = _calcVerticalShiftInPxl(offs, ampl);

    vert_shift = MIN(vert_shift, 20);
    vert_shift = MAX(vert_shift, -19);

    ULOG_TRACE("<OFFSLINE> shift: %i", vert_shift);
    DISP_drawHorizontalLine(disp, 2, 31 + vert_shift, 57, GFX_WHITE);
}

// static void _drawMaxAmpLine(GFX_display_t *disp, int16_t offs, uint32_t ampl)
// {
//     DISP_drawHorizontalLine(disp, 2, 12, 57, GFX_WHITE);
//     DISP_drawBitmap(disp, &marker_up, 0, 13, BM_NORMAL);

//     DISP_drawHorizontalLine(disp, 2, 51, 57, GFX_WHITE);
//     DISP_drawBitmap(disp, &marker_down, 0, 48, BM_NORMAL);
// }

static void _drawFunGenGraph(GFX_display_t *disp, APP_data_t *app_data)
{
    GEN_fg_t *fun_gen = (GEN_fg_t *)app_data->generator;
    DISP_clearRegion(disp, 3, 12, 57, 40);

    switch (fun_gen->wave)
    {
    case GEN_SIN:
        DISP_drawBitmapShift(disp, &wave[WAVE_SIN], 6, 19, _calcPhaseShiftInPxl(fun_gen->phase, 360), BM_NORMAL);
        break;
    case GEN_TRI:
        DISP_drawBitmapShift(disp, &wave[WAVE_TRI], 6, 19, _calcPhaseShiftInPxl(fun_gen->phase, 360), BM_NORMAL);
        break;
    case GEN_SQR:
        DISP_drawBitmapShift(disp, &wave[WAVE_SQR], 6, 19, _calcPhaseShiftInPxl(fun_gen->phase, 360), BM_NORMAL);
        break;
    default:
        break;
    }

    _drawOffsetLine(disp, fun_gen->offset, fun_gen->amplitude);
    // _drawMaxAmpLine(disp, fun_gen->offset, fun_gen->amplitude);
}
static void _drawPwmGenGraph(GFX_display_t *disp, APP_data_t *app_data)
{
}

static void _drawGraph(GFX_display_t *disp, APP_data_t *app_data)
{
    // input: graph type(sin, triangle, squere, pwm), frequency(info), amplitiude(value), offset(value), phase(value), invert(pwm),
    DISP_drawVerticalLine(disp, 2, 12, 40, GFX_WHITE);

    switch (app_data->curr_gen_type)
    {
    case GEN_FG_TYPE:
        _drawFunGenGraph(disp, app_data);
        break;
    case GEN_PWM_TYPE:
        _drawPwmGenGraph(disp, app_data);
        break;

    default:
        break;
    }

    app_data->isGraphChange = 0;
}

static void _drawChannels(GFX_display_t *disp, APP_data_t *app_data)
{
    // input: active channel
    DISP_writeString(disp, &font5x7Info, (uint8_t *)"CH1", 2, 1, CHANNEL1 == app_data->curr_channel ? BM_INVERSE : BM_NORMAL);
    DISP_writeString(disp, &font5x7Info, (uint8_t *)"CH2", 23, 2, CHANNEL2 == app_data->curr_channel ? BM_INVERSE : BM_NORMAL);
    DISP_writeString(disp, &font5x7Info, (uint8_t *)"CH3", 44, 2, CHANNEL3 == app_data->curr_channel ? BM_INVERSE : BM_NORMAL);
    DISP_writeString(disp, &font5x7Info, (uint8_t *)"CH4", 65, 2, CHANNEL4 == app_data->curr_channel ? BM_INVERSE : BM_NORMAL);
    DISP_writeString(disp, &font5x7Info, (uint8_t *)"CH5", 86, 2, CHANNEL5 == app_data->curr_channel ? BM_INVERSE : BM_NORMAL);
    DISP_writeString(disp, &font5x7Info, (uint8_t *)"CH6", 107, 2, CHANNEL6 == app_data->curr_channel ? BM_INVERSE : BM_NORMAL);
    DISP_drawHorizontalLine(disp, 0, 10, 127, GFX_WHITE);

    app_data->isChannelChange = 0;
}

void LAY_drawDisplayLayout(GFX_display_t *disp, APP_data_t *app_data)
{
    if (app_data->isChannelChange)
        _drawChannels(disp, app_data);

    if (app_data->isValueChange)
        _drawValues(disp, app_data);

    if (app_data->isGraphChange)
        _drawGraph(disp, app_data);

    if (app_data->isButtonChange)
        _drawButtons(disp, app_data);

    if (app_data->isButtonBlink)
        _blinkButtons(disp, app_data);
}