/*******************************************************************************
 * Copyright (c) 2002-2005 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   IBM - Initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.wsi.internal.core.analyzer.config.impl;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.wst.wsi.internal.core.WSIConstants;
import org.eclipse.wst.wsi.internal.core.WSIException;
import org.eclipse.wst.wsi.internal.core.WSIFileNotFoundException;
import org.eclipse.wst.wsi.internal.core.analyzer.config.AnalyzerConfig;
import org.eclipse.wst.wsi.internal.core.analyzer.config.AnalyzerConfigReader;
import org.eclipse.wst.wsi.internal.core.analyzer.config.AssertionResultType;
import org.eclipse.wst.wsi.internal.core.analyzer.config.AssertionResultsOption;
import org.eclipse.wst.wsi.internal.core.analyzer.config.UDDIReference;
import org.eclipse.wst.wsi.internal.core.analyzer.config.WSDLElement;
import org.eclipse.wst.wsi.internal.core.analyzer.config.WSDLReference;
import org.eclipse.wst.wsi.internal.core.common.AddStyleSheet;
import org.eclipse.wst.wsi.internal.core.common.impl.AddStyleSheetImpl;
import org.eclipse.wst.wsi.internal.core.profile.validator.WSDLValidator;
import org.eclipse.wst.wsi.internal.core.util.MessageList;
import org.eclipse.wst.wsi.internal.core.util.TestUtils;
import org.eclipse.wst.wsi.internal.core.xml.XMLUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Element;


/**
 * This class is the implementation used to read the analyzer config documents.
 * 
 * @version 1.0.1
 * @author Peter Brittenham (peterbr@us.ibm.com)
 */
public class AnalyzerConfigReaderImpl implements AnalyzerConfigReader
{
  /**
   * Message list.
   */
  protected MessageList messageList;

  /**
   * Document location.
   */
  protected String documentURI;

  /**
   * Initialize analyzer config reader.
   */
  public void init(MessageList messageList)
  {
    this.messageList = messageList;
  }

  /**
   * @see org.eclipse.wst.wsi.internal.core.analyzer.config.AnalyzerConfigReader#readAnalyzerConfig(String)
   */
  public AnalyzerConfig readAnalyzerConfig(String analyzerConfigURI)
    throws WSIException
  {
    FileReader fileReader = null;
    try
    {
      fileReader = new FileReader(analyzerConfigURI);
    }

    catch (FileNotFoundException fnfe)
    {
      throw new WSIFileNotFoundException(
        getMessage(
          "config01",
          analyzerConfigURI,
          "Could not find analyzer config file: "),
        fnfe);
    }

    catch (Exception e)
    {
      throw new WSIException(
        getMessage(
          "config08",
          analyzerConfigURI,
          "Could not read analyzer config file: "),
        e);
    }

    return readAnalyzerConfig(fileReader);
  }

  /**
   * @see org.eclipse.wst.wsi.internal.core.analyzer.config.AnalyzerConfigReader#readAnalyzerConfig(Reader)
   */
  public AnalyzerConfig readAnalyzerConfig(Reader reader) throws WSIException
  {
    AnalyzerConfig analyzerConfig = new AnalyzerConfigImpl();

    // Parse XML
    Document doc = XMLUtils.parseXML(reader);

    // Parse elements in the config document
    parseConfigElement(analyzerConfig, doc.getDocumentElement());

    return analyzerConfig;
  }

  /**
   * @see org.eclipse.wst.wsi.internal.core.document.DocumentReader#getLocation()
   */
  public String getLocation()
  {
    return this.documentURI;
  }

  /**
   * @see org.eclipse.wst.wsi.internal.core.document.DocumentReader#setLocation(String)
   */
  public void setLocation(String documentURI)
  {
    this.documentURI = documentURI;
  }

