/*******************************************************************************
 * 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.profile.validator.impl;

import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.TreeMap;
import java.util.Vector;

import org.eclipse.wst.wsi.internal.core.WSIException;
import org.eclipse.wst.wsi.internal.core.analyzer.AnalyzerContext;
import org.eclipse.wst.wsi.internal.core.profile.ProfileArtifact;
import org.eclipse.wst.wsi.internal.core.profile.TestAssertion;
import org.eclipse.wst.wsi.internal.core.profile.validator.BaseValidator;
import org.eclipse.wst.wsi.internal.core.profile.validator.EntryContext;
import org.eclipse.wst.wsi.internal.core.profile.validator.EnvelopeValidator;
import org.eclipse.wst.wsi.internal.core.report.AssertionResult;
import org.eclipse.wst.wsi.internal.core.report.Entry;
import org.eclipse.wst.wsi.internal.core.report.FailureDetail;
import org.eclipse.wst.wsi.internal.core.report.PrereqFailedList;
import org.eclipse.wst.wsi.internal.core.report.ReportArtifact;
import org.eclipse.wst.wsi.internal.core.report.Reporter;
import org.eclipse.wst.wsi.internal.core.report.impl.PrereqFailedListImpl;
import org.eclipse.wst.wsi.internal.core.util.EntryType;
import org.eclipse.wst.wsi.internal.core.xml.XMLDocumentCacheUser;
import org.eclipse.wst.wsi.internal.core.xml.dom.ElementLocation;

/**
 * The WSDL validator will verify that the WSDL and associated XML schema definitions
 * are in conformance with the profile.
 *
 * @version 1.0.1
 * @author Peter Brittenham (peterbr@us.ibm.com)
 * @author Graham Turrell   (gturrell@uk.ibm.com)
 */
