/*
;    Project:       Open Vehicle Monitor System
;    Date:          14th March 2017
;
;    Changes:
;    1.0  Initial release
;
;    (C) 2011       Michael Stegen / Stegen Electronics
;    (C) 2011-2017  Mark Webb-Johnson
;    (C) 2011        Sonny Chen @ EPRO/DX
;
; 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.
*/
#define LWIP_POSIX_SOCKETS_IO_NAMES 0
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h> // Required for libtelnet.h
#include <string.h>
#include <errno.h>
#include <lwip/def.h>
#include <lwip/sockets.h>
#undef bind
#include "freertos/queue.h"
#include "ovms_log.h"
#include "ovms_events.h"
#include "console_telnet.h"
#include "ovms_netmanager.h"

//#define LOGEVENTS
#ifdef LOGEVENTS
static const char *eventToString(telnet_event_type_t type);
#endif

static const char *tag = "telnet";
static const char newline = '\n';

//-----------------------------------------------------------------------------
//    Class OvmsTelnet
//-----------------------------------------------------------------------------

OvmsTelnet MyTelnet __attribute__ ((init_priority (8300)));

static void MongooseHandler(struct mg_connection *nc, int ev, void *p)
  {
  MyTelnet.EventHandler(nc, ev, p);
  }

void OvmsTelnet::EventHandler(struct mg_connection *nc, int ev, void *p)
  {
  //ESP_LOGI(tag, "Event %d conn %p, data %p", ev, nc, p);
  switch (ev)
    {
    case MG_EV_ACCEPT:
      {
      ConsoleTelnet* child = new ConsoleTelnet(nc);
      nc->user_data = child;
      break;
      }

    case MG_EV_POLL:
      {
      ConsoleTelnet* child = (ConsoleTelnet*)nc->user_data;
      if (child)
        child->Poll(0);
      }
      break;

    case MG_EV_RECV:
      {
      ConsoleTelnet* child = (ConsoleTelnet*)nc->user_data;
      child->Receive();
      child->Poll(0);
      }
      break;

    case MG_EV_CLOSE:
      {
      ConsoleTelnet* child = (ConsoleTelnet*)nc->user_data;
      if (child)
        delete child;
      }
      break;

    default:
      break;
    }
  }

OvmsTelnet::OvmsTelnet()
  {
  ESP_LOGI(tag, "Initialising Telnet (8300)");

  m_running = false;

  using std::placeholders::_1;
  using std::placeholders::_2;
  MyEvents.RegisterEvent(tag,"network.mgr.init", std::bind(&OvmsTelnet::NetManInit, this, _1, _2));
  MyEvents.RegisterEvent(tag,"network.mgr.stop", std::bind(&OvmsTelnet::NetManStop, this, _1, _2));
  }

void OvmsTelnet::NetManInit(std::string event, void* data)
  {
  // Only initialise server for WIFI connections
  // TODO: Disabled as this introduces a network interface ordering issue. It
  //       seems that the correct way to do this is to always start the mongoose
  //       listener, but to filter incoming connections to check that the
  //       destination address is a Wifi interface address.
  // if (!(MyNetManager.m_connected_wifi || MyNetManager.m_wifi_ap))
  //   return;

  m_running = true;

  ESP_LOGI(tag, "Launching Telnet Server");
  struct mg_mgr* mgr = MyNetManager.GetMongooseMgr();
  mg_connection* nc = mg_bind(mgr, ":23", MongooseHandler);
  if (nc)
    nc->user_data = NULL;
  else
    ESP_LOGE(tag, "Launching Telnet Server failed");
  }

void OvmsTelnet::NetManStop(std::string event, void* data)
  {
  if (m_running)
    {
    ESP_LOGI(tag, "Stopping Telnet Server");
    m_running = false;
    }
  }

//-----------------------------------------------------------------------------
//    Class ConsoleTelnet
//-----------------------------------------------------------------------------

ConsoleTelnet::ConsoleTelnet(struct mg_connection* nc)
  {
  m_connection = nc;
  m_queue = xQueueCreate(100, sizeof(Event));

  static const telnet_telopt_t options[] =
    {
    { TELNET_TELOPT_ECHO,      TELNET_WILL, TELNET_DONT },
    { TELNET_TELOPT_LINEMODE,  TELNET_WONT, TELNET_DONT },
    { TELNET_TELOPT_SGA,       TELNET_WILL, TELNET_DO   },
    { TELNET_TELOPT_TTYPE,     TELNET_WONT, TELNET_DONT },
    { TELNET_TELOPT_COMPRESS2, TELNET_WONT, TELNET_DONT },
    { TELNET_TELOPT_ZMP,       TELNET_WONT, TELNET_DONT },
    { TELNET_TELOPT_MSSP,      TELNET_WONT, TELNET_DONT },
    { TELNET_TELOPT_BINARY,    TELNET_WONT, TELNET_DONT },
    { TELNET_TELOPT_NAWS,      TELNET_WONT, TELNET_DONT },
    { -1, 0, 0 }
    };
  m_telnet = telnet_init(options, TelnetCallback, TELNET_FLAG_NVT_EOL, (void*)this);
  telnet_negotiate(m_telnet, TELNET_WILL, TELNET_TELOPT_ECHO);
  Initialize("Telnet");
  }