  /**
   * Parse config element.
   */
  private void parseConfigElement(
    AnalyzerConfig analyzerConfig,
    Element element)
    throws WSIException
  {
    // ADD: Get name and version

    // ADD: Verify that this is the config element

    // Get first child element
    Element nextElement = XMLUtils.getFirstChild(element);

    // DEBUG:
    //System.out.println("Element name: " + nextElement.getClass().getName());

    // Process each child element
    while (nextElement != null)
    {
      // <description>
      if (isElement(nextElement, WSIConstants.ELEM_DESCRIPTION))
      {
        analyzerConfig.setDescription(XMLUtils.getText(nextElement));
      }

      // <verbose>
      else if (isElement(nextElement, WSIConstants.ELEM_VERBOSE))
      {
        analyzerConfig.setVerboseOption(
          XMLUtils.getBooleanValue(nextElement, false));
      }

      // <assertionResults>
      else if (isElement(nextElement, WSIConstants.ELEM_ASSERTION_RESULTS))
      {
        // Create assertion results option object
        AssertionResultsOption assertionResultsOption =
          new AssertionResultsOptionImpl();
        analyzerConfig.setAssertionResultsOption(assertionResultsOption);

        // Set result type
        String resultType =
          XMLUtils.getAttributeValue(nextElement, WSIConstants.ATTR_TYPE);
        assertionResultsOption.setAssertionResultType(
          AssertionResultType.newInstance(resultType));

        // Set show log entry
        assertionResultsOption.setShowMessageEntry(
          XMLUtils.getBooleanValue(
            nextElement,
            WSIConstants.ATTR_MESSAGE_ENTRY,
            assertionResultsOption.getShowMessageEntry()));

        // Set show failure message
        assertionResultsOption.setShowFailureMessage(
          XMLUtils.getBooleanValue(
            nextElement,
            WSIConstants.ATTR_FAILURE_MESSAGE,
            assertionResultsOption.getShowFailureMessage()));

        // Set show failure detail
        assertionResultsOption.setShowFailureDetail(
          XMLUtils.getBooleanValue(
            nextElement,
            WSIConstants.ATTR_FAILURE_DETAIL,
            assertionResultsOption.getShowFailureDetail()));

        // REMOVE: Set show warning message
        //assertionResultsOption.setShowWarningMessage(XMLUtils.getBooleanValue(nextElement, 
        //      WSIConstants.ATTR_WARNING_MESSAGE, assertionResultsOption.getShowWarningMessage()));
      }

      // <reportFile>
      else if (isElement(nextElement, WSIConstants.ELEM_REPORT_FILE))
      {
        parseReportFileElement(analyzerConfig, nextElement);
      }

      // <testAssertionFile>
      else if (isElement(nextElement, WSIConstants.ELEM_TEST_ASSERTIONS_FILE))
      {
        analyzerConfig.setTestAssertionsDocumentLocation(
          XMLUtils.getText(nextElement));
      }

      // <logFile>
      else if (isElement(nextElement, WSIConstants.ELEM_LOG_FILE))
      {
        String correlationType =
          XMLUtils.getAttributeValue(
            nextElement,
            WSIConstants.ATTR_CORRELATION_TYPE);
        analyzerConfig.setCorrelationType(
          correlationType == null ? "operation" : correlationType);
        analyzerConfig.setLogLocation(XMLUtils.getText(nextElement));
      }

      // <wsdlReference>
      else if (isElement(nextElement, WSIConstants.ELEM_WSDL_REFERENCE))
      {
        parseWsdlReference(analyzerConfig, nextElement);
      }

      // <uddiReference>
      else if (isElement(nextElement, WSIConstants.ELEM_UDDI_REFERENCE))
      {
        parseUddiReference(analyzerConfig, nextElement);
      }

      else
      {
        // Throw exception
        throw new IllegalArgumentException(
          getMessage(
            "config06",
            nextElement.getLocalName(),
            "Invalid analyzer config element:"));
      }

      // Get next element
      nextElement = XMLUtils.getNextSibling(nextElement);
    }
  }

