/*
 * xmlParser for picoC on Loxone
 *
 * Andrej Konkow 03/2026  v01
 */

// Maximum number of xml elements/tags in pool.
#define XML_MAX_ELEMENTS 750

// Maximum number of xml elements/tags in pool.
#define XML_MAX_ATTRIBUTES_PER_ELEMENT 5

// Maximum length of char content for text, cdata etc.
#define XML_MAX_TAG_CHAR_CONTENT 25

// Maximum values to be addressed for printing by the user
// We have 13 numeric channels and 2 channels for string data output
#define MAXCHANNELS 13+2

// "Points" to no element
#define XML_NO_ELEMENT -1

#define XML_PARSER_ERROR -2

#define PICOXML_ERRORLEN  250    // maximum error string length

#define INPUT_HTTP_SERVER    getinputtext(0)
#define INPUT_HTTP_PAGE      getinputtext(1)
#define INPUT_XML_QUERY      getinputtext(2)
#define INPUT_ITERATION_WAIT_SEC getinput(0)

// Pseudovalue for identfying a "no param"
#define STRING_NOPARAM    -99999

enum xml_datatype
{
  DT_NONE   = 0,
  DT_INT    = 1,
  DT_FLOAT  = 2,
  DT_BOOL   = 3,
  DT_STRING = 4
};

/*
  Holds information about a specified value
*/
struct xml_query
{
  char *name;
  int  arrayindex;
  int  datatype;

  char *attribute[XML_MAX_ATTRIBUTES_PER_ELEMENT];
  char *value[XML_MAX_ATTRIBUTES_PER_ELEMENT];

  struct xml_query *oneDeeper;
  struct xml_query *parent;
};

/*
 * Attribute data inside of a xml tag.
 */
struct xmlAttribute
{
  char *name;
  char *value;
};

struct picoXml {
  char      *name;     // tag name
  short     sizeAttr;    // size of attr-list
  
  struct xmlAttribute szAttr[XML_MAX_ATTRIBUTES_PER_ELEMENT];  // tag attributes with name/value

  char  txt[XML_MAX_TAG_CHAR_CONTENT+1];  // tag character content, empty string if none, For safety one more with a terminating '\0'
  char  isCDATA;         // Flag for being CDATA data

  short off;             // tag offset from start of parent tag character content
  short next;            // next tag with same name in this section at this depth
  short sibling;         // next tag with different name in same section and depth
  short child;           // head of sub tag list, NULL if none
  short parent;          // parent tag, NULL if current tag is root tag
};

struct parserData
{
  short rootElement;    // Holds the root XML structure
  short current;
  short elementsInUse;

  char *xmlBeg;       // beginning of xml string

  int  gotError;      // Flagged with 1 if a parsing error occurred
  char errorMsg[100]; // In case holds the errormsg
  char *errorAdd;     // Additional error information pointing to inside of xml
};
struct parserData parser;

// "Allocated" pool of tags and attributes for usage in picoC as malloc is problematic
static struct picoXml szAllElements[XML_MAX_ELEMENTS];


// Maps for making efficient decisions
static char MapIsEOL[127];
static char MapIsWhitespace[127];
static char MapIsAlphabetic[127];
static char MapIsWsAndEq[127];
static char MapIsWsAndEqSlGr[127];
static char MapIsWsAndEqSQuoDQuo[127];
static char MapIsWsAndGr[127];
static char MapIsWsAndSlGr[127];
static char MapIsBrOBrOGr[127];
static char MapIsPrimitive[127];

