/*
 * Copyright (C) 2016 Freie Universität Berlin
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */

/**
 * @ingroup     boards_calliope-mini
 * @{
 *
 * @file
 * @brief       Calliope mini specific LED matrix handling
 *
 * @author      Hauke Petersen <hauke.petersen@fu-berlin.de>
 *
 * @}
 */

#include <string.h>
#include "xtimer.h"

#include "board.h"
#include "mini.h"
#include "mineplex.h"
#include "periph/gpio.h"
#include "periph/timer.h"

#define ENABLE_DEBUG        (0)
#include "debug.h"

/**
 * @brief   The visible number of rows and columns of the LED matrix
 */
#define ROWS                MINI_MATRIX_ROWS
#define COLS                MINI_MATRIX_COLS

/**
 * @brief   The electrical number of rows and columns
 */
#define ROWS_HW             (3)
#define COLS_HW             (9)

/**
 * @brief   The refresh rate used for drawing the contents
 *
 * We want a refresh rate of at least 50Hz (->20ms), so the LEDs do not flicker.
 */
#define REFRESH             (6000)      /* 6ms * 3 rows -> ~55Hz */

/**
 * @brief   GPIO pins driving the rows
 */
static const gpio_t rows[ROWS_HW] = {
    MINI_LED_ROW1,
    MINI_LED_ROW2,
    MINI_LED_ROW3
};

/**
 * @brief   GPIO pins driving the columns
 */
static const gpio_t cols[COLS_HW] = {
    MINI_LED_COL1,
    MINI_LED_COL2,
    MINI_LED_COL3,
    MINI_LED_COL4,
    MINI_LED_COL5,
    MINI_LED_COL6,
    MINI_LED_COL7,
    MINI_LED_COL8,
    MINI_LED_COL9,
};

/**
 * @brief   Map electrical layout to visible layout
 *
 * The electrical layout of the matrix is different than the visible layout
 * (3x9 -> 5x5). This array maps from the visible 5 by 5 layout to the actual
 * 3 by 9 layout used by the hardware.
 */
static const uint8_t pixmap[5][5] = {
    {  0, 12,  1, 13,  2 },
    { 21, 22, 23, 24, 25 },
    { 10,  8, 11, 26,  9 },
    {  7,  6,  5,  4,  3 },
    { 20, 15, 18, 14, 19 }
};

/**
 * @brief   Buffer holding the current 'image' that is displayed
 */
static uint8_t framebuf[ROWS_HW * COLS_HW] = { 0 };

/**
 * @brief   Internal counter to keep track of which row needs to be refreshed
 *          next
 */
static unsigned cur_row = 0;

/**
 * @brief   Write a Mineplex encoded character into the given buffer
 *
 * @param[in]  c    character to write
 * @param[out] buf  buffer to write the encoded character into, MUST be able to
 *                  hold 25 byte
 */
static void char2buf(char c, uint8_t *buf)
{
    const uint8_t *raw = mineplex_char(c);

    /* set each row */
    for (int row = 0; row < ROWS; row++) {
        for (int col = 0; col < COLS; col++) {
            buf[(row * COLS) + col] = (raw[row] & (1 << col));
        }
    }
}

/**
 * @brief   Shift out and replace an image with the next, column by column
 *
 * @param[in|out] cur   current 'image', will be overwritten
 * @param[in] next      image to shift in
 * @param[in] delay     delay between each column
 */
static void shift_next(uint8_t *cur, const uint8_t *next, uint32_t delay)
{
    for (int i = 0; i < COLS; i++) {
        for (int r = 0; r < ROWS; r++) {
            for (int c = 0; c < (COLS - 1); c++) {
                cur[(r * COLS) + c] = cur[(r * COLS) + c + 1];
            }
            cur[(r * COLS) + COLS - 1] = next[(r * COLS) + i];
        }
        mini_matrix_set_raw((uint8_t *)cur);
        xtimer_usleep(delay);
    }
}

static void refresh(void *arg, int channel)
{
    (void)arg;
    (void)channel;

    /* set next refresh */
    timer_set(TIMER_DEV(2), 0, REFRESH);

    /* disable current row */
    gpio_clear(rows[cur_row]);
    /* goto next row */
    cur_row = ((++cur_row) < ROWS_HW) ? cur_row : 0;
    /* setup columns */
    int base = (COLS_HW * cur_row);
    for (int i = 0; i < COLS_HW; i++) {
        gpio_write(cols[i], !(framebuf[base + i]));
    }
    /* and finally enable the new row */
    gpio_set(rows[cur_row]);
}

void mini_matrix_init(void)
{
    /* initialize rows */
    for (int i = 0; i < ROWS_HW; i++) {
        gpio_init(rows[i], GPIO_OUT);
        gpio_clear(rows[i]);
    }
    /* initialize columns */
    for (int i = 0; i < COLS_HW; i++) {
        gpio_init(cols[i], GPIO_OUT);
        gpio_set(cols[i]);
    }
    /* and finally initialize and start the refresh timer */
    timer_init(TIMER_DEV(2), 1000000, refresh, NULL);
    timer_set(TIMER_DEV(2), 0, REFRESH);
}

void mini_matrix_on(uint8_t row, uint8_t col)
{
    if ((row >= 5) || (col >= 5)) {
        return;
    }

    framebuf[pixmap[row][col]] = 0x01;
}

void mini_matrix_off(uint8_t row, uint8_t col)
{
    if ((row >= 5) || (col >= 5)) {
        return;
    }

    framebuf[pixmap[row][col]] = 0x00;
}

void mini_matrix_set_raw(const uint8_t *buf) {
    for (int row = 0; row < ROWS; row++) {
        for (int col = 0; col < COLS; col++) {
            framebuf[pixmap[row][col]] = buf[(row * COLS) + col];
        }
    }
}

void mini_matrix_set_char(char c)
{
    uint8_t buf[ROWS * COLS];

    char2buf(c, buf);
    mini_matrix_set_raw(buf);
}

void mini_matrix_shift_str(const char *str, uint32_t delay)
{
    uint8_t curbuf[ROWS][COLS];
    uint8_t newbuf[ROWS][COLS];

    char2buf(' ', (uint8_t *)curbuf);
    mini_matrix_set_raw((uint8_t *)curbuf);
    while (*str) {
        char2buf(*str++, (uint8_t *)newbuf);
        shift_next((uint8_t *)curbuf, (uint8_t *)newbuf, delay);
    }
    char2buf(' ', (uint8_t *)newbuf);
    shift_next((uint8_t *)curbuf, (uint8_t *)newbuf, delay);
}