  /**
   * Parse reportFile element.
   */
  private void parseReportFileElement(
    AnalyzerConfig analyzerConfig,
    Element element)
    throws WSIException
  {
    // Get report location and replace indicator
    analyzerConfig.setReplaceReport(
      XMLUtils.getBooleanValue(element, WSIConstants.ATTR_REPLACE, false));
    analyzerConfig.setReportLocation(
      XMLUtils.getAttributeValue(
        element,
        WSIConstants.ATTR_LOCATION,
        WSIConstants.DEFAULT_REPORT_URI));

    // ADD: If the report location wasn't specified, then throw an exception
    //if (analyzerConfig.getReportLocation() == null)
    //  throw new WSIException("The analyzer configuration file must contain the report file location.");

    // Get first child element
    Element nextElement = XMLUtils.getFirstChild(element);

    // Process each child element
    while (nextElement != null)
    {
      // <addStyleSheet>
      if (isElement(nextElement, WSIConstants.ELEM_ADD_STYLE_SHEET))
      {
        AddStyleSheet addStyleSheet = new AddStyleSheetImpl();

        // Parse the element  
        TestUtils.parseAddStyleSheet(
          nextElement,
          addStyleSheet,
          WSIConstants.DEFAULT_REPORT_XSL);

        // Set add style sheet
        analyzerConfig.setAddStyleSheet(addStyleSheet);
      }

      else
      {
        // Throw exception
        throw new IllegalArgumentException(
          getMessage(
            "config06",
            nextElement.getLocalName(),
            "Invalid analyzer config element:"));
      }

      // Get next element
      nextElement = XMLUtils.getNextSibling(nextElement);
    }
  }

  /**
   * Parse wsdl reference element.
   */
  private void parseWsdlReference(
    AnalyzerConfig analyzerConfig,
    Element element)
    throws WSIException
  {
    // Create UDDI reference
    WSDLReference wsdlReference = new WSDLReferenceImpl();

    // Set WSDL reference
    analyzerConfig.setWSDLReference(wsdlReference);

    // Get first child element
    Element nextElement = XMLUtils.getFirstChild(element);

    // Process each child element
    while (nextElement != null)
    {
      // <wsdlURI>
      if (isElement(nextElement, WSIConstants.ELEM_WSDL_URI))
      {
        // Set WSDL location
        wsdlReference.setWSDLLocation(XMLUtils.getText(nextElement));
      }

      // <serviceLocation>
      else if (isElement(nextElement, WSIConstants.ELEM_SERVICE_LOCATION))
      {
        // Set service location
        wsdlReference.setServiceLocation(XMLUtils.getText(nextElement));
      }

      // <wsdlElement>
      else if (isElement(nextElement, WSIConstants.ELEM_WSDL_ELEMENT))
      {
        // Set WSDL element
        wsdlReference.setWSDLElement(parseWsdlElement(nextElement));
      }

      else
      {
        // Throw exception
        throw new IllegalArgumentException(
          getMessage(
            "config06",
            nextElement.getLocalName(),
            "Invalid analyzer config element:"));
      }

      // Get next element
      nextElement = XMLUtils.getNextSibling(nextElement);
    }

    // If WSDL element or WSL URI not specified, then throw exception
    if ((wsdlReference.getWSDLElement() == null)
      || (wsdlReference.getWSDLLocation() == null))
    {
      throw new IllegalArgumentException(
        getMessage(
          "config07",
          "Both the <wsdlElement> and <wsdlURI> elements must be specified."));
    }

    // If type is port or operation, then parent element name must be specified
    if (((wsdlReference
      .getWSDLElement()
      .getType()
      .equalsIgnoreCase(WSDLValidator.TYPE_DESCRIPTION_PORT))
      || (wsdlReference
        .getWSDLElement()
        .getType()
        .equalsIgnoreCase(WSDLValidator.TYPE_DESCRIPTION_OPERATION)))
      && (wsdlReference.getWSDLElement().getParentElementName() == null))
    {
      throw new IllegalArgumentException(
        getMessage(
          "config09",
          "The parentElementName attribute must be specified with a WSDL type of "
            + WSDLValidator.TYPE_DESCRIPTION_PORT
            + " or "
            + WSDLValidator.TYPE_DESCRIPTION_OPERATION
            + "."));
    }
  }