/*
  Helperfunctions for initialization
*/
void initMapWithWhitespaces(char *map)
{
  memset(map, 0, 127);
  map[0]    = 1;
  map[' ']  = 1;
  map['\n'] = 1;
  map['\r'] = 1;
  map['\v'] = 1;
  map['\f'] = 1;
  map['\t'] = 1;
}
void initMapIsWhitespace() {
  initMapWithWhitespaces(MapIsWhitespace);

}
void initMapIsWsAndEq() {
  initMapWithWhitespaces(MapIsWsAndEq);
  MapIsWsAndEq['='] = 1;
}
void initMapIsWsAndEqSlGr() {
  initMapWithWhitespaces(MapIsWsAndEqSlGr);
  MapIsWsAndEqSlGr['='] = 1;
  MapIsWsAndEqSlGr['/'] = 1;
  MapIsWsAndEqSlGr['>'] = 1;
}
void initMapIsWsAndEqSQuoDQuo() {
  initMapWithWhitespaces(MapIsWsAndEqSQuoDQuo);
  MapIsWsAndEqSQuoDQuo['='] = 1;
  MapIsWsAndEqSQuoDQuo['\''] = 1;
  MapIsWsAndEqSQuoDQuo['"'] = 1;
}
void initMapIsWsAndGr() {
  initMapWithWhitespaces(MapIsWsAndGr);
  MapIsWsAndGr['>'] = 1;
}
void initMapIsWsAndSlGr() {
  initMapWithWhitespaces(MapIsWsAndSlGr);
  MapIsWsAndSlGr['/'] = 1;
  MapIsWsAndSlGr['>'] = 1;
}
void initMapIsBrOBrOGr() {
  memset(MapIsBrOBrOGr, 0, 127);
  MapIsBrOBrOGr['['] = 1;
  MapIsBrOBrOGr[']'] = 1;
  MapIsBrOBrOGr['>'] = 1;
}
void initMapIsAlphabetic() {
  memset(MapIsAlphabetic, 0, 127);

  int i;
  for (i='a'; i<='z'; i++) MapIsAlphabetic[i] = 1;
  for (i='A'; i<='Z'; i++) MapIsAlphabetic[i] = 1;
}
void initMapIsEOL()
{
  initMapWithWhitespaces(MapIsEOL);
  MapIsEOL[' ']  = 0;
}
void initMapIsPrimitive()
{
  int i;

  memset(MapIsPrimitive, 0, 127);

  for (i='a'; i<='z'; i++) MapIsPrimitive[i] = 1;
  for (i='A'; i<='Z'; i++) MapIsPrimitive[i] = 1;
  for (i='0'; i<='9'; i++) MapIsPrimitive[i] = 1;
  MapIsPrimitive['.'] = 1;
  MapIsPrimitive['-'] = 1;
}
void initMaps()
{
  initMapIsWhitespace();
  initMapIsWsAndEq();
  initMapIsWsAndEqSlGr();
  initMapIsWsAndEqSQuoDQuo();
  initMapIsWsAndGr();
  initMapIsWsAndSlGr();
  initMapIsBrOBrOGr();
  initMapIsAlphabetic();
  initMapIsEOL();
  initMapIsPrimitive();
}
// Initialize immediately
initMaps();

/*
  Initialize a xml_query element
*/
void initElement(struct xml_query *element, struct xml_query *parent, int dt)
{
  memset(element, 0, sizeof(struct xml_query));
  element->datatype   = dt;
  element->parent     = parent;
}

/*
  Helperfunctions for messaging output
*/
void messageParam   (char *msg, int val)        { messageParamTimed     (msg, val, 1000); }
void messageParamTimed(char *msg, int val, int sleepMs) { messageParamTimedChannel(msg, val, sleepMs, 0); }
void messageParamTimedChannel(char *msg, int val, int sleepMs, int channel)
{
  if (val == STRING_NOPARAM)
    setoutputtext(channel, msg);
  else
  {
    char szOutMsg[150];

    sprintf(szOutMsg,"%s %d", msg, val);
    setoutputtext(channel, szOutMsg);
  }

  if (sleepMs > 0)
    sleep(sleepMs);
}

/*
  Print error messages and return an error code
*/
int picoXml_err   (char *s, char *err) { return picoXml_errParam(s, err, "\n"); }
int picoXml_errParam(char *s, char *err, char *param)
{
  char fmt[PICOXML_ERRORLEN];

  int len_err   = 0,
      len_param = 0;

  if (err   != NULL) len_err   = strlen(err);
  if (param != NULL) len_param = strlen(param);

  memset(fmt, 0, PICOXML_ERRORLEN);
  if (len_err)   strncpy(fmt,                   err, PICOXML_ERRORLEN);
  if (len_param) strncpy(&fmt[len_err],       param, PICOXML_ERRORLEN-len_err);
  if (s != NULL) strncpy(&fmt[len_err+len_param], s, PICOXML_ERRORLEN-len_err-len_param);

  messageParamTimedChannel(fmt, STRING_NOPARAM, 1000, 1);

  return XML_PARSER_ERROR;
}

// Sets a parser error msg and returns NULL
char *setParserErrorParamChar(char *errorMsg, char *errorAdd, char c)
{
  sprintf(parser.errorMsg, "%s%c", errorMsg, c);
  return setParserErrorNoParam(parser.errorMsg, errorAdd);
}

// Sets a parser error msg and returns NULL
char *setParserErrorNoParam(char *errorMsg, char *errorAdd)
{
    parser.gotError = 1;
    parser.errorAdd = errorAdd;

    sprintf(parser.errorMsg, "%s", errorMsg);
    return NULL;
}

