/*
;    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.
*/

#include <sdkconfig.h>
#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE

#include "ovms_log.h"
static const char *TAG = "ovms-duk-http";

#include <string>
#include <fstream>
#include <iostream>
#include <string.h>
#include <stdio.h>
#include <dirent.h>
#include <esp_task_wdt.h>
#include "ovms_malloc.h"
#include "ovms_module.h"
#include "ovms_duktape.h"
#include "ovms_config.h"
#include "ovms_command.h"
#include "ovms_events.h"
#include "console_async.h"
#include "buffered_shell.h"
#include "ovms_netmanager.h"
#include "ovms_tls.h"

////////////////////////////////////////////////////////////////////////////////
// DuktapeHTTPRequest

////////////////////////////////////////////////////////////////////////////////
// DuktapeHTTPRequest: perform asynchronous HTTP request
//  - uses GET/POST (if post data is given)
//  - follows 301/302 redirects automatically (max 5 hops)
//  - automatically prevents garbage collection while active
//  - Note: any valid server response is considered a success (= triggers done callback)
//  - TODO: implement request.abort() method
//  - TODO: implement digest authentication
//
// Javascript API:
//  create:
//     var request = HTTP.Request({
//       url: "…",
//       [headers: [{ "key": "value", … }, …]]    // Note: array members may contain multiple headers
//       [post: "foo=bar&…",]                     // assumed x-www-form-urlencoded w/o Content-Type
//       [timeout: ms,]                           // default: 120 seconds
//       [binary: bool,]                          // default: false
//       [done: function(response){},]
//       [fail: function(error){},]
//     });
//
//  done(): (this = request, response = request.response)
//    request.response = {
//      statusCode: e.g. 200,
//      statusText: e.g. "OK",
//      [body: <string>,]                         // if binary=false
//      [data: <Uint8Array>,]                     // if binary=true
//      headers: [{ key: value }, …],
//    }
//
//  fail(): (this = request, error = request.error)
//    request.error = "error description"
//
//  also:
//    request.url = last URL used if redirected
//    request.redirectCount = number of redirects

class DuktapeHTTPRequest : public DuktapeObject
  {
  public:
    DuktapeHTTPRequest(duk_context *ctx, int obj_idx);
    ~DuktapeHTTPRequest();
    static duk_ret_t Create(duk_context *ctx);

  protected:
    bool StartRequest(duk_context *ctx=NULL);

  public:
    static void MongooseCallbackEntry(struct mg_connection *nc, int ev, void *ev_data);
    void MongooseCallback(struct mg_connection *nc, int ev, void *ev_data);

  public:
    duk_ret_t CallMethod(duk_context *ctx, const char* method, void* data=NULL);

  protected:
    extram::string m_url;
    int m_redirectcnt = 0;
    bool m_ispost = false;
    extram::string m_post;
    int m_timeout = 120*1000;
    bool m_binary = false;
    extram::string m_headers;
    extram::string m_error;
    struct mg_connection *m_mgconn = NULL;
    int m_response_status = 0;
    extram::string m_response_statusmsg;
    extram::string m_response_body;
    std::list<std::pair<extram::string, extram::string>> m_response_headers;
  };