  /**
   * Parse uddi reference.
   */
  private void parseUddiReference(
    AnalyzerConfig analyzerConfig,
    Element element)
    throws WSIException
  {
    // Create UDDI reference
    UDDIReference uddiReference = new UDDIReferenceImpl();

    // Set UDDI reference
    analyzerConfig.setUDDIReference(uddiReference);

    // Get first child element
    Element nextElement = XMLUtils.getFirstChild(element);

    // Process each child element
    while (nextElement != null)
    {
      // <inquiryURL>
      if (isElement(nextElement, WSIConstants.ELEM_INQUIRY_URL))
      {
        // Set inquiry URL
        uddiReference.setInquiryURL(XMLUtils.getText(nextElement));
      }

      // <uddiKey>
      else if (isElement(nextElement, WSIConstants.ELEM_UDDI_KEY))
      {
        // Set UDDI key and key type
        uddiReference.setKey(XMLUtils.getText(nextElement));
        uddiReference.setKeyType(
          XMLUtils.getAttributeValue(nextElement, WSIConstants.ATTR_TYPE));
      }

      // <wsdlElement>
      else if (isElement(nextElement, WSIConstants.ELEM_WSDL_ELEMENT))
      {
        // Set WSDL element
        uddiReference.setWSDLElement(parseWsdlElement(nextElement));
      }

      // <serviceLocation>
      else if (isElement(nextElement, WSIConstants.ELEM_SERVICE_LOCATION))
      {
        // Set service location
        uddiReference.setServiceLocation(XMLUtils.getText(nextElement));
      }

      /* REMOVE:
      // <wsdlElement>
      else if (isElement(nextElement, WSIConstants.ELEM_WSDL_ELEMENT)) {
        // Set service location
        parseWsdlElement(analyzerConfig, nextElement);
       }
       */

      else
      {
        // Throw exception
        throw new IllegalArgumentException(
          getMessage(
            "config06",
            nextElement.getLocalName(),
            "Invalid analyzer config element:"));
      }

      // Get next element
      nextElement = XMLUtils.getNextSibling(nextElement);
    }
  }

  /**
   * Parse WSDL element.
   */
  private WSDLElement parseWsdlElement(Element element) throws WSIException
  {
    WSDLElement wsdlElement = new WSDLElementImpl();

    // Set type, namespace, parent element name and name
    wsdlElement.setType(
      XMLUtils.getAttributeValue(element, WSIConstants.ATTR_TYPE));
    wsdlElement.setNamespace(
      XMLUtils.getAttributeValue(element, WSIConstants.ATTR_NAMESPACE));
    wsdlElement.setParentElementName(
      XMLUtils.getAttributeValue(
        element,
        WSIConstants.ATTR_PARENT_ELEMENT_NAME));

    String wsdlElementName = XMLUtils.getText(element);
    if (wsdlElementName.equals(""))
    {
      // Throw exception
      throw new IllegalArgumentException(
        getMessage("config19", "The WSDL element name must be specified."));
    }
    wsdlElement.setName(wsdlElementName);

    return wsdlElement;
  }

  /**
   * Determine if this element matches specified local name in the analyzer config namespace.
   */
  private boolean isElement(Element element, String localName)
  {
    return isElement(
      element,
      getValidWSIAnalyzerConfigNamespaces(),
      localName);
  }

  
  static public List getValidWSIAnalyzerConfigNamespaces()
  {
  	ArrayList list = new ArrayList();
  	list.add(WSIConstants.NS_URI_WSI_ANALYZER_CONFIG_2003);
  	list.add(WSIConstants.NS_URI_WSI_ANALYZER_CONFIG);
  	return list;
  }
  
  /**
   * Determine if this element matches specified local name in the analyzer config namespace.
   */
  private boolean isElement(
    Element element,
    List namespaces,
    String localName)
  {
    return XMLUtils.isElement(element, namespaces, localName);
  }

  /**
   * Get message from resource bundle.
   */
  private String getMessage(String messageID, String defaultMessage)
  {
    return getMessage(messageID, null, defaultMessage);
  }

  /**
   * Get message from resource bundle.
   */
  private String getMessage(
    String messageID,
    String messageData,
    String defaultMessage)
  {
    String message = defaultMessage;
    if (messageList != null)
      message = messageList.getMessage(messageID, messageData, defaultMessage);
    else
      message += " " + messageData + ".";

    return message;
  }
}