/*
  "Allocate" new element for usage. Returns pool index of new, initialized element
  Returns XML_NO_ELEMENT if pool is exhausted.
*/
int addNewElement()
{
  int newIdx = parser.elementsInUse;

  if (newIdx == XML_MAX_ELEMENTS)
  {
    parser.gotError = 1;
    sprintf(parser.errorMsg, "Tag pool too small: %d. Increase param XML_MAX_ELEMENTS", XML_MAX_ELEMENTS);
    return XML_NO_ELEMENT;
  }

  parser.elementsInUse++;
  struct picoXml *theElement = &szAllElements[newIdx];

  theElement->next    = XML_NO_ELEMENT;
  theElement->sibling = XML_NO_ELEMENT;
  theElement->child   = XML_NO_ELEMENT;
  theElement->parent  = XML_NO_ELEMENT;
  theElement->isCDATA = 0;

  memset(theElement->txt, 0, XML_MAX_TAG_CHAR_CONTENT+1);

  return newIdx;
}

/*
  "Adds" an attribute to an element by taking it out of the pool.
  Returns NULL if pool is exhausted.
*/
struct xmlAttribute *addNewAttribute(struct picoXml *element, char *name, char *value)
{
  if (element->sizeAttr == XML_MAX_ATTRIBUTES_PER_ELEMENT)
  {
    parser.gotError = 1;
    sprintf(parser.errorMsg, "Attribute pool too small: %d. Increase param XML_MAX_ATTRIBUTES_PER_ELEMENT", XML_MAX_ATTRIBUTES_PER_ELEMENT);
    return NULL;
  }

  struct xmlAttribute *newAttr = &element->szAttr[element->sizeAttr];
  element->sizeAttr++;

  newAttr->name  = name;
  newAttr->value = value;

  return newAttr;
};

/*
  First initialization of parser data
*/
void initParser()
{
  memset(&parser,       0, sizeof(struct parserData));
  memset(szAllElements, 0, sizeof(struct picoXml) * XML_MAX_ELEMENTS);

  parser.rootElement = addNewElement();
  parser.current     = parser.rootElement;
}

/*
  Handle opening tag
*/
int picoXml_openTag(char *name, struct xmlAttribute *attrList, int sizeAttrList)
{
  struct picoXml      *element;
  struct xmlAttribute *attr;
  int i, xml = parser.current, child=0;

  element = &szAllElements[xml];
  if (element->name != NULL)
  {
    picoXml_add_child(xml, name, strlen(element->txt), &child);
    xml = child;
  }
  else
    element->name = name; // first open tag

  if (xml == XML_NO_ELEMENT)
    return XML_PARSER_ERROR;

  parser.current = xml;

  if (sizeAttrList == 0)
    return 1;

  element = &szAllElements[xml];
  for (i=0; i<sizeAttrList; i++)
  {
    attr = &attrList[i];

    if (addNewAttribute(element, attr->name, attr->value) == NULL)
      return XML_PARSER_ERROR;
  }

  return 1;
}

/*
  Handle characters between open and closing tag
*/
void picoXml_handleCharacters(char *s, int len, char t)
{
  struct picoXml *element;
  int txtlen;

  if (parser.current == XML_NO_ELEMENT)
    return;

  element = &szAllElements[parser.current];
  if (element->name == NULL || len == 0)
    return;

  s[len] = 0;

  txtlen = strlen(element->txt);
  if (txtlen < XML_MAX_TAG_CHAR_CONTENT)      // add space limited char content
    strncpy(&element->txt[txtlen], s, XML_MAX_TAG_CHAR_CONTENT-txtlen);

  if (t == 'c')
    element->isCDATA = 1;
}


/*
  Handle closing tag
*/
int picoXml_close_tag(char *name, char *s)
{
  if (parser.current == XML_NO_ELEMENT)
    return picoXml_errParam(s, "unexpected closing tag </ >: ", name);

  struct picoXml *cur_element = &szAllElements[parser.current];
  if (cur_element->name == NULL || strcmp(name, cur_element->name))
    return picoXml_errParam(s, "unexpected closing tag </ >: ", name);

  parser.current = cur_element->parent;

  return XML_NO_ELEMENT;
}

