/**
 @file list.c
 @brief ENet linked list functions
*/
#define ENET_BUILDING_LIB 1
#include "enet/enet.h"

#include <stdio.h>
#include <string.h>

// http://rosettacode.org/wiki/Parse_an_IP_Address#C

static unsigned int _parseDecimal(const char **pchCursor) {
  unsigned int nVal = 0;
  char chNow;
  while (chNow = **pchCursor, chNow >= '0' && chNow <= '9') {
    // shift digit in
    nVal *= 10;
    nVal += chNow - '0';

    ++*pchCursor;
  }
  return nVal;
}

static unsigned int _parseHex(const char **pchCursor) {
  unsigned int nVal = 0;
  char chNow;
  while (chNow = **pchCursor & 0x5f, //(collapses case, but mutilates digits)
         (chNow >= ('0' & 0x5f) && chNow <= ('9' & 0x5f)) ||
             (chNow >= 'A' && chNow <= 'F')) {
    unsigned char nybbleValue;
    chNow -= 0x10; // scootch digital values down; hex now offset by x31
    nybbleValue = (chNow > 9 ? chNow - (0x31 - 0x0a) : chNow);
    // shift nybble in
    nVal <<= 4;
    nVal += nybbleValue;

    ++*pchCursor;
  }
  return nVal;
}