// This destructor is only called by NetManTask deleting the ConsoleTelnet child.

ConsoleTelnet::~ConsoleTelnet()
  {
  telnet_t *telnet = m_telnet;
  m_telnet = NULL;
  telnet_free(telnet);
  vQueueDelete(m_queue);
  }

void ConsoleTelnet::Receive()
  {
  OvmsConsole::Event event;
  event.type = OvmsConsole::event_type_t::RECV;
  event.mbuf = &m_connection->recv_mbuf;
  BaseType_t ret = xQueueSendToBack(m_queue, (void * )&event, (portTickType)(1000 / portTICK_PERIOD_MS));
  if (ret == pdPASS)
    {
    // Process this input in sequence with any queued logging.
    Poll(0);
    }
  else
    ESP_LOGE(tag, "Timeout queueing message in ConsoleTelnet::Receive\n");
  mbuf_remove(event.mbuf, event.mbuf->len);
  }

void ConsoleTelnet::HandleDeviceEvent(void* pEvent)
  {
  Event event = *(Event*)pEvent;
  switch (event.type)
    {
    case RECV:
      telnet_recv(m_telnet, event.mbuf->buf, event.mbuf->len);
      break;

    default:
      ESP_LOGE(tag, "Unknown event type in ConsoleTelnet");
      break;
    }
  }

void ConsoleTelnet::TelnetCallback(telnet_t *telnet, telnet_event_t *event, void *userData)
  {
  ((ConsoleTelnet*)userData)->TelnetHandler(event);
  }

void ConsoleTelnet::TelnetHandler(telnet_event_t *event)
  {
  switch (event->type)
    {
    case TELNET_EV_SEND:
      mg_send(m_connection, event->data.buffer, event->data.size);
      break;

    case TELNET_EV_DATA:
      {
      char *buffer = (char *)event->data.buffer;
      size_t size = (size_t)event->data.size;
      // Translate CR (Enter) from telnet client into \n for microrl
      for (size_t i = 0; i < size; ++i)
        {
        if (buffer[i] == '\r')
          buffer[i] = '\n';
        }
      ProcessChars(buffer, size);
      break;
      }

    default:
#ifdef LOGEVENTS
      ESP_LOGI(tag, "telnet event: %s", eventToString(event->type));
#endif
      break;
    }
  }

// This is called to shut down the Telnet connection when the "exit" command is input.
void ConsoleTelnet::Exit()
  {
  printf("logout\n");
  m_connection->flags |= MG_F_SEND_AND_CLOSE;
  }

int ConsoleTelnet::puts(const char* s)
  {
  if (!m_telnet)
    return -1;
  telnet_send_text(m_telnet, s, strlen(s));
  telnet_send_text(m_telnet, &newline, 1);
  return 0;
  }

int ConsoleTelnet::printf(const char* fmt, ...)
  {
  if (!m_telnet)
    return 0;
  va_list args;
  va_start(args,fmt);
  int ret = telnet_vprintf(m_telnet, fmt, args);
  va_end(args);
  return ret;
  }

ssize_t ConsoleTelnet::write(const void *buf, size_t nbyte)
  {
  if (!m_telnet || (m_connection->flags & MG_F_SEND_AND_CLOSE))
    return 0;
  telnet_send_text(m_telnet, (const char*)buf, nbyte);
  return nbyte;
  }

/**
 * Convert a telnet event type to its string representation.
 */
#ifdef LOGEVENTS
static const char *eventToString(telnet_event_type_t type) {
	switch(type) {
	case TELNET_EV_COMPRESS:
		return "TELNET_EV_COMPRESS";
	case TELNET_EV_DATA:
		return "TELNET_EV_DATA";
	case TELNET_EV_DO:
		return "TELNET_EV_DO";
	case TELNET_EV_DONT:
		return "TELNET_EV_DONT";
	case TELNET_EV_ENVIRON:
		return "TELNET_EV_ENVIRON";
	case TELNET_EV_ERROR:
		return "TELNET_EV_ERROR";
	case TELNET_EV_IAC:
		return "TELNET_EV_IAC";
	case TELNET_EV_MSSP:
		return "TELNET_EV_MSSP";
	case TELNET_EV_SEND:
		return "TELNET_EV_SEND";
	case TELNET_EV_SUBNEGOTIATION:
		return "TELNET_EV_SUBNEGOTIATION";
	case TELNET_EV_TTYPE:
		return "TELNET_EV_TTYPE";
	case TELNET_EV_WARNING:
		return "TELNET_EV_WARNING";
	case TELNET_EV_WILL:
		return "TELNET_EV_WILL";
	case TELNET_EV_WONT:
		return "TELNET_EV_WONT";
	case TELNET_EV_ZMP:
		return "TELNET_EV_ZMP";
	}
	return "Unknown type";
} // eventToString
#endif