// parse the given xml string and return the root index
void picoXml_parseString(char *s, int *root)
{
  char q, e, *d;
  int  cnt, len;

  len = strlen(s);
  if (len == 0)
  {
      *root = picoXml_err(NULL, "No XML to parse.");
      return;
  }

  parser.xmlBeg = s;

  e = s[len - 1];   
  s[len - 1] = 0;   

  while (*s && *s != '<') // go to first tag
    s++;

  if (! *s)
  {
    *root = picoXml_err(s, "root tag missing");
    return;
  }
  
  while (TRUE)
  {
    parser.gotError = 0;
    parser.errorAdd = NULL;
    s++;
    d = s;
    if (MapIsAlphabetic[*s] || *s == '_' || *s == ':') {
      if (parser.current == XML_NO_ELEMENT)
      {
        *root = picoXml_err(d, "markup outside of root element");
        return;
      }

      s = handleNewTag(s, d, e);
    }
    else if (*s == '/') {
      s = handleClosingTag(s, e);
    }
    else if (! strncmp(s, "!--", 3)) 
    { 
      s = strstr(s + 3, "--");

      if (s == NULL)
      {
        *root = picoXml_err(d, "unclosed <!--");
        return;
      }

      s += 2;
      if ((*s!=0 && *s != '>') || (*s==0 && e != '>'))
      {
        *root = picoXml_err(d, "unclosed <!--");
        return;
      }
    }
    else if (! strncmp(s, "![CDATA[", 8)) { // cdata, not dedicated for output again, just parsing
      s = strstr(s, "]]>");

      if (s == NULL)
      {
        *root = picoXml_err(d, "unclosed <![CDATA[");
        return;
      }

      s += 2;
      picoXml_handleCharacters(d + 8, s - d - 10, 'c');
    }
    else if (! strncmp(s, "!DOCTYPE", 8))
    {
      cnt = 0;
      s = ignoreDoctype(s, d, e, &cnt);
      d += cnt;

      if ( s == NULL)
      {
        *root = picoXml_err(d, "unclosed <!DOCTYPE");
        return;
      }
      if (*s == 0)  
      {
        *root = picoXml_err(d, "unclosed <!DOCTYPE");
        return;
      }
    }
    else if (*s == '?')
    {
      s = ignoreProcessingInstructions(s);

      if (*s == 0)
      {
        *root = picoXml_err(d, "unclosed <?");
        return;
      }
    }   
    else if (s-parser.xmlBeg != len)
    {
      if (parser.xmlBeg-d < 0 || parser.xmlBeg-d >=len)
        d = NULL;

      *root = picoXml_err(d, "unexpected <");
      return;
    }

    if (s == NULL && parser.gotError)
    {
      *root = picoXml_err(parser.errorAdd, parser.errorMsg);
      return;
    }

    if ( s == NULL) break;
    if (*s == 0)  break;

    *s = '\0';
    d = ++s;

    if (*s != 0 && *s != '<')
    {
      while (*s != 0 && *s != '<') s++;

      if (*s == 0)
        break;

      picoXml_handleCharacters(d, s - d, '&');
    }
    else if (*s == 0)
      break;
  }

  if (parser.current == XML_NO_ELEMENT)
  {
    *root = parser.rootElement;
    return;
  }

  struct picoXml *cur_element = &szAllElements[parser.current];
  if (cur_element->name == NULL)
  {
    *root = picoXml_err(d, "root tag missing");
    return;
  }

  *root = picoXml_errParam(d, "unclosed tag: ", cur_element->name);
  return;
}

/*
  Just iterate over processing instructions ignoring them
*/
char *ignoreProcessingInstructions(char *s)
{
  do
  {
    while (*s != 0 && *s != '?')
      s++;

    if (*s == 0)
      break;
    s++;
  }
  while (*s != 0 && *s != '>');

  return s;
}

/*
  Ignore DOCTYPE declarations, dtd etc.
*/
char *ignoreDoctype(char *s, char *d, char endChar, int *d_cnt)
{
  int cnt = 1, l = 0;

  while (MapIsWhitespace[s[cnt]])
    cnt++;

  for (; *s != 0 && ((! l && *s != '>') || (l && (*s != ']' || *(s + cnt) != '>')));)
  {
    cnt = 1;
    while (! MapIsBrOBrOGr[s[cnt]])
      cnt++;
    s += cnt;

    if (*s == '[')
      l = 1;
  }

  if (*s == 0 && endChar != '>')
    return NULL;

  if (l)
  {
    while (d[*d_cnt] != '[')
      *d_cnt++;
    *d_cnt++;
  }

  return s;
}