// Parse a textual IPv4 or IPv6 address, optionally with port, into a binary
// array (for the address, in network order), and an optionally provided port.
// Also, indicate which of those forms (4 or 6) was parsed.  Return true on
// success.  ppszText must be a nul-terminated ASCII string.  It will be
// updated to point to the character which terminated parsing (so you can carry
// on with other things.  abyAddr must be 16 bytes.  You can provide NULL for
// abyAddr, nPort, bIsIPv6, if you are not interested in any of those
// informations.  If we request port, but there is no port part, then nPort will
// be set to 0.  There may be no whitespace leading or internal (though this may
// be used to terminate a successful parse.
// Note:  the binary address and integer port are in network order.
static int ParseIPv4OrIPv6(const char **ppszText, enet_uint8 *abyAddr,
                           enet_uint16 *pnPort, int *pbIsIPv6) {
  unsigned char *abyAddrLocal;
  unsigned char abyDummyAddr[16];

  // find first colon, dot, and open bracket
  const char *pchColon = strchr(*ppszText, ':');
  const char *pchDot = strchr(*ppszText, '.');
  const char *pchOpenBracket = strchr(*ppszText, '[');
  const char *pchCloseBracket = NULL;

  // we'll consider this to (probably) be IPv6 if we find an open
  // bracket, or an absence of dots, or if there is a colon, and it
  // precedes any dots that may or may not be there
  int bIsIPv6local =
      NULL != pchOpenBracket || NULL == pchDot ||
      (NULL != pchColon && (NULL == pchDot || pchColon < pchDot));
  // OK, now do a little further sanity check our initial guess...
  if (bIsIPv6local) {
    // if open bracket, then must have close bracket that follows somewhere
    pchCloseBracket = strchr(*ppszText, ']');
    if (NULL != pchOpenBracket &&
        (NULL == pchCloseBracket || pchCloseBracket < pchOpenBracket))
      return 0;
  } else // probably ipv4
  {
    // dots must exist, and precede any colons
    if (NULL == pchDot || (NULL != pchColon && pchColon < pchDot))
      return 0;
  }

  // we figured out this much so far....
  if (NULL != pbIsIPv6)
    *pbIsIPv6 = bIsIPv6local;

  // especially for IPv6 (where we will be decompressing and validating)
  // we really need to have a working buffer even if the caller didn't
  // care about the results.
  abyAddrLocal = abyAddr;   // prefer to use the caller's
  if (NULL == abyAddrLocal) // but use a dummy if we must
    abyAddrLocal = abyDummyAddr;

  // OK, there should be no correctly formed strings which are miscategorized,
  // and now any format errors will be found out as we continue parsing
  // according to plan.
  if (!bIsIPv6local) // try to parse as IPv4
  {
    // 4 dotted quad decimal; optional port if there is a colon
    // since there are just 4, and because the last one can be terminated
    // differently, I'm just going to unroll any potential loop.
    unsigned char *pbyAddrCursor = abyAddrLocal;
    unsigned int nVal;
    const char *pszTextBefore = *ppszText;
    nVal = _parseDecimal(ppszText); // get first val
    if ('.' != **ppszText || nVal > 255 ||
        pszTextBefore ==
            *ppszText) // must be in range and followed by dot and nonempty
      return 0;
    *(pbyAddrCursor++) = (unsigned char)nVal; // stick it in addr
    ++(*ppszText);                            // past the dot

    pszTextBefore = *ppszText;
    nVal = _parseDecimal(ppszText); // get second val
    if ('.' != **ppszText || nVal > 255 || pszTextBefore == *ppszText)
      return 0;
    *(pbyAddrCursor++) = (unsigned char)nVal;
    ++(*ppszText); // past the dot

    pszTextBefore = *ppszText;
    nVal = _parseDecimal(ppszText); // get third val
    if ('.' != **ppszText || nVal > 255 || pszTextBefore == *ppszText)
      return 0;
    *(pbyAddrCursor++) = (unsigned char)nVal;
    ++(*ppszText); // past the dot

    pszTextBefore = *ppszText;
    nVal = _parseDecimal(ppszText); // get fourth val
    if (nVal > 255 ||
        pszTextBefore ==
            *ppszText) //(we can terminate this one in several ways)
      return 0;
    *(pbyAddrCursor++) = (unsigned char)nVal;

    if (':' == **ppszText && NULL != pnPort) // have port part, and we want it
    {
      ++(*ppszText); // past the colon
      pszTextBefore = *ppszText;
      nVal = _parseDecimal(ppszText);
      if (nVal > 65535 || pszTextBefore == *ppszText)
        return 0;

      *pnPort = (enet_uint16)nVal;
      return 1;
    } else // finished just with ip address
    {
      if (NULL != pnPort)
        *pnPort = 0; // indicate we have no port part
      return 1;
    }
  } else // try to parse as IPv6
  {
    unsigned char *pbyAddrCursor;
    unsigned char *pbyZerosLoc;
    int bIPv4Detected;
    int nIdx;
    // up to 8 16-bit hex quantities, separated by colons, with at most one
    // empty quantity, acting as a stretchy run of zeroes.  optional port
    // if there are brackets followed by colon and decimal port number.
    // A further form allows an ipv4 dotted quad instead of the last two
    // 16-bit quantities, but only if in the ipv4 space ::ffff:x:x .
    if (NULL != pchOpenBracket) // start past the open bracket, if it exists
      *ppszText = pchOpenBracket + 1;
    pbyAddrCursor = abyAddrLocal;
    pbyZerosLoc = NULL; // if we find a 'zero compression' location
    bIPv4Detected = 0;
    for (nIdx = 0; nIdx < 8;
         ++nIdx) // we've got up to 8 of these, so we will use a loop
    {
      const char *pszTextBefore = *ppszText;
      unsigned nVal = _parseHex(ppszText); // get value; these are hex
      if (pszTextBefore ==
          *ppszText) // if empty, we are zero compressing; note the loc
      {
        if (NULL != pbyZerosLoc) // there can be only one!
        {
          // unless it's a terminal empty field, then this is OK, it just means
          // we're done with the host part
          if (pbyZerosLoc == pbyAddrCursor) {
            --nIdx;
            break;
          }
          return 0; // otherwise, it's a format error
        }
        if (':' != **ppszText) // empty field can only be via :
          return 0;
        if (0 == nIdx) // leading zero compression requires an extra peek, and
                       // adjustment
        {
          ++(*ppszText);
          if (':' != **ppszText)
            return 0;
        }

        pbyZerosLoc = pbyAddrCursor;
        ++(*ppszText);
      } else {
        if ('.' == **ppszText) // special case of ipv4 convenience notation
        {
          // who knows how to parse ipv4?  we do!
          const char *pszTextlocal = pszTextBefore; // back it up
          unsigned char abyAddrlocal[16];
          int bIsIPv6local;
          int bParseResultlocal =
              ParseIPv4OrIPv6(&pszTextlocal, abyAddrlocal, NULL, &bIsIPv6local);
          *ppszText =
              pszTextlocal; // success or fail, remember the terminating char
          if (!bParseResultlocal || bIsIPv6local) // must parse and must be ipv4
            return 0;
          // transfer addrlocal into the present location
          *(pbyAddrCursor++) = abyAddrlocal[0];
          *(pbyAddrCursor++) = abyAddrlocal[1];
          *(pbyAddrCursor++) = abyAddrlocal[2];
          *(pbyAddrCursor++) = abyAddrlocal[3];
          ++nIdx; // pretend like we took another short, since the ipv4
                  // effectively is two shorts
          bIPv4Detected =
              1; // remember how we got here for further validation later
          break; // totally done with address
        }

        if (nVal > 65535) // must be 16 bit quantity
          return 0;
        *(pbyAddrCursor++) = nVal >> 8; // transfer in network order
        *(pbyAddrCursor++) = nVal & 0xff;
        if (':' == **ppszText) // typical case inside; carry on
        {
          ++(*ppszText);
        } else // some other terminating character; done with this parsing parts
        {
          break;
        }
      }
    }

    // handle any zero compression we found
    if (NULL != pbyZerosLoc) {
      int nHead =
          (int)(pbyZerosLoc - abyAddrLocal); // how much before zero compression
      int nTail =
          nIdx * 2 -
          (int)(pbyZerosLoc - abyAddrLocal); // how much after zero compression
      int nZeros = 16 - nTail - nHead;       // how much zeros
      memmove(&abyAddrLocal[16 - nTail], pbyZerosLoc,
              nTail);                 // scootch stuff down
      memset(pbyZerosLoc, 0, nZeros); // clear the compressed zeros
    }

    // validation of ipv4 subspace ::ffff:x.x
    if (bIPv4Detected) {
      static const unsigned char abyPfx[] = {0, 0, 0, 0, 0,    0,
                                             0, 0, 0, 0, 0xff, 0xff};
      if (0 != memcmp(abyAddrLocal, abyPfx, sizeof(abyPfx)))
        return 0;
    }

    // close bracket
    if (NULL != pchOpenBracket) {
      if (']' != **ppszText)
        return 0;
      ++(*ppszText);
    }

    if (':' == **ppszText && NULL != pnPort) // have port part, and we want it
    {
      const char *pszTextBefore;
      unsigned int nVal;
      ++(*ppszText); // past the colon
      pszTextBefore = *ppszText;
      pszTextBefore = *ppszText;
      nVal = _parseDecimal(ppszText);
      if (nVal > 65535 || pszTextBefore == *ppszText)
        return 0;

      *pnPort = (enet_uint16)nVal;
      return 1;
    } else // finished just with ip address
    {
      if (NULL != pnPort)
        *pnPort = 0; // indicate we have no port part
      return 1;
    }
  }
}

