/*
 * Author: Jon Trulson <jtrulson@ics.com>
 * Copyright (c) 2015 Intel Corporation.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include <iostream>
#include <time.h>

#include "nlgpio16.h"

using namespace upm;
using namespace std;

static const int maxBuffer = 1024;
static const int baudRate = 115200;

static char num2Hex(int i, bool upcase)
{
  char temp;

  switch (i)
    {
    case 0: return '0';
    case 1: return '1';
    case 2: return '2';
    case 3: return '3';
    case 4: return '4';
    case 5: return '5';
    case 6: return '6';
    case 7: return '7';
    case 8: return '8';
    case 9: return '9';
    case 10: temp = (upcase) ? 'A' : 'a'; return temp;
    case 11: temp = (upcase) ? 'B' : 'b'; return temp;
    case 12: temp = (upcase) ? 'C' : 'c'; return temp;
    case 13: temp = (upcase) ? 'D' : 'd'; return temp;
    case 14: temp = (upcase) ? 'E' : 'e'; return temp;
    case 15: temp = (upcase) ? 'F' : 'f'; return temp;

    default:
      throw std::out_of_range(std::string(__FUNCTION__) +
                              ": number must be between 0 and 15");
      return '0';
    }
}

NLGPIO16::NLGPIO16(string uart) :
  m_uart(uart)
{
  m_uart.setBaudRate(baudRate);
}

NLGPIO16::~NLGPIO16()
{
}

bool NLGPIO16::dataAvailable(unsigned int millis)
{
  return m_uart.dataAvailable(millis);
}

std::string NLGPIO16::readStr(int len)
{
  return m_uart.readStr(len);
}

int NLGPIO16::writeStr(std::string data)
{
  m_uart.flush();
  return m_uart.writeStr(data);
}

string NLGPIO16::sendCommand(string cmd)
{
  // make sure we got a command
  if (cmd.empty())
    {
      throw std::invalid_argument(std::string(__FUNCTION__) +
                                  ": cmd is empty!");
      return "";
    }

  // make sure string is CR terminated
  if (cmd.at(cmd.size() - 1) != '\r')
    cmd.append("\r");

  writeStr(cmd);

  string resp;
  while (dataAvailable(10))
    {
      resp += readStr(maxBuffer);
    }

  if (resp.empty())
    {
      throw std::runtime_error(std::string(__FUNCTION__) +
                               ": timed out waiting for response");
      return "";
    }

  // check that the last character is the prompt
  if (resp.at(resp.size() - 1) != '>')
    {
      throw std::runtime_error(std::string(__FUNCTION__) +
                               ": read from device corrupted");
      return "";
    }

  // delete the last 3 characters, which should be '\n\r>'
  resp.erase(resp.size() - 3, 3);

  // find first delimeter (second should already be erased)
  size_t pos = resp.find("\n\r");

  // if we didn't find one, then the command was invalid.  This
  // shouldn't happen, but we check for it anyway
  if (pos == string::npos)
    return "";

  pos += 2;                     // skip past them.

  // now we should have the value (or an empty string in the case of a
  // write command).  Erase everything else and return the result.
  resp.erase(0, pos);

  return resp;
}

void NLGPIO16::gpioSet(int gpio)
{
  if (gpio < 0 || gpio > 15)
    {
      throw std::out_of_range(std::string(__FUNCTION__) +
                              ": gpio must be between 0 and 15");
      return;
    }

  string cmd("gpio set ");
  cmd += num2Hex(gpio, true);

  // set commands don't return anything useful
  sendCommand(cmd);
  return;
}

void NLGPIO16::gpioClear(int gpio)
{
  if (gpio < 0 || gpio > 15)
    {
      throw std::out_of_range(std::string(__FUNCTION__) +
                              ": gpio must be between 0 and 15");
      return;
    }

  string cmd("gpio clear ");
  cmd += num2Hex(gpio, true);

  // set commands don't return anything useful
  sendCommand(cmd);
  return;
}

bool NLGPIO16::gpioRead(int gpio)
{
  if (gpio < 0 || gpio > 15)
    {
      throw std::out_of_range(std::string(__FUNCTION__) +
                              ": gpio must be between 0 and 15");
      return false;
    }

  string cmd("gpio read ");
  cmd += num2Hex(gpio, true);

  string resp = sendCommand(cmd);
  if (resp.empty())
    {
      throw std::runtime_error(std::string(__FUNCTION__) +
                               ": invalid empty response from device");
      return false;
    }

  // c++11 toString() would be handy...
  return ( (atoi(resp.c_str()) == 0) ? false : true );
}

unsigned int NLGPIO16::gpioReadAll()
{
  string cmd("gpio readall");

  string resp = sendCommand(cmd);
  if (resp.empty())
    {
      throw std::runtime_error(std::string(__FUNCTION__) +
                               ": invalid empty response from device");
      return false;
    }

  //  Convert to unsigned int (but mask out everything but the lower 16bits)
  unsigned int value = strtoul(resp.c_str(), NULL, 16);
  value &= 0xffff;

  return value;
}

void NLGPIO16::gpioSetIOMask(int mask)
{
  if (mask < 0 || mask > 65535)
    {
      throw std::out_of_range(std::string(__FUNCTION__) +
                              ": mask must be between 0 and 65535");
      return;
    }

  string cmd("gpio iomask ");
  cmd += num2Hex( ((mask & 0xf000) >> 12), false);
  cmd += num2Hex( ((mask & 0x0f00) >> 8), false);
  cmd += num2Hex( ((mask & 0x00f0) >> 4), false);
  cmd += num2Hex( ((mask & 0x000f) >> 0), false);

  sendCommand(cmd);

  return;
}

void NLGPIO16::gpioSetIODir(int mask)
{
  if (mask < 0 || mask > 65535)
    {
      throw std::out_of_range(std::string(__FUNCTION__) +
                              ": mask must be between 0 and 65535");
      return;
    }

  string cmd("gpio iodir ");
  cmd += num2Hex( ((mask & 0xf000) >> 12), false);
  cmd += num2Hex( ((mask & 0x0f00) >> 8), false);
  cmd += num2Hex( ((mask & 0x00f0) >> 4), false);
  cmd += num2Hex( ((mask & 0x000f) >> 0), false);

  sendCommand(cmd);

  return;
}

void NLGPIO16::gpioWriteAll(int mask)
{
  if (mask < 0 || mask > 65535)
    {
      throw std::out_of_range(std::string(__FUNCTION__) +
                              ": mask must be between 0 and 65535");
      return;
    }

  string cmd("gpio writeall ");
  cmd += num2Hex( ((mask & 0xf000) >> 12), false);
  cmd += num2Hex( ((mask & 0x0f00) >> 8), false);
  cmd += num2Hex( ((mask & 0x00f0) >> 4), false);
  cmd += num2Hex( ((mask & 0x000f) >> 0), false);

  sendCommand(cmd);

  return;
}

string NLGPIO16::getVersion()
{
  return sendCommand("vers");
}

string NLGPIO16::getID()
{
  return sendCommand("id get");
}

void NLGPIO16::setID(string id)
{
  if (id.size() != 8)
    {
      throw std::out_of_range(std::string(__FUNCTION__) +
                              ": ID must be exactly 8 characters in length");
      return;
    }

  string cmd("id set ");
  cmd += id;

  sendCommand(cmd);

  return;
}

int NLGPIO16::analogReadValue(int adc)
{
  // Only ports 0-6 are ADC capable
  if (adc < 0 || adc > 6)
    {
      throw std::out_of_range(std::string(__FUNCTION__) +
                              ": adc must be between 0 and 6");
      return false;
    }

  string cmd("adc read ");
  cmd += num2Hex(adc, true);

  string resp = sendCommand(cmd);
  if (resp.empty())
    {
      throw std::runtime_error(std::string(__FUNCTION__) +
                               ": invalid empty response from device");
      return false;
    }

  // c++11 stoi() would be handy...
  return atoi(resp.c_str());
}

float NLGPIO16::analogReadVolts(int adc)
{
  float value = float(analogReadValue(adc));

  return ( value * (ADC_AREF / float(1 << ADC_PRECISION)) );
}