/*
  Iterates over tag and attributes
*/
char *handleNewTag(char *s, char *d, char endChar)
{
  struct picoXml *element;
  struct xmlAttribute *newAttr, newAttrList[XML_MAX_ATTRIBUTES_PER_ELEMENT], *attr;
  int  i, attrCnt=0;
  char q;

  while (! MapIsWsAndSlGr[*s]) s++;
  while (*s != 0 && MapIsWhitespace[*s])
  {
    *s = 0; // null terminate tag name
    s++;
  }

  if (*s != 0 && *s != '/' && *s != '>') // find tag in default attr list
  {
    element = &szAllElements[parser.rootElement];
    for (i=0; i < element->sizeAttr; i++)
    {
      attr = &element->szAttr[i];
      if (strcmp(attr->name, d) == 0)
        break;
    }
  }

  attrCnt = 0;
  memset(newAttrList, 0, XML_MAX_ATTRIBUTES_PER_ELEMENT * sizeof(struct xmlAttribute));
  for (i=0; *s != 0 && *s != '/' && *s != '>'; i+=2)
  {   // new attribute
    if (attrCnt == XML_MAX_ATTRIBUTES_PER_ELEMENT)
    {
      parser.gotError = 1;
      sprintf(parser.errorMsg, "Found more than %d attributes. Adjust amount in code.", XML_MAX_ATTRIBUTES_PER_ELEMENT);
      return NULL;
    }

    newAttr = &newAttrList[attrCnt];
    attrCnt++;
    newAttr->name = s;

    while (! MapIsWsAndEqSlGr[*s]) s++;

    if (*s == '=' || (*s && MapIsWhitespace[*s]))
    {
      *s = 0; // null terminate tag attribute name
      s++;

       while (MapIsWsAndEq[*s]) s++;
       q = *s;

      if (q == '"' || q == '\'') // attribute value
      {
        newAttr->value = ++s;
        while (*s != 0 && *s != q) s++;

        if (*s != 0)
        {
          *s = '\0'; // null terminate attribute val
          s++;
        }
        else
          return setParserErrorParamChar("missing ", d, q);
      }
    }
    while (*s != 0 && MapIsWhitespace[*s]) s++;
  }

  if (*s == '/')  // self closing tag
  {
    *s = 0;
    s++;

    if ((*s != 0 && *s != '>') || (*s == 0 && endChar != '>'))
      return setParserErrorNoParam("missing >", d);

    if (picoXml_openTag(d, &newAttrList, attrCnt) == XML_PARSER_ERROR)
      return NULL;

    picoXml_close_tag(d, s);
    return s;
  }
  else if ((q = *s) == '>' || (*s == 0 && endChar == '>'))
  {
    *s = 0; // temporarily null terminate tag name

    if (picoXml_openTag(d, &newAttrList, attrCnt) == XML_PARSER_ERROR)
      return NULL;

    *s = q;
    return s;
  }

  return setParserErrorNoParam("missing >", d);
}

/*
  Handles a closing tag
*/
char *handleClosingTag(char *s, char endChar)
{
  int  cnt = 0;
  char q, *d = &s[1];

  while (! MapIsWsAndGr[d[cnt]]) cnt++;
  s += cnt+1;

  if (! *s && endChar != '>')
    return setParserErrorNoParam("missing >", d);

  q = *s;

  *s = '\0'; // temporarily null terminate tag name
  if (picoXml_close_tag(d, s) == XML_PARSER_ERROR)
    return setParserErrorNoParam("error in closing tag", d);

  cnt = 0;

  while (MapIsWhitespace[s[cnt]])
    cnt++;

  *s = q;
  if (*s && MapIsWhitespace[*s])
    s += cnt;

  return s;
}

// inserts an existing tag into an picoXml structure
void picoXml_insert(int xml, int dest, int off)
{
  struct picoXml *xml_element, *cur_element, *head_element, *dest_element, *prev_element, *next_element;
  int cur, prev, head;

  xml_element     = &szAllElements[xml];
  xml_element->off  = off;
  xml_element->parent = dest;

  dest_element = &szAllElements[dest];
  head     = dest_element->child;
  if (head == XML_NO_ELEMENT)
  {
    dest_element->child = xml;
    return;
  }

  head_element = &szAllElements[head];
  if (head_element->off > off) // first subtag
    dest_element->child  = xml;

  cur = head;
  cur_element = &szAllElements[cur];
  for (prev = XML_NO_ELEMENT; cur != XML_NO_ELEMENT && strcmp(cur_element->name, xml_element->name);) // find tag type
  {
    prev = cur;
    cur_element = &szAllElements[cur];
    cur = cur_element->sibling;
    if (cur != XML_NO_ELEMENT)
      cur_element = &szAllElements[cur];
  }

  if (cur != XML_NO_ELEMENT && cur_element->off <= off) // not first of type
  {
    next_element = &szAllElements[cur_element->next];
    while (cur_element->next != XML_NO_ELEMENT && next_element->off <= off)
    {
      cur = cur_element->next;
      if (cur != XML_NO_ELEMENT)
      {
        cur_element  = &szAllElements[cur];
        next_element = &szAllElements[cur_element->next];
      }
    }
    xml_element->next = cur_element->next;
    cur_element->next = xml;
  }
  else
  {
    handleFirstTag(cur, prev, head, xml, off, xml_element);
  }
}

