/*
 * Copyright (C) 2017 HAW Hamburg
 *
 * 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     drivers_hd44780
 *
 * @{
 * @file
 * @brief       Driver for the HD44780 LCD
 *
 * @note        The display is also known as LCM1602C from Arduino kits
 *
 * @author      Sebastian Meiling <s@mlng.net>
 *
 * @}
 */

#include <assert.h>
#include <string.h>

#include "log.h"
#include "periph/gpio.h"
#include "xtimer.h"

#include "hd44780.h"
#include "hd44780_internal.h"

static inline void _command(const hd44780_t *dev, uint8_t value);
static void _pulse(const hd44780_t *dev);
static void _send(const hd44780_t *dev, uint8_t value, uint8_t mode);
static void _write_bits(const hd44780_t *dev, uint8_t bits, uint8_t value);

/**
 * @brief   Send a command to the display
 *
 * @param[in]  dev          device descriptor of display to initialize
 * @param[in]  value        the command
 */
static inline void _command(const hd44780_t *dev, uint8_t value)
{
    _send(dev, value, HD44780_OFF);
}

/**
 * @brief   Send a pulse to the display to enable new state
 *
 * @param[in]  dev          device descriptor of display to initialize
 */
static void _pulse(const hd44780_t *dev)
{
    gpio_clear(dev->p.enable);
    xtimer_usleep(HD44780_PULSE_WAIT_SHORT);
    gpio_set(dev->p.enable);
    xtimer_usleep(HD44780_PULSE_WAIT_SHORT);
    gpio_clear(dev->p.enable);
    xtimer_usleep(HD44780_PULSE_WAIT_LONG);
}

/**
 * @brief   Send a data value to the display
 *
 * @param[in]  dev          device descriptor of display to initialize
 * @param[in]  value        the data value, either char or command
 * @param[in]  state        send state, to distinguish chars and commands
 */
static void _send(const hd44780_t *dev, uint8_t value, hd44780_state_t state)
{
    (state == HD44780_ON) ? gpio_set(dev->p.rs) : gpio_clear(dev->p.rs);
    /* if RW pin is available, set it to LOW */
    if (dev->p.rw != HD44780_RW_OFF) {
        gpio_clear(dev->p.rw);
    }
    /* write data in 8Bit or 4Bit mode */
    if (dev->flag & HD44780_8BITMODE) {
        _write_bits(dev, 8, value);
    }
    else {
        _write_bits(dev, 4, value>>4);
        _write_bits(dev, 4, value);
    }
}

static void _write_bits(const hd44780_t *dev, uint8_t bits, uint8_t value)
{
    for (unsigned i = 0; i < bits; ++i) {
        if ((value >> i) & 0x01) {
            gpio_set(dev->p.data[i]);
        }
        else {
            gpio_clear(dev->p.data[i]);
        }
    }
    _pulse(dev);
}

int hd44780_init(hd44780_t *dev, const hd44780_params_t *params)
{
    /* write config params to device descriptor */
    memcpy(&dev->p, params, sizeof(hd44780_params_t));
    /* verify cols and rows */
    if ((dev->p.cols > HD44780_MAX_COLS) || (dev->p.rows > HD44780_MAX_ROWS)
                                         || (dev->p.rows * dev->p.cols > 80)) {
        LOG_ERROR("hd44780_init: invalid LCD size!\n");
        return -1;
    }
    uint8_t count_pins = 0;
    /* check which pins are used */
    for (unsigned i = 0; i < HD44780_MAX_PINS; ++i) {
        if (dev->p.data[i] != HD44780_RW_OFF) {
            ++count_pins;
        }
    }
    /* set mode depending on configured pins */
    if (count_pins < HD44780_MAX_PINS) {
        dev->flag |= HD44780_4BITMODE;
    }
    else {
        dev->flag |= HD44780_8BITMODE;
    }
    /* set flag for 1 or 2 row mode, 4 rows are 2 rows split half */
    if (dev->p.rows > 1) {
        dev->flag |= HD44780_2LINE;
    }
    else {
        dev->flag |= HD44780_1LINE;
    }
    /* set char size to 5x8 as default, 5x10 is hardly used by LCDs anyway */
    dev->flag |= HD44780_5x8DOTS;
    /* calc and set row offsets, depending on number of columns */
    dev->roff[0] = 0x00;
    dev->roff[1] = 0x40;
    dev->roff[2] = 0x00 + dev->p.cols;
    dev->roff[3] = 0x40 + dev->p.cols;

    gpio_init(dev->p.rs, GPIO_OUT);
    /* RW (read/write) of LCD not required, set it to HD44780_RW_OFF (255) */
    if (dev->p.rw != HD44780_RW_OFF) {
        gpio_init(dev->p.rw, GPIO_OUT);
    }
    gpio_init(dev->p.enable, GPIO_OUT);
    /* configure all data pins as output */
    for (int i = 0; i < ((dev->flag & HD44780_8BITMODE) ? 8 : 4); ++i) {
        gpio_init(dev->p.data[i], GPIO_OUT);
    }
    /* see hitachi HD44780 datasheet pages 45/46 for init specs */
    xtimer_usleep(HD44780_INIT_WAIT_XXL);
    gpio_clear(dev->p.rs);
    gpio_clear(dev->p.enable);
    if (dev->p.rw != HD44780_RW_OFF) {
        gpio_clear(dev->p.rw);
    }
    /* put the LCD into 4 bit or 8 bit mode */
    if (!(dev->flag & HD44780_8BITMODE)) {
        /* see hitachi HD44780 datasheet figure 24, pg 46 */
        _write_bits(dev, 4, 0x03);
        xtimer_usleep(HD44780_INIT_WAIT_LONG);

        _write_bits(dev, 4, 0x03);
        xtimer_usleep(HD44780_INIT_WAIT_LONG);

        _write_bits(dev, 4, 0x03);
        xtimer_usleep(HD44780_INIT_WAIT_SHORT);

        _write_bits(dev, 4, 0x02);
    } else {
        /* see hitachi HD44780 datasheet page 45 figure 23 */
        _command(dev, HD44780_FUNCTIONSET | dev->flag);
        xtimer_usleep(HD44780_INIT_WAIT_LONG);  // wait more than 4.1ms

        _command(dev, HD44780_FUNCTIONSET | dev->flag);
        xtimer_usleep(HD44780_INIT_WAIT_SHORT);

        _command(dev, HD44780_FUNCTIONSET | dev->flag);
    }
    _command(dev, HD44780_FUNCTIONSET | dev->flag);

    /* turn the display on with no cursor or blinking default, and clear */
    dev->ctrl = HD44780_DISPLAYON | HD44780_CURSOROFF | HD44780_BLINKOFF;
    hd44780_display(dev, HD44780_ON);
    hd44780_clear(dev);
    /* Initialize to default text direction for western languages */
    dev->mode = HD44780_ENTRYLEFT | HD44780_ENTRYSHIFTDECREMENT;
    _command(dev, HD44780_ENTRYMODESET | dev->mode);

    return 0;
}

