/****************************************************************************
 * apps/netutils/libcurl4nx/curl4nx_easy_perform.c
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.  The
 * ASF licenses this file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 ****************************************************************************/

/****************************************************************************
 * Included Files
 ****************************************************************************/

#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <debug.h>

#include <sys/socket.h>
#include <sys/time.h>
#include <stdint.h>
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <unistd.h>
#include <netdb.h>
#include <strings.h>
#include <errno.h>

#include <arpa/inet.h>
#include <netinet/in.h>

#include <nuttx/version.h>

#include "netutils/netlib.h"
#include "netutils/curl4nx.h"
#include "curl4nx_private.h"

#if defined(CONFIG_NETUTILS_CODECS)
#  if defined(CONFIG_CODECS_URLCODE)
#    define WGET_USE_URLENCODE 1
#    include "netutils/urldecode.h"
#  endif
#  if defined(CONFIG_CODECS_BASE64)
#    include "netutils/base64.h"
#  endif
#else
#  undef CONFIG_CODECS_URLCODE
#  undef CONFIG_CODECS_BASE64
#endif

/****************************************************************************
 * Pre-processor Definitions
 ****************************************************************************/

#define CURL4NX_STATE_STATUSLINE   0
#define CURL4NX_STATE_STATUSCODE   1
#define CURL4NX_STATE_STATUSREASON 2
#define CURL4NX_STATE_HEADERS      3
#define CURL4NX_STATE_DATA_NORMAL  4
#define CURL4NX_STATE_DATA_CHUNKED 5

/****************************************************************************
 * Private Functions
 ****************************************************************************/

/****************************************************************************
 * Name: curl4nx_easy_perform()
 *
 * Description:
 *  Resolve the hostname to an IP address. There are 3 cases:
 *  - direct IP: inet_aton is used
 *  - using internal curl4nx resolution
 *  - DNS resolution, if available
 ****************************************************************************/

/****************************************************************************
 * Name: curl4nx_resolve
 * Description:
 *   Translate a host name to an IP address (V4 only for the moment)
 *   - either the host is a string with an IP
 *   - either the known hosts were defined by CURL4NXOPT_
 ****************************************************************************/

static int curl4nx_resolve(FAR struct curl4nx_s *handle, FAR char *hostname,
                          FAR struct in_addr *ip)
{
  int ret = inet_aton(hostname, ip);
  if (ret != 0)
    {
      return CURL4NXE_OK; /* IP address is valid */
    }

  curl4nx_warn("Not a valid IP address, trying hostname resolution\n");
  return CURL4NXE_COULDNT_RESOLVE_HOST;
}

/****************************************************************************
 * Name: curl4nx_is_header
 * Description:
 *   Return TRUE if buf contains header, then update off to point at the
 *   beginning of header value
 ****************************************************************************/

static int curl4nx_is_header(FAR char *buf, int len,
                            FAR const char *header, FAR int *off)
{
  if (strncasecmp(buf, header, strlen(header)))
    {
      return false;
    }

  *off = strlen(header);
  while ((*off) < len && buf[*off] == ' ')
    {
      (*off)++;
    }

  return true;
}

/****************************************************************************
 * Public Functions
 ****************************************************************************/

/****************************************************************************
 * Name: curl4nx_easy_perform()
 ****************************************************************************/