/*
  Handle first tag
*/
void handleFirstTag(int cur, int prev, int head, int xml, int off, struct picoXml *xml_element)
{
  struct picoXml *cur_element, *prev_element;

  if (prev != XML_NO_ELEMENT && cur != XML_NO_ELEMENT)
  {
    prev_element = &szAllElements[prev];
    cur_element  = &szAllElements[cur];
    prev_element->sibling = cur_element->sibling; // remove old first
  }
  xml_element->next = cur; // old first tag is now next
  cur = head;
  cur_element = &szAllElements[cur];
  for (prev = XML_NO_ELEMENT; cur != XML_NO_ELEMENT && cur_element->off <= off; ) // new sibling insertion point
  {
    prev = cur;
    cur  = cur_element->sibling;
    cur_element = &szAllElements[cur];
  }
  xml_element->sibling = cur;
  if (prev != XML_NO_ELEMENT)
  {
    prev_element = &szAllElements[prev];
    prev_element->sibling = xml;
  }
}

// Adds a child tag. off is the offset of the child tag relative to the start
// of the parent tag's character content. Returns the child tag.
void picoXml_add_child(int xml, char *name, int off, int *child)
{
  *child = addNewElement();
  if (*child == XML_NO_ELEMENT)
    return;

  struct picoXml *element = &szAllElements[*child];
  element->name = name;

  picoXml_insert(*child, xml, off);
  return;
}

/*
  Parse the query to the end of the line and terminate it
*/
int parseElement(char *toParse, struct xml_query *key, int root)
{
  int  idx=0, idxClose=0, hlp,
     len_toParse = strlen(toParse);

  key->name = toParse;
  
  for (idx=0; ! MapIsEOL[toParse[idx]]; idx++)
  {
    if (toParse[idx] == '/')
    {
      toParse[idx] = 0;
      idx++;

      if (!root)
      {
          key->oneDeeper = (struct xml_query*) malloc(sizeof(struct xml_query));
          initElement(key->oneDeeper, key, key->datatype);

          key = key->oneDeeper;
      }

      hlp = parseElement(&toParse[idx], key, 0);
      if (hlp < 0)
        return -1;

      return idx + hlp;
    }
    else if (toParse[idx] == '[')
    {
      toParse[idx] = 0;
      idx++;

      while (toParse[idx+idxClose] != ']')
        idxClose++;

      toParse[idx+idxClose] = 0;

      if (parseBracketContent(&toParse[idx], key))
        return -1;

      idx += idxClose;
    }
    else if (toParse[idx] == ' ')
    {
      while (!MapIsEOL[toParse[idx]])
        idx++;

      return idx;
    }
  }

  if (toParse[idx] != 0)
  {
    toParse[idx] = 0;
    idx++;
  }

  return idx;
}

/*
  Parse specifiers inside of brackets []
  Cases: [], [12], [@key1='' @key2='']

  Be aware that XPath semantics handle indexes 1-based
*/
int parseBracketContent(char *toParse, struct xml_query *key)
{
  int idx, attrFound=0, attrIdx=0;
  char *start, *hlp,
     szMsg[150];

  while (toParse[idx])
  {
    start = &toParse[idx];

    while (toParse[idx] && MapIsWhitespace[toParse[idx]])
      idx++;

    if (! toParse[idx])
      return 0;

    if (toParse[idx] >= '0' && toParse[idx] <= '9')
    {
      if (attrFound == 1)
      {
        sprintf(szMsg, "Syntax error in query: Mix of index and attributes at %s", start);
        messageParamTimed(szMsg, STRING_NOPARAM, 5000);
        return 1;
      }
      else
        key->arrayindex = atoi(&toParse[idx]) - 1;  // When numeric is found handle it as 1-based index, subsequent data is ignored

      return 0;
    }
    else if (toParse[idx] == '@')
    {
      idx++;
      attrFound = 1;

      // Handle attribute by setting the correct 0-terminating char
      key->attribute[attrIdx] = &toParse[idx];
      while (toParse[idx] && toParse[idx]!= '=' && !MapIsWhitespace[toParse[idx]])
        idx++;

      if (MapIsWhitespace[toParse[idx]])
      {
        toParse[idx] = 0;
        idx++;
      }
      while (MapIsWhitespace[toParse[idx]])
        idx++;
      if (toParse[idx] == '=')
      {
        toParse[idx] = 0;
        idx++;
      }
      else
      {
        sprintf(szMsg, "Attribute syntax error in query at %s", start);
        messageParamTimed(szMsg, STRING_NOPARAM, 5000);
        return 1;
      }

      // Now get the value
      while (toParse[idx] && (toParse[idx] != '\'' || MapIsWhitespace[toParse[idx]]))
        idx++;

      if (toParse[idx] == '\'')
      {
        toParse[idx] = 0;
        idx++;
        key->value[attrIdx] = &toParse[idx];
        attrIdx++;

        while (toParse[idx] && toParse[idx] != '\'')
          idx++;
        if (toParse[idx])
        {
          toParse[idx] = 0;
          idx++;
          continue;
        }
      }

      sprintf(szMsg, "quoted value/closing quotes error at %s", start);
      messageParamTimed(szMsg, STRING_NOPARAM, 5000);
      return 1;
    }
    else
    {
      sprintf(szMsg, "Unexpected characters at %s", start);
      messageParamTimed(szMsg, STRING_NOPARAM, 5000);
      return 1;
    }

    idx++;
  }

  return 0;
}