DuktapeHTTPRequest::DuktapeHTTPRequest(duk_context *ctx, int obj_idx)
  : DuktapeObject(ctx, obj_idx)
  {
  // get args:
  duk_require_stack(ctx, 5);
  if (duk_get_prop_string(ctx, 0, "url"))
    m_url = duk_to_string(ctx, -1);
  duk_pop(ctx);
  if (duk_get_prop_string(ctx, 0, "post"))
    {
    m_ispost = true;
    m_post = duk_to_string(ctx, -1);
    }
  duk_pop(ctx);
  if (duk_get_prop_string(ctx, 0, "timeout"))
    m_timeout = duk_to_int(ctx, -1);
  duk_pop(ctx);
  if (duk_get_prop_string(ctx, 0, "binary"))
    m_binary = duk_to_boolean(ctx, -1);
  duk_pop(ctx);

  if (m_url.empty())
    {
    m_error = "missing argument: url";
    CallMethod(ctx, "fail");
    return;
    }

  // …request headers:
  extram::string key, val;
  bool have_useragent = false, have_contenttype = false;

  duk_get_prop_string(ctx, 0, "headers");
  if (duk_is_array(ctx, -1))
    {
    for (int i=0; true; i++)
      {
      if (!duk_get_prop_index(ctx, -1, i))
        {
        // array end
        duk_pop(ctx);
        break;
        }
      if (duk_is_object(ctx, -1))
        {
        duk_enum(ctx, -1, 0);
        while (duk_next(ctx, -1, true))
          {
          key = duk_to_string(ctx, -2);
          val = duk_to_string(ctx, -1);
          duk_pop_2(ctx);
          m_headers.append(key);
          m_headers.append(": ");
          m_headers.append(val);
          m_headers.append("\r\n");
          if (key == "User-Agent")
            have_useragent = true;
          else if (key == "Content-Type")
            have_contenttype = true;
          }
        duk_pop(ctx); // enum
        }
      duk_pop(ctx); // array element
      }
    }
  duk_pop(ctx); // [array]

  // add defaults:
  if (!have_useragent)
    {
    m_headers.append("User-Agent: ");
    m_headers.append(get_user_agent().c_str());
    m_headers.append("\r\n");
    }
  if (m_ispost && !have_contenttype)
    {
    m_headers.append("Content-Type: application/x-www-form-urlencoded\r\n");
    }

  // check network:
  if (!MyNetManager.MongooseRunning() || !MyNetManager.m_connected_any)
    {
    m_error = "network unavailable";
    CallMethod(ctx, "fail");
    return;
    }

  // start initial request:
  if (StartRequest(ctx))
    {
    // running, prevent deletion & GC:
    Ref();
    Register(ctx);
    ESP_LOGD(TAG, "DuktapeHTTPRequest: started '%s'", m_url.c_str());
    }
  }

bool DuktapeHTTPRequest::StartRequest(duk_context *ctx /*=NULL*/)
  {
  // create connection:
  m_mgconn = NULL;
  struct mg_mgr* mgr = MyNetManager.GetMongooseMgr();
  struct mg_connect_opts opts = {};
  opts.user_data = this;
  const char* err;
  opts.error_string = &err;

  if (startsWith(m_url, "https://"))
    {
    #if MG_ENABLE_SSL
      opts.ssl_ca_cert = MyOvmsTLS.GetTrustedList();
    #else
      m_error = "SSL support disabled";
      ESP_LOGD(TAG, "DuktapeHTTPRequest: connect to '%s' failed: %s", m_url.c_str(), m_error.c_str());
      CallMethod(ctx, "fail");
      return false;
    #endif
    }

  m_mgconn = mg_connect_http_opt(mgr, MongooseCallbackEntry, opts,
    m_url.c_str(), m_headers.c_str(), m_ispost ? m_post.c_str() : NULL);

  if (!m_mgconn)
    {
    ESP_LOGD(TAG, "DuktapeHTTPRequest: connect to '%s' failed: %s", m_url.c_str(), err);
    m_error = (err && *err) ? err : "unknown";
    CallMethod(ctx, "fail");
    return false;
    }

  // connection created:
  if (m_timeout > 0)
    mg_set_timer(m_mgconn, mg_time() + (double)m_timeout / 1000);
  return true;
  }

DuktapeHTTPRequest::~DuktapeHTTPRequest()
  {
  // ESP_LOGD(TAG, "~DuktapeHTTPRequest");
  if (m_mgconn)
    {
    m_mgconn->user_data = NULL;
    m_mgconn->flags |= MG_F_CLOSE_IMMEDIATELY;
    m_mgconn = NULL;
    }
  }

duk_ret_t DuktapeHTTPRequest::Create(duk_context *ctx)
  {
  // var request = HTTP.Request({ args })
  DuktapeHTTPRequest* request = new DuktapeHTTPRequest(ctx, 0);
  request->Push(ctx);
  return 1;
  }

void DuktapeHTTPRequest::MongooseCallbackEntry(struct mg_connection *nc, int ev, void *ev_data)
  {
  DuktapeHTTPRequest* me = (DuktapeHTTPRequest*)nc->user_data;
  if (me) me->MongooseCallback(nc, ev, ev_data);
  }

