/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/***************************************************************************
 *            cli.c
 *
 *  Thu Jun  6 20:20:20 CEST 2013
 *  Copyright 2013 Bent Bisballe Nyeng
 *  deva@aasimon.org
 ****************************************************************************/

/*
 *  This file is part of Pedal2Metal.
 *
 *  Pedal2Metal is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Pedal2Metal is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Pedal2Metal; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */
#include "cli.h"

#include <stdarg.h>
#include <string.h>

#include "uart.h"

void cli_init()
{
  uart_init(0, 115200);
}

void cli_write(const char *buf, unsigned int size)
{
  uart_send(0, buf, size);
}

int cli_read(char *buf, unsigned int size)
{
  uart_receive(0, buf, size);
  return 0;
}

/*
static int cli_strlen(char *p0)
{
  char *p = p0;
  while(*p) p++;
  return p - p0;
}
*/
static inline void cli_write_int(int i)
{
	if(i < 0) {
		uart_send(0, "-", 1);
		i *= -1;
	}

	char buf[] = "\0\0";
	int pos = 1000000000;
	int tvaersum = 0;
	while(pos) {
		int res = i / pos;
		i -= res * pos;

		tvaersum += res;
		if(tvaersum || pos == 1) {
			buf[0] = res + '0';
			cli_write(buf, 1);
		}
		pos /= 10;
	}
}

static inline char *cli_to_hex(char i)
{
	static const char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
	static char buf[] = { 'f', 'f', 0 };
	buf[0] = hex[i / 16];
	buf[1] = hex[i % 16];
	return buf;
}

static int cli_write_format(const char *fmt, va_list ap)
{
	char buf[] = "\0\0";

	const char *p = fmt;
	while(*p) {
		if(*p != '%') {
      buf[0] = *p;
      cli_write(buf, 1);
      if(*p == '\n') cli_write("\r", 1); // also write carrige return.
		} else {
			p++;
			if(!*p) {
				return 1; // Error: Invalid format string
			}
			if(*p == '%') cli_write("%", 1);
			if(*p == 'd') cli_write_int(va_arg(ap, int));
			if(*p == 'c') {
				buf[0] = va_arg(ap, int);
        cli_write(buf, 1);
			}
			if(*p == 'x') {
				char *c = va_arg(ap, char *);
				size_t sz = va_arg(ap, int);
				while(sz) {
          cli_write(cli_to_hex(*c), 2);
					c++; sz--;
				}
			}
			if(*p == 's') {
				char *str = va_arg(ap, char *);
        while(*str) {
          cli_write(str, 1);
          str++;
        }
			}
		}
		p++;
	}

	// If last character wasn't a newline, print one.
	//if(p > fmt && *(p - 1) != '\n') cli_write("\n\r", 2);

	return 0;
}

int cli_printf(const char *fmt, ...)
{
  va_list ap;
	va_start(ap, fmt);
	cli_write_format(fmt, ap);
	va_end(ap);

	return 0;
}

int cli_readline(char *cmd, unsigned int size)
{
  char buf[2] = { };
  unsigned int cmdpos = 0;
  int parsing = 1;
  while(parsing &&
        cmdpos < (size - 1)) // Make sure we have room for the terminating zero.
    {
    cli_read(buf, 1); // read one byte

    switch(*buf) {
    case '\n':
    case '\r':
      parsing = 0; // break out of parse loop.
      break;

    case '\b': // backspace
      if(cmdpos) {
        cmdpos--;
        cli_write("\b \b", 3); // erase last written character from echo.
        continue;
      }
      break;

    case 27: // ignore 'ESC' sent on arrow keys.
      // NOTE: Sequence ESC, '[', 'D' is left arrow.
      //       Sequence ESC, '[', 'C' is right arrow.
      continue;

    default:
      cmd[cmdpos++] = *buf;
      break;
    }

    // Echo
    cli_write(buf, 1); // write one byte
  }
  cmd[cmdpos++] = '\0';

  return cmdpos;
}