/*
  Map character to datatype
*/
int getDatatype(char c, char d)
{
  if (d != ':')
    return DT_NONE;

  if    (c == 'i') return DT_INT;
  else if (c == 'f') return DT_FLOAT;
  else if (c == 'b') return DT_BOOL;
  else if (c == 's') return DT_STRING;

  return DT_NONE;
}

/*
  Get the queried data string and parse it.
*/
int parseQuery(char *xml_queries, struct xml_query *queries, int size)
{
  int  startIdx = 0,
     elementIdx = 0,
     len = strlen(xml_queries),
     hlp, i;

  struct xml_query *query;

  for (i=0; i<size; i++)
    initElement(&queries[i], NULL, DT_NONE);

  do
  {
    // Just in case: Skip all leading whitespaces
    while (startIdx<len && (MapIsEOL[xml_queries[startIdx]] || xml_queries[startIdx] == ' '))
      startIdx++;

    if (xml_queries[startIdx] == '#')   // Skip comment lines
    {
      while (startIdx<len && !MapIsEOL[xml_queries[startIdx]])
        startIdx++;
    }
    else
    {
      while (startIdx<len && !MapIsPrimitive[xml_queries[startIdx]])
        startIdx++;

      query = &queries[elementIdx];
      elementIdx++;

      query->datatype = getDatatype(xml_queries[startIdx], xml_queries[startIdx+1]);
      startIdx+=2; // Skip the datatype, for example: f:
      hlp = parseElement(&xml_queries[startIdx], query, 1);
      if (hlp < 0)
        return -1;
      startIdx += hlp;
    }
  }
  while (startIdx<len && elementIdx<MAXCHANNELS);

  return elementIdx;
}

// Helper for getting the right values
int hasMatchingAttribute(struct picoXml *tag, char *attr, char *value)
{
  struct xmlAttribute *tagAttr;
  int i;

  for (i=0; i < tag->sizeAttr; i++)
  {
    tagAttr = &tag->szAttr[i];

    if (strcmp(tagAttr->name, attr) == 0 && strcmp(tagAttr->value, value) == 0)
      return 1;
  }
  return 0;
}

int doAllAttributesMatch(struct picoXml *tag, struct xml_query *query)
{
  int i, result, resultAll = 1;
  char *attr, *val;

  for (i=0; i < XML_MAX_ATTRIBUTES_PER_ELEMENT; i++)
  {
    attr = query->attribute[i];
    val  = query->value[i];

    if (attr == NULL)
        return resultAll;

    result = hasMatchingAttribute(tag, attr, val);

    if (i == 0)
      resultAll = result;
    else
      resultAll = resultAll && result;
  }
  return resultAll;
}