void DuktapeHTTPRequest::MongooseCallback(struct mg_connection *nc, int ev, void *ev_data)
  {
  OvmsRecMutexLock lock(&m_mutex);
  if (nc != m_mgconn) return; // ignore events of previous connections
  switch (ev)
    {
    case MG_EV_CONNECT:
      {
      int err = *(int*) ev_data;
      const char* errdesc = strerror(err);
      ESP_LOGD(TAG, "DuktapeHTTPRequest: MG_EV_CONNECT err=%d/%s", err, errdesc);
      if (err)
        {
        #if MG_ENABLE_SSL
        if (err == MG_SSL_ERROR)
          m_error = "SSL error";
        else
        #endif
          m_error = (errdesc && *errdesc) ? errdesc : "unknown";
        RequestCallback("fail");
        nc->flags |= MG_F_CLOSE_IMMEDIATELY;
        }
      }
      break;

    case MG_EV_HTTP_REPLY:
      {
      // response is complete, store:
      http_message *hm = (http_message*) ev_data;
      ESP_LOGD(TAG, "DuktapeHTTPRequest: MG_EV_HTTP_REPLY status=%d bodylen=%d", hm->resp_code, hm->body.len);
      m_response_status = hm->resp_code;
      m_response_statusmsg.assign(hm->resp_status_msg.p, hm->resp_status_msg.len);
      m_response_body.assign(hm->body.p, hm->body.len);
      extram::string key, val, location;
      for (int i = 0; i < MG_MAX_HTTP_HEADERS && hm->header_names[i].len > 0; i++)
        {
        key.assign(hm->header_names[i].p, hm->header_names[i].len);
        val.assign(hm->header_values[i].p, hm->header_values[i].len);
        m_response_headers.push_back(std::make_pair(key, val));
        if (key == "Location") location = val;
        }

      // follow redirect?
      if (m_response_status == 301 || m_response_status == 302)
        {
        if (location.empty())
          {
          m_error = "redirect without location";
          RequestCallback("fail");
          }
        else if (++m_redirectcnt > 5)
          {
          m_error = "too many redirects";
          RequestCallback("fail");
          }
        else
          {
          ESP_LOGD(TAG, "DuktapeHTTPRequest: redirect code=%d to '%s'", m_response_status, location.c_str());
          m_url = location;
          m_response_status = 0;
          m_response_statusmsg.clear();
          m_response_body.clear();
          m_response_headers.clear();
          if (!StartRequest(NULL))
            RequestCallback("fail");
          }
        }
      else
        {
        RequestCallback("done");
        }
      // in any case, this connection is done:
      nc->flags |= MG_F_CLOSE_IMMEDIATELY;
      }
      break;

    case MG_EV_TIMER:
      {
      ESP_LOGD(TAG, "DuktapeHTTPRequest: MG_EV_TIMER");
      m_error = "timeout";
      RequestCallback("fail");
      nc->flags |= MG_F_CLOSE_IMMEDIATELY;
      }
      break;

    case MG_EV_CLOSE:
      {
      if (m_response_status == 0 && m_error.empty())
        {
        ESP_LOGD(TAG, "DuktapeHTTPRequest: MG_EV_CLOSE: abort");
        m_error = "abort";
        RequestCallback("fail");
        }
      else
        {
        ESP_LOGD(TAG, "DuktapeHTTPRequest: MG_EV_CLOSE status=%d", m_response_status);
        }
      // Mongoose part done:
      nc->user_data = NULL;
      m_mgconn = NULL;
      Unref();
      }
      break;

    default:
      break;
    }
  }