int enet_address_equal_host(const ENetAddress *firstAddress,
                            const ENetAddress *secondAddress) {
  if (firstAddress->type != secondAddress->type)
    return 0;

  if (firstAddress->port != secondAddress->port)
    return 0;

  if (firstAddress->type == ENET_ADDRESS_TYPE_IPV4) {
    if (memcmp(&firstAddress->host.v4[0], &secondAddress->host.v4[0],
               4 * sizeof(enet_uint8)) != 0)
      return 0;
  } else if (firstAddress->type == ENET_ADDRESS_TYPE_IPV6) {
    if (memcmp(&firstAddress->host.v6[0], &secondAddress->host.v6[0],
               8 * sizeof(enet_uint16)) != 0)
      return 0;
  }

  return 1;
}

int enet_address_equal(const ENetAddress *firstAddress,
                       const ENetAddress *secondAddress) {
  if (!enet_address_equal_host(firstAddress, secondAddress))
    return 0;

  if (firstAddress->port != secondAddress->port)
    return 0;

  return 1;
}

int enet_address_is_any(const ENetAddress *address) {
  switch (address->type) {
  case ENET_ADDRESS_TYPE_IPV4: {
    enet_uint8 zero[4] = {0};
    return memcmp(&address->host.v4[0], zero, 4 * sizeof(enet_uint8)) != 0;
  }

  case ENET_ADDRESS_TYPE_IPV6: {
    enet_uint16 zero[8] = {0};
    return memcmp(&address->host.v6[0], zero, 8 * sizeof(enet_uint16)) != 0;
  }

  default:
    break;
  }

  return 0;
}