// Returns found value or NULL
char *getValue(short eId, struct xml_query *query, int qIdx)
{
  if (eId == XML_NO_ELEMENT || query == NULL || qIdx < 0)
    return NULL;

  struct picoXml      *tag = &szAllElements[eId];
  struct xmlAttribute *xAttr;
  int i;

  if (query->name[0] == '@')
  {
      if (query->oneDeeper != NULL || tag->parent == XML_NO_ELEMENT)
          return NULL;
          
      tag = &szAllElements[tag->parent];

      for (i=0; i < tag->sizeAttr; i++)
      {
        xAttr = &tag->szAttr[i];
        if (strcmp(&query->name[1], xAttr->name) == 0)
            return xAttr->value;
      }
      return NULL;
  }
  else if (strcmp(query->name, tag->name) != 0)
    return getValue(tag->sibling, query, qIdx);

  char *attr = query->attribute[0];
  if (attr != NULL )
  {
    if (doAllAttributesMatch(tag, query))
    {
      if (query->oneDeeper == NULL)
        return tag->txt;

      return getValue(tag->child, query->oneDeeper, query->oneDeeper->arrayindex);
    }

    return getValue(tag->next, query, qIdx);
  }

  if (qIdx == 0)
  {
    if (query->oneDeeper == NULL)
      return tag->txt;

    return getValue(tag->child, query->oneDeeper, query->oneDeeper->arrayindex);
  }

  return getValue(tag->next, query, qIdx-1);
}


void printValues(struct xml_query *queries, int qSize)
{
  int i, stringI=0, dataChannel;
  struct xml_query *query;
  char *value;

  for (i=0; i<qSize ; i++)
  {
    query = &queries[i];

    dataChannel = i-stringI;
    value = getValue(parser.rootElement, query, query->arrayindex);

    if (value == NULL)
    {
      setoutput(dataChannel, 0);
      continue;
    }

    switch (query->datatype)
    {
      case DT_INT:    setoutput(dataChannel, atoi(value));  break;
      case DT_FLOAT:  setoutput(dataChannel, atof(value));  break;
      case DT_STRING: setoutputtext(stringI+1, value); stringI++; break;
      case DT_BOOL:
        if (strcmp(value, "true") == 0 || strcmp(value, "TRUE") == 0 || strcmp(value, "on") == 0 || strcmp(value, "ON") == 0 || strcmp(value, "1") == 0)
          setoutput(dataChannel, 1);
        else
          setoutput(dataChannel, 0);
        break;
    }
  }
}


//	Helperfunction for formatting output-values, printing etc.
void pad(char *retValue, int value)
{
  if (value <10)
	sprintf(retValue, "0%d", value);
  else
    sprintf(retValue, "%d", value);
}

//	Gets the current time and returns it formatted.
char *getFormattedTime(char *buffer, int timeonly, int time)
{
  char month[3], day[3];
  char hour[3],  minute[3], second[3];

  pad(hour,   gethour(time, 1));
  pad(minute, getminute(time, 1));
  pad(second, getsecond(time, 1));

  if (timeonly)
    sprintf (buffer, "%s:%s:%s", hour, minute, second);
  else
  {
    pad(month, getmonth(time, 1));
    pad(day,   getday(time, 1));
    sprintf (buffer, "%s.%s %s:%s:%s", day, month, hour, minute, second);
  }

  return buffer;
}

void main()
{
  char szMsg[150];
  char *xml, *xml_queries, *server, *page;
  int  now, startElement, no_queries, sleeptimeSec=0;

  struct xml_query queries[MAXCHANNELS], *query;

  xml_queries  = INPUT_XML_QUERY;
  server       = INPUT_HTTP_SERVER;
  page         = INPUT_HTTP_PAGE;
  sleeptimeSec = INPUT_ITERATION_WAIT_SEC;
  if (sleeptimeSec == 0)
    sleeptimeSec = 5;

  no_queries = parseQuery(xml_queries, queries, MAXCHANNELS);
  if (no_queries < 0)
  {
    messageParam("Error in query parsing. Stopping.", STRING_NOPARAM);
    return;
  }

  while (TRUE)
  {
    initParser();

    sprintf(szMsg, "Fetching data from: http://%s%s", server, page);
    messageParam(szMsg, STRING_NOPARAM);
    if (startElement == XML_PARSER_ERROR)
      messageParamTimedChannel("", STRING_NOPARAM, 0, 1);
         
    xml = httpget(server,page);

    messageParam("Start parsing...", STRING_NOPARAM);

    now = getcurrenttime();
    picoXml_parseString(xml, &startElement);
    if (startElement != XML_PARSER_ERROR)
    {
      sprintf(szMsg, "Parsed %d XML elements in %ds%c", parser.elementsInUse, getcurrenttime() - now, 0);
      messageParam(szMsg, STRING_NOPARAM);
  
      printValues(queries, no_queries);
    }

    now = getcurrenttime() + sleeptimeSec;

    sprintf(szMsg, "Next XML check: %s", getFormattedTime(szMsg, 1, now));
    messageParam(szMsg, STRING_NOPARAM);

    if (xml != NULL)
        free(xml);
    sleeps(sleeptimeSec);
  }
}
main();