/*
 * .============.
 * // M A K E / \
 * // C++ DEV / \
 * // E A S Y / \/ \
 * ++ ----------. \/\ .
 * \\ \ \ /\ /
 * \\ \ \ /
 * \\ \ \ /
 * -============'
 *
 * Copyright (c) 2018 Hevake and contributors, all rights reserved.
 *
 * This file is part of cpp-tbox (https://github.com/cpp-main/cpp-tbox)
 * Use of this source code is governed by MIT license that can be found
 * in the LICENSE file in the root of the source tree. All contributing
 * project authors may be found in the CONTRIBUTORS.md file in the root
 * of the source tree.
 */
#include "uart.h"

#include <termios.h>
#include <fcntl.h>

#include <tbox/base/log.h>
#include <tbox/util/string_to.h>

#undef MODULE_ID
#define MODULE_ID "tbox.uart"

namespace tbox {
namespace network {

Uart::Uart(event::Loop *wp_loop) :
 buff_fd_(wp_loop)
{ }

bool Uart::initialize(const std::string &dev, const std::string &mode)
{
 if (!openDevice(dev))
 return false;
 return setMode(mode);
}

bool Uart::initialize(const std::string &dev, const Mode &mode)
{
 if (!openDevice(dev))
 return false;
 return setMode(mode);
}

namespace {
int Baudrate2Enum(int baudrate)
{
 switch (baudrate) {
#ifdef B50
 case (50): return B50;
#endif /* B50 */
#ifdef B75
 case (75): return B75;
#endif /* B75 */
#ifdef B110
 case (110): return B110;
#endif /* B110 */
#ifdef B134
 case (134): return B134;
#endif /* B134 */
#ifdef B150
 case (150): return B150;
#endif /* B150 */
#ifdef B200
 case (200): return B200;
#endif /* B200 */
#ifdef B300
 case (300): return B300;
#endif /* B300 */
#ifdef B600
 case (600): return B600;
#endif /* B600 */
#ifdef B1200
 case (1200): return B1200;
#endif /* B1200 */
#ifdef B1800
 case (1800): return B1800;
#endif /* B1800 */
#ifdef B2400
 case (2400): return B2400;
#endif /* B2400 */
#ifdef B4800
 case (4800): return B4800;
#endif /* B4800 */
#ifdef B9600
 case (9600): return B9600;
#endif /* B9600 */
#ifdef B19200
 case (19200): return B19200;
#endif /* B19200 */
#ifdef B38400
 case (38400): return B38400;
#endif /* B38400 */
#ifdef B57600
 case (57600): return B57600;
#endif /* B57600 */
#ifdef B115200
 case (115200): return B115200;
#endif /* B115200 */
#ifdef B230400
 case (230400): return B230400;
#endif /* B230400 */
#ifdef B345600
 case (345600): return B345600;
#endif /* B345600 */
#ifdef B460800
 case (460800): return B460800;
#endif /* B460800 */
#ifdef B500000
 case (500000): return B500000;
#endif /* B500000 */
#ifdef B576000
 case (576000): return B576000;
#endif /* B576000 */
#ifdef B921600
 case (921600): return B921600;
#endif /* B921600 */
#ifdef B1000000
 case (1000000): return B1000000;
#endif /* B1000000 */
#ifdef B1152000
 case (1152000): return B1152000;
#endif /* B1152000 */
#ifdef B1500000
 case (1500000): return B1500000;
#endif /* B1500000 */
#ifdef B2000000
 case (2000000): return B2000000;
#endif /* B2000000 */
#ifdef B2500000
 case (2500000): return B2500000;
#endif /* B2500000 */
#ifdef B3000000
 case (3000000): return B3000000;
#endif /* B3000000 */
#ifdef B3500000
 case (3500000): return B3500000;
#endif /* B3500000 */
#ifdef B4000000
 case (4000000): return B4000000;
#endif /* B4000000 */
 default:
 return -1;
 }
}

}

bool Uart::setMode(const Mode &mode)
{
 if (fd_.get() < 0) {
 LogErr("please open first");
 return false;
 }

 int baud = Baudrate2Enum(mode.baudrate);
 if (baud == -1) {
 LogErr("baudrate %d not support", mode.baudrate);
 return false;
 }

 struct termios options;
 if (tcgetattr(fd_.get(), &options) == -1) {
 LogErr("tcgetattr fail, errno:%d", errno);
 return false;
 }

 options.c_iflag &= ~(INLCR | IGNCR | ICRNL | IUCLC | IXON | IXANY | IXOFF);
 options.c_iflag |= IGNBRK | IGNPAR;
 options.c_oflag &= ~(OPOST | OLCUC | ONLCR | OCRNL | ONOCR | ONLRET);
 options.c_cflag &= ~(CRTSCTS);
 options.c_cflag |= CREAD | HUPCL | CLOCAL;
 options.c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN);