int enet_address_is_broadcast(const ENetAddress *address) {
  /* there's no broadcast address in ipv6 */
  if (address->type == ENET_ADDRESS_TYPE_IPV4 && address->host.v4[0] == 0xFF &&
      address->host.v4[1] == 0xFF && address->host.v4[2] == 0xFF &&
      address->host.v4[3] == 0xFF) {
    return 1;
  }

  return 0;
}

int enet_address_is_loopback(const ENetAddress *address) {
  switch (address->type) {
  case ENET_ADDRESS_TYPE_IPV4:
    return address->host.v4[0] == 127;

  case ENET_ADDRESS_TYPE_IPV6: {
    enet_uint16 loopback[8] = {0, 0, 0, 0, 0, 0, 0, 1};
    return memcmp(&address->host.v6[0], loopback, 8 * sizeof(enet_uint16)) != 0;
  }

  default:
    break;
  }

  return 0;
}

int enet_address_get_host_ip(const ENetAddress *address, char *name,
                             size_t nameLength) {
  enum MaxSize {
    MS_PortPart = 1 + 4, /* semicolon + 4 digits */

    MS_IPv4 = 4 * 3 + 3 +
              1, /* 4 * 3 digits plus three dots plus end of string character */
    MS_IPv4MappedIPv6 =
        7 + 4 * 3 + 3 + 1, /* prefix + 4 * 3 digits plus three dots plus end of
                              string character */
    MS_IPv6 = 8 * 4 + 7 +
              1, /* 4 * 3 digits plus three dots plus end of string character */

    MS_IPv4WithPort = MS_IPv4 + MS_PortPart,
    MS_IPv4MappedIPv6WithPort =
        MS_IPv4MappedIPv6 + MS_PortPart + 2,     /* plus two brackets */
    MS_IPv6WithPort = MS_IPv6 + MS_PortPart + 2, /* plus two brackets */
  };

  if (address->type == ENET_ADDRESS_TYPE_IPV4) {
    if (address->port != 0) {
      if (nameLength < MS_IPv4WithPort)
        return -1;

      sprintf(name, "%u.%u.%u.%u:%u", address->host.v4[0], address->host.v4[1],
              address->host.v4[2], address->host.v4[3], address->port);
    } else {
      if (nameLength < MS_IPv4)
        return -1;

      sprintf(name, "%u.%u.%u.%u", address->host.v4[0], address->host.v4[1],
              address->host.v4[2], address->host.v4[3]);
    }
  } else if (address->type == ENET_ADDRESS_TYPE_IPV6) {
    /* check if ipv4-mapped address */
    if (address->host.v6[0] == 0 && address->host.v6[1] == 0 &&
        address->host.v6[2] == 0 && address->host.v6[3] == 0 &&
        address->host.v6[4] == 0 && address->host.v6[5] == 0xFFFF) {
      if (address->port != 0) {
        if (nameLength < MS_IPv4MappedIPv6WithPort)
          return -1;

        sprintf(name, "[::ffff:%u.%u.%u.%u]:%u",
                (address->host.v6[6] >> 8) & 0xFF,
                (address->host.v6[6] >> 0) & 0xFF,
                (address->host.v6[7] >> 8) & 0xFF,
                (address->host.v6[7] >> 0) & 0xFF, address->port);
      } else {
        if (nameLength < MS_IPv4MappedIPv6)
          return -1;

        sprintf(name, "::ffff:%u.%u.%u.%u", (address->host.v6[6] >> 8) & 0xFF,
                (address->host.v6[6] >> 0) & 0xFF,
                (address->host.v6[7] >> 8) & 0xFF,
                (address->host.v6[7] >> 0) & 0xFF);
      }
    } else {
      /* standard IPv6
       * canonical representation of an IPv6
       * https://tools.ietf.org/html/rfc5952
       */

      const size_t maxSize =
          8 * 4 + 7 +
          1; /* 4 * 3 digits plus three dots plus end of string character */
      char buffer[MS_IPv6WithPort];

      /* find the longest zero sequence */
      int f0 = -1;
      int l0 = -1;
      int i, j;
      char *p = buffer;
      int advance;

      for (i = 0; i < 8; ++i) {
        if (address->host.v6[i] == 0) {
          for (j = i + 1; j < 8; ++j) {
            if (address->host.v6[j] != 0)
              break;
          }

          if (f0 == -1 || j - i > l0 - f0) {
            f0 = i;
            l0 = j;
          }
        }
      }

      /* We need brackets around our IPv6 address if we have a port */
      if (address->port != 0)
        *p++ = '[';

      for (i = 0; i < 8; ++i) {
        if (i == f0) {
          *p++ = ':';
          *p++ = ':';

          i = l0;
          if (i >= 8)
            break;
        } else if (i != 0)
          *p++ = ':';

        advance = sprintf(p, "%x", address->host.v6[i]);
        p += advance;
      }

      if (address->port != 0) {
        *p++ = ']';
        *p++ = ':';

        advance = sprintf(p, "%u", address->port);
        p += advance;
      }

      *p++ = '\0';

      size_t addrLen = p - buffer;
      if (nameLength < addrLen)
        return -1;

      memcpy(name, buffer, addrLen);
    }
  }

  return 0;
}