void hd44780_clear(const hd44780_t *dev)
{
    _command(dev, HD44780_CLEARDISPLAY);
    xtimer_usleep(HD44780_CMD_WAIT);
}

void hd44780_home(const hd44780_t *dev)
{
    _command(dev, HD44780_RETURNHOME);
    xtimer_usleep(HD44780_CMD_WAIT);
}

void hd44780_set_cursor(const hd44780_t *dev, uint8_t col, uint8_t row)
{
    if (row >= dev->p.rows) {
        row = dev->p.rows - 1;
    }
    _command(dev, HD44780_SETDDRAMADDR | (col + dev->roff[row]));
}

void hd44780_display(hd44780_t *dev, hd44780_state_t state)
{
    if (state == HD44780_ON) {
        dev->ctrl |= HD44780_DISPLAYON;
    }
    else {
        dev->ctrl &= ~HD44780_DISPLAYON;
    }
    _command(dev, HD44780_DISPLAYCONTROL | dev->ctrl);
}

void hd44780_cursor(hd44780_t *dev, hd44780_state_t state)
{
    if (state == HD44780_ON) {
        dev->ctrl |= HD44780_CURSORON;
    }
    else {
        dev->ctrl &= ~HD44780_CURSORON;
    }
    _command(dev, HD44780_DISPLAYCONTROL | dev->ctrl);
}

void hd44780_blink(hd44780_t *dev, hd44780_state_t state)
{
    if (state == HD44780_ON) {
        dev->ctrl |= HD44780_BLINKON;
    }
    else {
        dev->ctrl &= ~HD44780_BLINKON;
    }
    _command(dev, HD44780_DISPLAYCONTROL | dev->ctrl);
}

void hd44780_scroll_left(const hd44780_t *dev)
{
    _command(dev, HD44780_CURSORSHIFT | HD44780_DISPLAYMOVE | HD44780_MOVELEFT);
}

void hd44780_scroll_right(const hd44780_t *dev) {
    _command(dev, HD44780_CURSORSHIFT | HD44780_DISPLAYMOVE | HD44780_MOVERIGHT);
}

void hd44780_left2right(hd44780_t *dev)
{
    dev->mode |= HD44780_ENTRYLEFT;
    _command(dev, HD44780_ENTRYMODESET | dev->mode);
}

void hd44780_right2left(hd44780_t *dev)
{
    dev->mode &= ~HD44780_ENTRYLEFT;
    _command(dev, HD44780_ENTRYMODESET | dev->mode);
}

void hd44780_autoscroll(hd44780_t *dev, hd44780_state_t state)
{
    if (state == HD44780_ON) {
        dev->mode |= HD44780_ENTRYSHIFTINCREMENT;
    }
    else {
        dev->mode &= ~HD44780_ENTRYSHIFTINCREMENT;
    }
    _command(dev, HD44780_ENTRYMODESET | dev->mode);
}

void hd44780_create_char(const hd44780_t *dev, uint8_t location, uint8_t charmap[])
{
    location &= 0x7; /* 8 locations (0-7) possible */
    _command(dev, HD44780_SETCGRAMADDR | (location << 3));
    for (unsigned i = 0; i < HD44780_CGRAM_SIZE; ++i) {
        hd44780_write(dev, charmap[i]);
    }
}

void hd44780_write(const hd44780_t *dev, uint8_t value)
{
    _send(dev, value, HD44780_ON);
}

void hd44780_print(const hd44780_t *dev, const char *data )
{
    while (*data != '\0') {
        hd44780_write(dev, *data++);
    }
}