/** @file
  This file is cloned from DMTF libredfish library tag v1.0.0 and maintained
  by EDKII.

//----------------------------------------------------------------------------
// Copyright Notice:
// Copyright 2017 Distributed Management Task Force, Inc. All rights reserved.
// License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libredfish/LICENSE.md
//----------------------------------------------------------------------------

  Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
  (C) Copyright 2021 Hewlett Packard Enterprise Development LP<BR>

  SPDX-License-Identifier: BSD-2-Clause-Patent

**/
#include <redpath.h>

static char *
getVersion (
  const char  *path,
  char        **end
  );

static void
parseNode (
  const char   *path,
  redPathNode  *node,
  redPathNode  **end
  );

static char *
getStringTill (
  const char  *string,
  const char  *terminator,
  char        **retEnd
  );

redPathNode *
parseRedPath (
  const char  *path
  )
{
  redPathNode  *node;
  redPathNode  *endNode;
  char         *curPath;
  char         *end;

  if (!path || (strlen (path) == 0)) {
    return NULL;
  }

  node = (redPathNode *)calloc (1, sizeof (redPathNode));
  if (!node) {
    return NULL;
  }

  if (path[0] == '/') {
    node->isRoot = true;
    if (path[1] == 'v') {
      node->version = getVersion (path+1, &curPath);
      if (curPath == NULL) {
        return node;
      }

      if (curPath[0] == '/') {
        curPath++;
      }

      node->next = parseRedPath (curPath);
    } else {
      node->next = parseRedPath (path+1);
    }

    return node;
  }

  node->isRoot = false;
  curPath      = getStringTill (path, "/", &end);
  endNode      = node;
  parseNode (curPath, node, &endNode);
  free (curPath);
  if (end != NULL) {
    endNode->next = parseRedPath (end+1);
  }

  return node;
}

void
cleanupRedPath (
  redPathNode  *node
  )
{
  if (!node) {
    return;
  }

  cleanupRedPath (node->next);
  node->next = NULL;
  if (node->version) {
    free (node->version);
  }

  if (node->nodeName) {
    free (node->nodeName);
  }

  if (node->op) {
    free (node->op);
  }

  if (node->propName) {
    free (node->propName);
  }

  if (node->value) {
    free (node->value);
  }

  free (node);
}

static char *
getVersion (
  const char  *path,
  char        **end
  )
{
  return getStringTill (path, "/", end);
}

static void
parseNode (
  const char   *path,
  redPathNode  *node,
  redPathNode  **end
  )
{
  char    *indexStart;
  char    *index;
  char    *indexEnd;
  char    *nodeName = getStringTill (path, "[", &indexStart);
  size_t  tmpIndex;
  char    *opChars;

  node->nodeName = nodeName;
  if (indexStart == NULL) {
    *end = node;
    return;
  }

  node->next = (redPathNode *)calloc (1, sizeof (redPathNode));
  if (!node->next) {
    return;
  }

  // Skip past [
  indexStart++;
  *end     = node->next;
  index    = getStringTill (indexStart, "]", NULL);
  tmpIndex = (size_t)strtoull (index, &indexEnd, 0);
  if (indexEnd != index) {
    free (index);
    node->next->index   = tmpIndex;
    node->next->isIndex = true;
    return;
  }

  opChars = strpbrk (index, "<>=~");
  if (opChars == NULL) {
    // TODO handle last() and position()
    node->next->op       = strdup ("exists");
    node->next->propName = index;
    return;
  }

  node->next->propName = (char *)malloc ((opChars - index)+1);
  memcpy (node->next->propName, index, (opChars - index));
  node->next->propName[(opChars - index)] = 0;

  tmpIndex = 1;
  while (1) {
    if ((opChars[tmpIndex] == '=') || (opChars[tmpIndex] == '<') || (opChars[tmpIndex] == '>') || (opChars[tmpIndex] == '~')) {
      tmpIndex++;
      continue;
    }

    break;
  }

  node->next->op = (char *)malloc (tmpIndex+1);
  memcpy (node->next->op, opChars, tmpIndex);
  node->next->op[tmpIndex] = 0;

  node->next->value = strdup (opChars+tmpIndex);
  free (index);
}

static char *
getStringTill (
  const char  *string,
  const char  *terminator,
  char        **retEnd
  )
{
  char  *ret;
  char  *end;

  end = strstr ((char *)string, terminator);
  if (retEnd) {
    *retEnd = end;
  }

  if (end == NULL) {
    // No terminator
    return strdup (string);
  }

  ret = (char *)malloc ((end-string)+1);
  memcpy (ret, string, (end-string));
  ret[(end-string)] = 0;
  return ret;
}