int enet_address_set_host_ip(ENetAddress *address, const char *name) {
  enet_uint8 result[16];
  int isIPv6;
  int i;
  enet_uint16 port;

  if (!ParseIPv4OrIPv6(&name, result, &port, &isIPv6))
    return -1;

  if (isIPv6) {
    address->type = ENET_ADDRESS_TYPE_IPV6;

    for (i = 0; i < 8; ++i)
      address->host.v6[i] = (result[i * 2] << 8) | result[i * 2 + 1];
  } else {
    address->type = ENET_ADDRESS_TYPE_IPV4;

    for (i = 0; i < 4; ++i)
      address->host.v4[i] = result[i];
  }

  if (port)
    address->port = port;

  return 0;
}

void enet_address_build_any(ENetAddress *address, ENetAddressType type) {
  address->type = type;

  switch (type) {
  case ENET_ADDRESS_TYPE_IPV4: {
    memset(&address->host.v4, 0, sizeof(address->host.v4));
    // address->port = ENET_PORT_ANY;
    break;
  }

  case ENET_ADDRESS_TYPE_IPV6: {
    memset(&address->host.v6, 0, sizeof(address->host.v6));
    // address->port = ENET_PORT_ANY;
    break;
  }

  default:
    break;
  }
}

void enet_address_build_loopback(ENetAddress *address, ENetAddressType type) {
  address->type = type;

  switch (type) {
  case ENET_ADDRESS_TYPE_IPV4: {
    enet_uint8 loopbackIpV4[4] = {127, 0, 0, 1};

    memcpy(&address->host.v4, loopbackIpV4, sizeof(address->host.v4));
    address->port = ENET_PORT_ANY;
    break;
  }

  case ENET_ADDRESS_TYPE_IPV6: {
    enet_uint16 loopbackIpV6[8] = {0, 0, 0, 0, 0, 0, 0, 1};

    memcpy(&address->host.v6, loopbackIpV6, sizeof(address->host.v6));
    address->port = ENET_PORT_ANY;
    break;
  }

  default:
    break;
  }
}

void enet_address_convert_ipv6(ENetAddress *address) {
  enet_uint8 ipv4[4];

  if (address->type == ENET_ADDRESS_TYPE_IPV4) {
    /* Turn into IPv4-mapped IPv6 */
    address->type = ENET_ADDRESS_TYPE_IPV6;
    memcpy(&ipv4[0], &address->host.v4[0],
           4 * sizeof(enet_uint8)); /* save IPv4 before modifying the IPv6
                                       because of the union */

    address->host.v6[0] = 0;
    address->host.v6[1] = 0;
    address->host.v6[2] = 0;
    address->host.v6[3] = 0;
    address->host.v6[4] = 0;
    address->host.v6[5] = 0xFFFF;
    address->host.v6[6] = ((enet_uint16)ipv4[0]) << 8 | ipv4[1];
    address->host.v6[7] = ((enet_uint16)ipv4[2]) << 8 | ipv4[3];
  }
}

/** @} */