duk_ret_t DuktapeHTTPRequest::CallMethod(duk_context *ctx, const char* method, void* data /*=NULL*/)
  {
  if (!ctx)
    {
    RequestCallback(method, data);
    return 0;
    }
  OvmsRecMutexLock lock(&m_mutex);
  if (!IsCoupled()) return 0;

  duk_require_stack(ctx, 7);
  int entry_top = duk_get_top(ctx);

  bool deregister = false;

  while (method)
    {
    const char* followup_method = NULL;

    // check method:
    int obj_idx = Push(ctx);
    duk_get_prop_string(ctx, obj_idx, method);
    bool callable = duk_is_callable(ctx, -1);
    duk_pop(ctx);
    if (callable) duk_push_string(ctx, method);
    int nargs = 0;

    // update request.url, set request.redirectCount:
    duk_push_string(ctx, m_url.c_str());
    duk_put_prop_string(ctx, obj_idx, "url");
    duk_push_int(ctx, m_redirectcnt);
    duk_put_prop_string(ctx, obj_idx, "redirectCount");

    // create results & method arguments:
    if (strcmp(method, "done") == 0)
      {
      // done(response):
      followup_method = "always";
      ESP_LOGD(TAG, "DuktapeHTTPRequest: done status=%d bodylen=%d url='%s'",
        m_response_status, m_response_body.size(), m_url.c_str());

      // clear request.error:
      duk_push_string(ctx, "");
      duk_put_prop_string(ctx, obj_idx, "error");

      // create response object:
      duk_push_object(ctx);
      duk_push_int(ctx, m_response_status);
      duk_put_prop_string(ctx, -2, "statusCode");
      duk_push_string(ctx, m_response_statusmsg.c_str());
      duk_put_prop_string(ctx, -2, "statusText");

      // …body:
      if (m_binary)
        {
        void* p = duk_push_fixed_buffer(ctx, m_response_body.size());
        memcpy(p, m_response_body.data(), m_response_body.size());
        duk_put_prop_string(ctx, -2, "data");
        }
      else
        {
        duk_push_lstring(ctx, m_response_body.data(), m_response_body.size());
        duk_put_prop_string(ctx, -2, "body");
        }
      m_response_body.clear();
      m_response_body.shrink_to_fit();

      // …response headers:
      duk_push_array(ctx);
      int i = 0;
      for (auto it = m_response_headers.begin(); it != m_response_headers.end(); it++, i++)
        {
        duk_push_object(ctx);
        duk_push_string(ctx, it->second.c_str());
        duk_put_prop_string(ctx, -2, it->first.c_str());
        duk_put_prop_index(ctx, -2, i);
        }
      duk_put_prop_string(ctx, -2, "headers");
      m_response_headers.clear();

      duk_dup(ctx, -1);
      duk_put_prop_string(ctx, obj_idx, "response");
      nargs++;
      }
    else if (strcmp(method, "fail") == 0)
      {
      // fail(error):
      followup_method = "always";
      ESP_LOGD(TAG, "DuktapeHTTPRequest: failed error='%s' url='%s'",
        m_error.c_str(), m_url.c_str());

      // set request.error:
      duk_push_string(ctx, m_error.c_str());
      duk_dup(ctx, -1);
      duk_put_prop_string(ctx, obj_idx, "error");
      nargs++;
      }
    else if (strcmp(method, "always") == 0)
      {
      // always():
      deregister = true;
      }

    // call method:
    if (callable)
      {
      ESP_LOGD(TAG, "DuktapeHTTPRequest: calling method '%s' nargs=%d", method, nargs);
      if (duk_pcall_prop(ctx, obj_idx, nargs) != 0)
        {
        DukOvmsErrorHandler(ctx, -1);
        }
      }

    // clear stack:
    duk_pop_n(ctx, duk_get_top(ctx) - entry_top);

    // followup call:
    method = followup_method;
    } // while (method)

  // allow GC:
  if (deregister) Deregister(ctx);
  return 0;
  }

////////////////////////////////////////////////////////////////////////////////
// DuktapeHTTPInit registration

class DuktapeHTTPInit
  {
  public: DuktapeHTTPInit();
} MyDuktapeHTTPInit  __attribute__ ((init_priority (1700)));

DuktapeHTTPInit::DuktapeHTTPInit()
  {
  ESP_LOGI(TAG, "Installing DUKTAPE HTTP (1710)");

  DuktapeObjectRegistration* dt_http = new DuktapeObjectRegistration("HTTP");
  dt_http->RegisterDuktapeFunction(DuktapeHTTPRequest::Create, 1, "request"); // legacy
  dt_http->RegisterDuktapeFunction(DuktapeHTTPRequest::Create, 1, "Request");
  MyDuktape.RegisterDuktapeObject(dt_http);
  }

#endif // CONFIG_OVMS_SC_GPL_MONGOOSE