/*
 * 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.
 */
package org.apache.lucene.queryparser.xml;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.xml.sax.InputSource;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.Reader;
Helper methods for parsing XML
/**
 * Helper methods for parsing XML
 */
public class DOMUtils {

  public static Element getChildByTagOrFail(Element e, String name) throws ParserException {
    Element kid = getChildByTagName(e, name);
    if (null == kid) {
      throw new ParserException(e.getTagName() + " missing \"" + name
          + "\" child element");
    }
    return kid;
  }

  public static Element getFirstChildOrFail(Element e) throws ParserException {
    Element kid = getFirstChildElement(e);
    if (null == kid) {
      throw new ParserException(e.getTagName()
          + " does not contain a child element");
    }
    return kid;
  }

  public static String getAttributeOrFail(Element e, String name) throws ParserException {
    String v = e.getAttribute(name);
    if (null == v) {
      throw new ParserException(e.getTagName() + " missing \"" + name
          + "\" attribute");
    }
    return v;
  }

  public static String getAttributeWithInheritanceOrFail(Element e, String name) throws ParserException {
    String v = getAttributeWithInheritance(e, name);
    if (null == v) {
      throw new ParserException(e.getTagName() + " missing \"" + name
          + "\" attribute");
    }
    return v;
  }

  public static String getNonBlankTextOrFail(Element e) throws ParserException {
    String v = getText(e);
    if (null != v)
      v = v.trim();
    if (null == v || 0 == v.length()) {
      throw new ParserException(e.getTagName() + " has no text");
    }
    return v;
  }

  /* Convenience method where there is only one child Element of a given name */
  public static Element getChildByTagName(Element e, String name) {
    for (Node kid = e.getFirstChild(); kid != null; kid = kid.getNextSibling()) {
      if ((kid.getNodeType() == Node.ELEMENT_NODE) && (name.equals(kid.getNodeName()))) {
        return (Element) kid;
      }
    }
    return null;
  }

  
Returns an attribute value from this node, or first parent node with this attribute defined
Returns:
A non-zero-length value if defined, otherwise null/**
   * Returns an attribute value from this node, or first parent node with this attribute defined
   *
   * @return A non-zero-length value if defined, otherwise null
   */
  public static String getAttributeWithInheritance(Element element, String attributeName) {
    String result = element.getAttribute(attributeName);
    if ((result == null) || ("".equals(result))) {
      Node n = element.getParentNode();
      if ((n == element) || (n == null)) {
        return null;
      }
      if (n instanceof Element) {
        Element parent = (Element) n;
        return getAttributeWithInheritance(parent, attributeName);
      }
      return null; //we reached the top level of the document without finding attribute
    }
    return result;
  }


  /* Convenience method where there is only one child Element of a given name */
  public static String getChildTextByTagName(Element e, String tagName) {
    Element child = getChildByTagName(e, tagName);
    return child != null ? getText(child) : null;
  }

  /* Convenience method to append a new child with text*/
  public static Element insertChild(Element parent, String tagName, String text) {
    Element child = parent.getOwnerDocument().createElement(tagName);
    parent.appendChild(child);
    if (text != null) {
      child.appendChild(child.getOwnerDocument().createTextNode(text));
    }
    return child;
  }

  public static String getAttribute(Element element, String attributeName, String deflt) {
    String result = element.getAttribute(attributeName);
    return (result == null) || ("".equals(result)) ? deflt : result;
  }

  public static float getAttribute(Element element, String attributeName, float deflt) {
    String result = element.getAttribute(attributeName);
    return (result == null) || ("".equals(result)) ? deflt : Float.parseFloat(result);
  }

  public static int getAttribute(Element element, String attributeName, int deflt) {
    String result = element.getAttribute(attributeName);
    return (result == null) || ("".equals(result)) ? deflt : Integer.parseInt(result);
  }

  public static boolean getAttribute(Element element, String attributeName,
                                     boolean deflt) {
    String result = element.getAttribute(attributeName);
    return (result == null) || ("".equals(result)) ? deflt : Boolean.valueOf(result);
  }

  /* Returns text of node and all child nodes - without markup */
  //MH changed to Node from Element 25/11/2005

  public static String getText(Node e) {
    StringBuilder sb = new StringBuilder();
    getTextBuffer(e, sb);
    return sb.toString();
  }

  public static Element getFirstChildElement(Element element) {
    for (Node kid = element.getFirstChild(); kid != null; kid = kid.getNextSibling()) {
      if (kid.getNodeType() == Node.ELEMENT_NODE) {
        return (Element) kid;
      }
    }
    return null;
  }

  private static void getTextBuffer(Node e, StringBuilder sb) {
    for (Node kid = e.getFirstChild(); kid != null; kid = kid.getNextSibling()) {
      switch (kid.getNodeType()) {
        case Node.TEXT_NODE: {
          sb.append(kid.getNodeValue());
          break;
        }
        case Node.ELEMENT_NODE: {
          getTextBuffer(kid, sb);
          break;
        }
        case Node.ENTITY_REFERENCE_NODE: {
          getTextBuffer(kid, sb);
          break;
        }
      }
    }
  }

  
Helper method to parse an XML file into a DOM tree, given a reader.
Params:
is – reader of the XML file to be parsed
Returns:
an org.w3c.dom.Document object/**
   * Helper method to parse an XML file into a DOM tree, given a reader.
   *
   * @param is reader of the XML file to be parsed
   * @return an org.w3c.dom.Document object
   */
  public static Document loadXML(Reader is) {
    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    DocumentBuilder db = null;

    try {
      db = dbf.newDocumentBuilder();
    }
    catch (Exception se) {
      throw new RuntimeException("Parser configuration error", se);
    }

    // Step 3: parse the input file
    org.w3c.dom.Document doc = null;
    try {
      doc = db.parse(new InputSource(is));
      //doc = db.parse(is);
    }
    catch (Exception se) {
      throw new RuntimeException("Error parsing file:" + se, se);
    }

    return doc;
  }
}