int curl4nx_easy_perform(FAR struct curl4nx_s *handle)
{
  struct sockaddr_in server;
  FAR FILE          *stream;     /* IOSTREAM used to printf in the socket TODO avoid */
  int                rxoff;      /* Current offset within RX buffer */
  char               tmpbuf[16]; /* Buffer to hold small strings */
  int                tmplen;     /* Number of bytes used in tmpbuffer */
  int                state;      /* Current state of the parser */
  int                ret;        /* Return value from internal calls */
  FAR char          *headerbuf;
  int                headerlen;
  FAR char          *end;
  int                cret = CURL4NXE_OK; /* Public return value */
  bool               redirected = false; /* Boolean to manage HTTP redirections */
  bool               chunked = false;
  unsigned long long done = 0;
  int                redircount = 0;

  curl4nx_info("started\n");

  stream = NULL;
  headerbuf = malloc(CONFIG_LIBCURL4NX_MAXHEADERLINE);
  if (!headerbuf)
    {
      cret = CURL4NXE_OUT_OF_MEMORY;
      goto abort;
    }

  if (handle->host[0] == 0 || handle->port == 0)
    {
      /* URL has not been set */

      cret = CURL4NXE_URL_MALFORMAT;
      goto freebuf;
    }

  /* TODO: check that host and port have changed or are the same, so we can
   * recycle the socket for the next request.
   */

  do
    {
      handle->sockfd = socket(AF_INET, SOCK_STREAM, 0);
      if (handle->sockfd < 0)
        {
          /* socket failed.  It will set the errno appropriately */

          curl4nx_err("ERROR: socket failed: %d\n", errno);
          cret = CURL4NXE_COULDNT_CONNECT;
          goto freebuf;
        }

      /* TODO: timeouts */

      server.sin_family = AF_INET;
      server.sin_port   = htons(handle->port);
      cret = curl4nx_resolve(handle, handle->host, &server.sin_addr);
      if (cret != CURL4NXE_OK)
        {
          /* Could not resolve host (or malformed IP address) */

          curl4nx_err("ERROR: Failed to resolve hostname\n");
          cret = CURL4NXE_COULDNT_RESOLVE_HOST;
          goto freebuf;
        }

      /* Connect to server.  First we have to set some fields in the
       * 'server' address structure.  The system will assign me an arbitrary
       * local port that is not in use.
       */

      ret = connect(handle->sockfd,
                    (struct sockaddr *)&server, sizeof(struct sockaddr_in));
      if (ret < 0)
        {
          curl4nx_err("ERROR: connect failed: %d\n", errno);
          cret = CURL4NXE_COULDNT_CONNECT;
          goto close;
        }

      curl4nx_info("Connected...\n");

      stream = fdopen(handle->sockfd, "wb");

      /* Send request */

      fprintf(stream, "%s %s HTTP/%d.%d\r\n",
                      handle->method,
                      handle->path,
                      handle->version >> 4,
                      handle->version & 0x0f);

      /* Send headers */

      fprintf(stream, "Host: %s\r\n", handle->host);

      /* For the moment we do not support compression */

      fprintf(stream, "Content-encoding: identity\r\n");

      /* Send more headers */

      /* End of headers */

      fprintf(stream, "\r\n");

      /* TODO send data */

      fflush(stream);
      curl4nx_info("Request sent\n");

      /* Now wait for the result */

      redirected = false; /* for now */
      state      = CURL4NX_STATE_STATUSLINE;
      tmplen     = 0;

      while (1)
        {
          ret = recv(handle->sockfd, handle->rxbuf, handle->rxbufsize, 0);
          if (ret < 0)
            {
              curl4nx_err("RECV failed, errno=%d\n", errno);
              cret = CURL4NXE_RECV_ERROR;
              goto close;
            }
          else if (ret == 0)
            {
              curl4nx_err("Connection lost\n");
              cret = CURL4NXE_GOT_NOTHING;
              goto close;
            }

          curl4nx_info("Received %d bytes\n", ret);
          rxoff = 0;

          if (state == CURL4NX_STATE_STATUSLINE)
            {
              /* Accumulate HTTP/x.y until space */

              while ((tmplen < sizeof(tmpbuf)) && (rxoff < ret))
                {
                  if (handle->rxbuf[rxoff] == ' ')
                    {
                      /* found space after http version */

                      tmpbuf[tmplen] = 0; /* Finish pending string */
                      rxoff++;
                      curl4nx_info("received version: [%s]\n", tmpbuf);
                      tmplen = 0; /* reset buffer to look at code */
                      state = CURL4NX_STATE_STATUSCODE;
                      break;
                    }

                  /* Not a space: accumulate chars */

                  tmpbuf[tmplen] = handle->rxbuf[rxoff];
                  tmplen++;
                  rxoff++;
                }

              /* Check for overflow,
               * version code should not fill the tmpbuf
               */

              if (tmplen == sizeof(tmpbuf))
                {
                  /* extremely long http version -> invalid response */

                  curl4nx_err("Buffer overflow while reading version\n");
                  cret = CURL4NXE_RECV_ERROR;
                  goto close;
                }

              /* No overflow and no space found: wait for next buffer */
            }

          /* NO ELSE HERE, state may have changed and require new management
           * for the same rx buffer.
           */

          if (state == CURL4NX_STATE_STATUSCODE)
            {
              /* Accumulate response code until space */

              while ((tmplen < sizeof(tmpbuf)) && (rxoff < ret))
                {
                  if (handle->rxbuf[rxoff] == ' ')
                    {
                      /* Found space after http version */

                      tmpbuf[tmplen] = 0; /* Finish pending string */
                      rxoff++;
                      curl4nx_info("received code: [%s]\n", tmpbuf);
                      handle->status = strtol(tmpbuf, &end, 10);

                      if (*end != 0)
                        {
                          curl4nx_err("Bad status code [%s]\n", tmpbuf);
                          cret = CURL4NXE_RECV_ERROR;
                          goto close;
                        }

                      tmplen = 0; /* reset buffer to look at code */
                      state = CURL4NX_STATE_STATUSREASON;
                      break;
                    }

                  /* Not a space: accumulate chars */

                  tmpbuf[tmplen] = handle->rxbuf[rxoff];
                  tmplen++;
                  rxoff++;
                }

              /* Check for overflow,
               * version code should not fill the tmpbuf
               */

              if (tmplen == sizeof(tmpbuf))
                {
                  /* Extremely long http code -> invalid response */

                  curl4nx_err("Buffer overflow while reading code\n");
                  cret = CURL4NXE_RECV_ERROR;
                  goto close;
                }

              /* No overflow and no space found: wait for next buffer */
            }

          if (state == CURL4NX_STATE_STATUSREASON)
            {
              /* Accumulate response code until CRLF */

              while (rxoff < ret)
                {
                  if (handle->rxbuf[rxoff] == 0x0d ||
                     handle->rxbuf[rxoff] == 0x0a)
                    {
                      /* Accumulate all contiguous CR and LF in any order */

                      tmpbuf[tmplen] = handle->rxbuf[rxoff];
                      tmplen++;
                      if (tmplen == 2)
                        {
                          if (tmpbuf[0] == 0x0d && tmpbuf[1] == 0x0a)
                            {
                              headerlen = 0;
                              handle->content_length = 0;
                              state = CURL4NX_STATE_HEADERS;
                              break;
                            }
                          else
                            {
                              tmplen = 0; /* Reset search for CRLF */
                            }
                        }
                    }
                  else
                    {
                      /* This char is not interesting: reset storage */

                      tmplen = 0;

                      /* curl4nx_info("-> %c\n", handle->rxbuf[rxoff]); */
                    }

                  rxoff++;
                }
            }

          if (state == CURL4NX_STATE_HEADERS)
            {
              while (rxoff < ret)
                {
                  if (handle->rxbuf[rxoff] == 0x0d ||
                     handle->rxbuf[rxoff] == 0x0a)
                    {
                      /* Accumulate all contiguous CR and LF in any order */

                      tmpbuf[tmplen] = handle->rxbuf[rxoff];
                      tmplen++;
                      if (tmplen == 2)
                        {
                          if (tmpbuf[0] == 0x0d && tmpbuf[1] == 0x0a)
                            {
                              if (headerlen == 0) /* Found an empty header */
                                {
                                  curl4nx_info("<End of headers>\n");
                                  rxoff++; /* Skip this char */
                                  state = chunked ?
                                           CURL4NX_STATE_DATA_CHUNKED :
                                           CURL4NX_STATE_DATA_NORMAL;
                                  break;
                                }
                              else
                                {
                                  int off;
                                  curl4nx_iofunc_f func;
                                  headerbuf[headerlen] = 0;
                                  func = handle->headerfunc;
                                  if (func == NULL)
                                    {
                                      func = handle->writefunc;
                                    }

                                  func(headerbuf, headerlen, 1,
                                       handle->headerdata);

                                  /* Find the content-length */

                                  if (curl4nx_is_header(headerbuf, headerlen,
                                                        "content-length:",
                                                        &off))
                                    {
                                      handle->content_length =
                                        strtoull(headerbuf + off, &end, 10);
                                      if (*end != 0)
                                        {
                                          curl4nx_err("Stray chars after "
                                                      "content length!\n");
                                          cret = CURL4NXE_RECV_ERROR;
                                          goto close;
                                        }

                                      curl4nx_info("Found content length: "
                                                   "%llu\n",
                                                   handle->content_length);
                                    }

                                  /* Find the transfer encoding */

                                  if (curl4nx_is_header(headerbuf, headerlen,
                                                        "transfer-encoding:",
                                                        &off))
                                    {
                                      chunked = !strncasecmp(headerbuf + off,
                                                             "chunked", 7);
                                      if (chunked)
                                        {
                                          curl4nx_info("Transfer using "
                                                       "chunked format\n");
                                        }
                                    }

                                  /* Find the location */

                                  if (curl4nx_is_header(headerbuf, headerlen,
                                                        "location:",
                                                        &off))
                                    {
                                      /* Parse the new URL if we get a
                                       * redirection code.
                                       */

                                      if (handle->status >= 300 &&
                                          handle->status < 400)
                                        {
                                          if (handle->flags &
                                             CURL4NX_FLAGS_FOLLOWLOCATION)
                                            {
                                              if ((handle->max_redirs > 0) &&
                                                  (redircount >=
                                                   handle->max_redirs))
                                                {
                                                  curl4nx_info(
                                                  "Too many redirections\n");
                                                  cret =
                                                 CURL4NXE_TOO_MANY_REDIRECTS;
                                                  goto close;
                                                }

                                              cret =
                                                curl4nx_easy_setopt(
                                                        handle,
                                                        CURL4NXOPT_URL,
                                                        headerbuf + off);
                                              if (cret != CURL4NXE_OK)
                                                {
                                                  goto close;
                                                }

                                              redirected = true;
                                              redircount += 1;
                                              curl4nx_info("\
                                                REDIRECTION (%d) -> %s\n",
                                                redircount,
                                                headerbuf + off);
                                            }
                                        }
                                    }

                                  /* Prepare for next header */

                                  headerlen = 0;
                                  tmplen    = 0; /* Reset search for CRLF */
                                }
                            }
                          else
                            {
                              tmplen = 0; /* Reset search for CRLF */
                            }
                        }
                    }
                  else
                    {
                      tmplen = 0; /* Reset CRLF detection */

                      /* Plus one for final zero */

                      if (headerlen < (CONFIG_LIBCURL4NX_MAXHEADERLINE - 1))
                        {
                          headerbuf[headerlen] = handle->rxbuf[rxoff];
                          headerlen++;
                        }
                      else
                        {
                          curl4nx_warn("prevented header overload\n");
                        }
                    }

                  rxoff++;
                }
            }

          if (state == CURL4NX_STATE_DATA_NORMAL)
            {
              if ((handle->flags & CURL4NX_FLAGS_FAILONERROR) &&
                   handle->status >= 400)
                {
                  cret = CURL4NXE_HTTP_RETURNED_ERROR;
                  goto close;
                }

              curl4nx_info("now in normal data state, rxoff=%d rxlen=%d\n",
                           rxoff, ret);
              done += (ret - rxoff);

              handle->writefunc(handle->rxbuf + rxoff, ret - rxoff, 1,
                                handle->writedata);
              if (handle->content_length != 0)
                {
                  curl4nx_info("Done %llu of %llu\n",
                               done, handle->content_length);

                  if (handle->progressfunc)
                    {
                      handle->progressfunc(handle->progressdata,
                                           handle->content_length,
                                           done, 0, 0);
                    }

                  if (handle->content_length == done)
                    {
                      /* Transfer is complete */

                      goto close;
                    }
                }
            }

          if (state == CURL4NX_STATE_DATA_CHUNKED)
            {
              if ((handle->flags & CURL4NX_FLAGS_FAILONERROR) &&
                  handle->status >= 400)
                {
                  cret = CURL4NXE_HTTP_RETURNED_ERROR;
                  goto close;
                }

              curl4nx_info("now in chunked data state, rxoff=%d rxlen=%d\n",
                           rxoff, ret);
              curl4nx_err("Not supported yet.\n");
              goto close;
            }
        }

      /* Done with this connection - this will also close the socket */

close:
      curl4nx_info("Closing\n");
      if (stream)
        {
          fclose(stream);
        }
    }
  while (redirected);

freebuf:
  free(headerbuf);

abort:
  curl4nx_info("done\n");
  return cret;
}