public abstract class BaseValidatorImpl
  extends XMLDocumentCacheUser
  implements BaseValidator
{

  /**
   * A hashtable that maps assertion results to their priorities, 0 is lowest
   */
  private static final Hashtable resultPriority = new Hashtable(6);
  static {
    resultPriority.put(AssertionResult.RESULT_PASSED, new Integer(0));
    resultPriority.put(AssertionResult.RESULT_NOT_APPLICABLE, new Integer(1));
    resultPriority.put(AssertionResult.RESULT_MISSING_INPUT, new Integer(2));
    resultPriority.put(AssertionResult.RESULT_WARNING, new Integer(3));
    resultPriority.put(AssertionResult.RESULT_PREREQ_FAILED, new Integer(4));
    resultPriority.put(AssertionResult.RESULT_FAILED, new Integer(5));
  }

  /**
   * The highest priority value being passed when processing pre-requisites
   */
  private static final int MAX_VALID_PRIORITY = 1;

  /**
   * Analyzer context.
   */
  public AnalyzerContext analyzerContext;

  /**
   * Profile artifact.
   */
  protected ProfileArtifact profileArtifact;

  /**
   * Reporter.
   */
  protected Reporter reporter;

  /**
   * Entry.
   */
  // protected Entry entry;

  /**
   * Report artifact.
   */
  protected ReportArtifact reportArtifact;

  /**
   * Verbose option.
   */
  public boolean verboseOption = false;

  /**
   * Test assertion processed count.
   */
  protected int assertionCount = 0;

  /**
   * Constructor.
   */
  public BaseValidatorImpl()
  {
  }

  /**
   * Initiailize validation test procedure.
   * @param analyzerContext the analyzerContext.
   * @param profileArtifact the profile artifiact.
   * @param reportArtifact  the report artifact.
   * @param reporter        a Reporter object.
   * @throws WSIException if validator could not be initialized.
   */
  public void init(
    AnalyzerContext analyzerContext,
    ProfileArtifact profileArtifact,
    ReportArtifact reportArtifact,
    Reporter reporter)
    throws WSIException
  {
    // Save input references
    this.analyzerContext = analyzerContext;
    this.profileArtifact = profileArtifact;
    this.reportArtifact = reportArtifact;
    this.reporter = reporter;

    // Get verbose option    
    verboseOption =
      reporter
        .getReport()
        .getReportContext()
        .getAnalyzer()
        .getAnalyzerConfig()
        .getVerboseOption();
  }

  /**
   * Process all of the test assertions for one entry.
   * @param classPrefix a class prefix.
   * @param entryContext an entry context.
   * @throws WSIException if serious problems occur while processing 
   *         all of the test assertions for an entry.
   */
  protected void processAssertions(
    String classPrefix,
    EntryContext entryContext)
    throws WSIException
  {
    long startTime = 0;

    HashMap processList = new HashMap();
    TestAssertion testAssertion = null;
    AssertionProcess assertionProcess;
    AssertionResult assertionResult;

    TreeMap preReqResults;
    PrereqFailedList prereqFailedList;
    String preReqId;

    Class[] paramTypes = new Class[1];
    // If this is an instance of MessageValidator or EnvelopeValidator
    // then use BaseMessageValidator as a param type of assertions constructor
    paramTypes[0] = this instanceof BaseMessageValidator ?
      BaseMessageValidator.class : this.getClass();

    Object[] params = new Object[1];
    params[0] = this;

    // Get entry from context
    Entry entry = entryContext.getEntry();

    // Add entry to artifact
    this.reportArtifact.addEntry(entry);

    // Add entry to report
    if (this instanceof EnvelopeValidator)
     	this.reporter.setCurrentEnvelopeEntry(entry); 
	else this.reporter.setCurrentEntry(entry);

    try
    {
      // Go through the list of test assertions for the artifact
      Iterator iterator = profileArtifact.getTestAssertionList().iterator();
      while (iterator.hasNext())
      {
        // Get next test assertion
        testAssertion = (TestAssertion) iterator.next();

        // Reset variables
        assertionResult = null;

        // If the test assertion is enabled, then continue
        //        if ((testAssertion.isEnabled()) && 
        //            testAssertion.getEntryTypeName().equals(targetContext.getEntry().getEntryType().getTypeName())) { 
        if (testAssertion.isEnabled()
          && isPrimaryEntryTypeMatch(testAssertion, entryContext))
        {
          try
          {
            // Add 1 to assertion processed count
            assertionCount++;

            // If the assertion process hasn't been created yet, then create it
            if ((assertionProcess =
              (AssertionProcess) processList.get(testAssertion.getId()))
              == null)
            {

              // Create a new assertion process
              Class assertionClass =
                Class.forName(classPrefix + testAssertion.getId());

              assertionProcess =
                (AssertionProcess) assertionClass.getConstructor(
                  paramTypes).newInstance(
                  params);

              // Add it to the list
              processList.put(testAssertion.getId(), assertionProcess);
            }

            // Check whether entry is null
            if (entry.getEntryDetail() == null)
            {
              assertionResult =
                createAssertionResult(
                  testAssertion,
                  AssertionResult.RESULT_MISSING_INPUT,
                  (String) null);
            }

            // Check to see if the test assertion should be run
            //if (isNotApplicable(testAssertion, entryContext)) {
            else if (isNotApplicable(testAssertion))
            {
              assertionResult =
                createAssertionResult(
                  testAssertion,
                  AssertionResult.RESULT_NOT_APPLICABLE,
                  (String) null);
            }
            else
            {
              // Processing all the assertion pre-requisites

              preReqResults = null;
              prereqFailedList = null;
              // Get list of pre-reqs for specified assertion
              Iterator i = testAssertion.getPrereqIdList().iterator();
              while (i.hasNext())
              {
                if (preReqResults == null)
                  preReqResults = new TreeMap();
                // Get next id
                preReqId = (String) i.next();
                // Get the prereq result
                AssertionResult preReqResult = reporter.getAssertionResult(preReqId);

                // Adding a result priority value to preReqResults
                preReqResults.put(
                  resultPriority.get(preReqResult.getResult()),
                  preReqResult.getResult());

                // If the prereq failed, then add it to the list
                if (((Integer)resultPriority.get(preReqResult.getResult())).intValue()
                  > MAX_VALID_PRIORITY)
                {
                  // Adding failed prereq ID to the list
                  if (prereqFailedList == null)
                    prereqFailedList = new PrereqFailedListImpl();
                  prereqFailedList.addTestAssertionID(preReqId);
                }
              }

              if (prereqFailedList != null) {
                // Getting the highest pre-requisites' result
                Integer maxRes = (Integer)preReqResults.lastKey();
                String resString = (String)preReqResults.get(maxRes);
                if (resString.equals(AssertionResult.RESULT_FAILED)
                  ||resString.equals(AssertionResult.RESULT_WARNING)) {
                  resString = AssertionResult.RESULT_PREREQ_FAILED;
                }
                // Create assertion result based on pre-requisites which are not passed
                assertionResult = createAssertionResult(testAssertion, resString, prereqFailedList);
              }

              // Pre-requisites are passed, validate current assertion
              else {

                // Reset test assertion
                assertionProcess.reset();

                //  VERBOSE
                if (verboseOption)
                {
                  System.err.println(
                    "  Processing "
                      + testAssertion.getId()
                      + " for entry reference ID ["
                      + entry.getReferenceID()
                      + "] ...");
                  startTime = System.currentTimeMillis();
                }

                // Validate the target
                assertionResult =
                  assertionProcess.validate(testAssertion, entryContext);

                //  VERBOSE
                if (verboseOption)
                {
                  System.err.println(
                    "    Elapsed time: "
                      + (System.currentTimeMillis() - startTime)
                      + "ms");
                }                
              }
            }

            // Add result to the report
            reporter.addAssertionResult(assertionResult);
          }

          catch (ClassNotFoundException cnfe)
          {
            // DEBUG:
            if (testAssertion != null)
            {
              reporter
                .getReport()
                .getReportContext()
                .getAnalyzer()
                .printMessage(
                "WARNING: "
                  + testAssertion.getId()
                  + " is not supported currently.");
            }
          }
        }
      }
    }

    catch (Exception e)
    {
      System.err.println("EXECEPTION: " + e.getMessage());
      if (verboseOption)
        e.printStackTrace();

      if (e instanceof WSIException)
        throw (WSIException) e;
      else
        throw new WSIException(e.getMessage(), e);
    }

    finally
    {
      // Indicate that we are done with this assertion target
      this.reporter.endCurrentEntry();
    }
  }

  /**
   * Determine if the test assertion should be processed for the current entry.
   * @param testAssertion a test assertion.
   * @param entryContext  the entry context.
   * @return true if the test assertion should be processed for the current entry.
   */
  protected abstract boolean isPrimaryEntryTypeMatch(
    TestAssertion testAssertion,
    EntryContext entryContext);

  /**
   * Determine if the test assertion should be processed for the current entry.
   * @param testAssertion  a test assertion.
   * @param entry          an Entry object
   * @return true if the test assertion should be processed for the current entry.
   */
  protected boolean isPrimaryEntryTypeMatch(
    TestAssertion testAssertion,
    Entry entry)
  {
    boolean match = false;

    // If the test assertion entry type matches the target context entry type, then contine
    if (testAssertion
      .getEntryTypeName()
      .equals(entry.getEntryType().getTypeName()))
    {
      match = true;
    }

    return match;
  }

  /**
   * Determine if the test assertion is not applicable.
   * @param testAssertion a test assertion.
   * @return true if the test assertion is not applicable.
   */
  protected abstract boolean isNotApplicable(TestAssertion testAssertion);

  /* (non-Javadoc)
   * @see org.wsi.test.profile.validator.BaseValidator#cleanup()
   */
  public void cleanup() throws WSIException
  {
    // If no assertions were processed, then set all missingInput
    if (assertionCount == 0)
      setAllMissingInput();
  }

  /**
   * Create assertion result.
   * @param testAssertion a test assertion.
   * @param result        a String object.
   * @param failureDetail a FailureDetail object.
   * @return newly created test result.
   */
  public AssertionResult createAssertionResult(
    TestAssertion testAssertion,
    String result,
    FailureDetail failureDetail)
  {
    Vector failureDetailList = null;

    // Create failure detail list
    if (failureDetail != null)
    {
      failureDetailList = new Vector();
      failureDetailList.add(failureDetail);
    }

    return createAssertionResult(testAssertion, result, failureDetailList);
  }

  /**
   * Create assertion result.
   * @param testAssertion         a test assertion.
   * @param result                a String object.
   * @param failureDetailMessage  a failure detail message.
   * @return newly created test result.
   */
  public AssertionResult createAssertionResult(
    TestAssertion testAssertion,
    String result,
    String failureDetailMessage)
  {
    return createAssertionResult(
      testAssertion,
      result,
      failureDetailMessage,
      null);
  }

  /**
   * Create assertion result.
   * @param testAssertion         a test assertion.
   * @param result                a String object.
   * @param failureDetailMessage  a failure detail message.
   * @param elementLocation       element location.
   * @return newly created test result.
   */
  public AssertionResult createAssertionResult(
    TestAssertion testAssertion,
    String result,
    String failureDetailMessage,
    ElementLocation elementLocation)
  {
    // Create failure detail list
    Vector failureDetailList = null;
    if (failureDetailMessage != null)
    {
      failureDetailList = new Vector();
      FailureDetail failureDetail = reporter.createFailureDetail();
      failureDetail.setFailureMessage(failureDetailMessage);
      failureDetail.setElementLocation(elementLocation);
      failureDetailList.add(failureDetail);
    }

    return createAssertionResult(testAssertion, result, failureDetailList);
  }

  /**
   * Create assertion result.
   * @param testAssertion     a test assertion.
   * @param result            a String object.
   * @param failureDetailList a failure detail list.
   * @return newly created test result.
   */
  public AssertionResult createAssertionResult(
    TestAssertion testAssertion,
    String result,
    Vector failureDetailList)
  {
    // Create assertion result
    AssertionResult assertionResult = reporter.createAssertionResult();

    // Set values in assertion result
    assertionResult.setAssertion(testAssertion);
    assertionResult.setResult(result);
    assertionResult.setEntry(reporter.getReport().getCurrentEntry());

    // Set failure detail list
    assertionResult.setFailureDetailList(failureDetailList);

    return assertionResult;
  }

  /**
   * Create assertion result.
   * @param testAssertion     a test assertion.
   * @param result            a String object.
   * @param prereqFailedList  a list failed pre-requisite assertions.
   * @return newly created test result.
   */
  public AssertionResult createAssertionResult(
    TestAssertion testAssertion,
    String result,
    PrereqFailedList prereqFailedList)
  {
    // Create assertion result
    AssertionResult assertionResult = reporter.createAssertionResult();

    // Set values in assertion result
    assertionResult.setAssertion(testAssertion);
    assertionResult.setResult(result);
    assertionResult.setEntry(reporter.getReport().getCurrentEntry());
    assertionResult.setPrereqFailedList(prereqFailedList);

    return assertionResult;
  }

  /**
   * Add assertion result to report.
   * @param assertionId  assertion id.
   * @param result       assertion result.
   * @throws WSIException if the assertion result cannot be added to the report.
   */
  protected void addAssertionResult(String assertionId, String result)
    throws WSIException
  {
    // Create test assertion result
    AssertionResult assertionResult = reporter.createAssertionResult();

    // Set assertion, result and target
    assertionResult.setAssertion(profileArtifact.getTestAssertion(assertionId));
    assertionResult.setResult(result);
    assertionResult.setEntry(reporter.getReport().getCurrentEntry());

    // Add it to the report
    reporter.addAssertionResult(assertionResult);
  }

  /**
   * Add assertion result to report with an error detail message.
   * @param assertionId          assertion id.
   * @param result               assertion result.
   * @param failureDetailMessage an error detail message.
   * @throws WSIException if the assertion result cannot be added to the report.
   */
  protected void addAssertionResult(
    String assertionId,
    String result,
    String failureDetailMessage)
    throws WSIException
  {
    // Convert message to vector
    Vector failureDetailList = null;
    if (failureDetailMessage != null)
    {
      failureDetailList = new Vector();
      FailureDetail failureDetail = reporter.createFailureDetail();
      failureDetailList.add(failureDetail);
    }

    // Add assertion result
    addAssertionResult(assertionId, result, failureDetailList);
  }

  /**
   * Add assertion result to report.
   * @param assertionId        assertion id.
   * @param result             assertion result.
   * @param failureDetailList  a list of error detail messages.
   * @throws WSIException if the assertion result cannot be added to the report.
   */
  protected void addAssertionResult(
    String assertionId,
    String result,
    Vector failureDetailList)
    throws WSIException
  {
    // Create test assertion result
    AssertionResult assertionResult = reporter.createAssertionResult();

    // Set assertion, result and target
    assertionResult.setAssertion(profileArtifact.getTestAssertion(assertionId));
    assertionResult.setResult(result);
    assertionResult.setEntry(reporter.getReport().getCurrentEntry());
    assertionResult.setFailureDetailList(failureDetailList);

    // Add it to the report
    reporter.addAssertionResult(assertionResult);
  }

  /**
   * Add missingInput assertion result to report.
   * @param testAssertion a test assertion.
   * @throws WSIException if there is any problem adding missingInput 
   * 		 assertion result to report.
   */
  protected void addMissingInputResult(TestAssertion testAssertion)
    throws WSIException
  {
    // Create test assertion result
    AssertionResult assertionResult = reporter.createAssertionResult();

    // Set assertion, result and target
    assertionResult.setAssertion(testAssertion);
    assertionResult.setResult(AssertionResult.RESULT_MISSING_INPUT);
    assertionResult.setEntry(reporter.getReport().getCurrentEntry());

    // Add it to the report
    reporter.addAssertionResult(assertionResult);
  }

  /* (non-Javadoc)
   * @see org.wsi.test.profile.validator.BaseValidator#setAllMissingInput()
   */
  public void setAllMissingInput() throws WSIException
  {
    // If profile artifact is set
    if (profileArtifact != null)
    {
      TestAssertion testAssertion;
  
      // Create entry
      Entry entry = this.reporter.getReport().createEntry();
      entry.setArtifactName(this.reportArtifact.getType().getTypeName());
  
      // Add entry to artifact
      this.reportArtifact.addEntry(entry);
  
      // Add entry to report
      this.reporter.setCurrentEntry(entry);
  
      // Go through the list of test assertions for the artifact
      Iterator iterator = profileArtifact.getTestAssertionList().iterator();
      while (iterator.hasNext())
      {
        // Get next test assertion
        testAssertion = (TestAssertion) iterator.next();
  
        // Add missingInput result
        if (testAssertion.isEnabled())
          addMissingInputResult(testAssertion);
      }
  
      // Indicate that we are done with this assertion target
      this.reporter.endCurrentEntry();
    }
  }

  /**
   * Set all results for an entry type to missingInput.
   * @param entryType an EntryType object.
   * @throws WSIException if there is any problem while processing.
   */
  protected void setMissingInput(EntryType entryType) throws WSIException
  {
    TestAssertion testAssertion;

    // Create entry 
    Entry entry = this.reporter.getReport().createEntry();
    entry.setEntryType(entryType);
    entry.setReferenceID("[" + entryType.getTypeName() + "]");

    // Add entry to artifact
    this.reportArtifact.addEntry(entry);

    // Add entry to report
    this.reporter.setCurrentEntry(entry);

    //try {
    // Go through the list of test assertions for the artifact
    Iterator iterator = profileArtifact.getTestAssertionList().iterator();
    while (iterator.hasNext())
    {
      // Get next test assertion
      testAssertion = (TestAssertion) iterator.next();
      if (testAssertion.isEnabled()
        && isPrimaryEntryTypeMatch(testAssertion, entry))
      {
        addMissingInputResult(testAssertion);
      }
    }

    // Indicate that we are done with this entry
    this.reporter.endCurrentEntry();
  }
}