 options.c_cflag &= ~CSIZE;
 if (mode.data_bit == DataBit::k8bits)
 options.c_cflag |= CS8;
 else
 options.c_cflag |= CS7;

 options.c_cflag &= ~PARENB;
 options.c_iflag &= ~(INPCK | ISTRIP);
 if (mode.parity != ParityEnd::kNoEnd) {
 options.c_cflag |= PARENB;
 options.c_iflag |= (INPCK | ISTRIP);
 if (mode.parity == ParityEnd::kOddEnd)
 options.c_cflag |= PARODD;
 else
 options.c_cflag &= ~PARODD;
 }

 if (mode.stop_bit == StopBit::k1bits)
 options.c_cflag &= ~CSTOPB;
 else
 options.c_cflag |= CSTOPB;

 cfsetispeed(&options, baud);
 cfsetospeed(&options, baud);

 if (tcsetattr(fd_.get(), TCSAFLUSH, &options) == -1) {
 LogErr("tcsetattr fail, errno:%d", errno);
 return false;
 }

 return true;
}

//! 解析如:"115200 8n1" 这样的字串
bool Uart::setMode(const std::string &mode_str)
{
 using namespace std;

 if (mode_str.empty()) {
 LogErr("mode_str is empty");
 return false;
 }

 size_t pos = mode_str.find_first_of(' ', 0);
 if ((pos == string::npos) || ((pos + 4) < mode_str.size())) {
 LogErr("mode_str format invalid");
 return false;
 }

 //! 提取各字段
 string baudrate_str = mode_str.substr(0, pos);
 char data_bits_ch = mode_str[pos + 1];
 char parity_ch = toupper(mode_str[pos + 2]);
 char stop_bits_ch = mode_str[pos + 3];

 Mode mode;

 //! 波特率
 if (!util::StringTo(baudrate_str, mode.baudrate)) {
 LogErr("baudrate must be number");
 return false;
 }

 //! 数据位
 if (data_bits_ch == '8')
 mode.data_bit = DataBit::k8bits;
 else if (data_bits_ch == '7')
 mode.data_bit = DataBit::k7bits;
 else {
 LogErr("unsupport databit %c", data_bits_ch);
 return false;
 }

 //! 奇偶校验位
 if (parity_ch == 'N')
 mode.parity = ParityEnd::kNoEnd;
 else if (parity_ch == 'O')
 mode.parity = ParityEnd::kOddEnd;
 else if (parity_ch == 'E')
 mode.parity = ParityEnd::kEvenEnd;
 else {
 LogErr("unsupport parity %c", parity_ch);
 return false;
 }

 //! 停止位
 if (stop_bits_ch == '1')
 mode.stop_bit = StopBit::k1bits;
 else if (stop_bits_ch == '2')
 mode.stop_bit = StopBit::k2bits;
 else {
 LogErr("unsupport stopbit %c", stop_bits_ch);
 return false;
 }

 return setMode(mode);
}

void Uart::setReceiveCallback(const ReceiveCallback &cb, size_t threshold)
{
 buff_fd_.setReceiveCallback(cb, threshold);
}

void Uart::setSendCompleteCallback(const SendCompleteCallback &cb)
{
 buff_fd_.setSendCompleteCallback(cb);
}

bool Uart::send(const void *data_ptr, size_t data_size)
{
 return buff_fd_.send(data_ptr, data_size);
}

void Uart::bind(ByteStream *receiver)
{
 buff_fd_.bind(receiver);
}

void Uart::unbind()
{
 buff_fd_.unbind();
}

Buffer* Uart::getReceiveBuffer()
{
 return buff_fd_.getReceiveBuffer();
}

bool Uart::enable()
{
 if (fd_.isNull()) {
 LogErr("please initialize first");
 return false;
 }

 return buff_fd_.enable();
}

bool Uart::disable()
{
 if (fd_.isNull()) {
 LogErr("please initialize first");
 return false;
 }

 return buff_fd_.disable();
}

bool Uart::openDevice(const std::string &dev)
{
 Fd fd = Fd::Open(dev.c_str(), O_RDWR | O_NOCTTY);
 if (fd.isNull()) {
 LogErr("Uart open fail");
 return false;
 }

 fd_ = std::move(fd);
 return buff_fd_.initialize(fd_);
}

}
}