/*
 *  YamParseTreeTests.java
 *  Copyright (c) 1998-2008, The University of Sheffield.
 *
 *  This code is from the GATE project (http://gate.ac.uk/) and is free
 *  software licenced under the GNU General Public License version 3. It is
 *  distributed without any warranty. For more details see COPYING.txt in the
 *  top level directory (or at http://gatewiki.sf.net/COPYING.txt).
 *  
 *  Hamish Cunningham, 12th May 2006
 */

package gate.yam.parse;

import java.io.*;
import junit.framework.*;
import org.apache.log4j.Logger;
import gate.util.*;
import gate.yam.*;
import gate.yam.*;


/**
 * Unit test for YAM parse trees.
 */
public class YamParseTreeTests extends TestCase
{

  /** Create the test case */
  public YamParseTreeTests(String testName) {
    super(testName);
  }

  /** Logger */
  static Logger lgr = Logger.getLogger("gate.yam");

  /** SInS (plain) logger */
  static Logger slgr = Logger.getLogger("gate.sins");

  /**
   * Test setup and reset of trees.
   */
  public void testTreeStuff() throws Exception
  {
    // path, suffixes
    String path = "/gate/yam/resources/yam-minimal.yam";

    // report
    lgr.info("testing tree setup and reset");

    // a reader for the test file
    InputStream testFileStream = 
      this.getClass().getResourceAsStream(path);
    if(testFileStream == null)
      fail("couldn't get resource " + path);
    BufferedReader testReader =
      new BufferedReader(new InputStreamReader(testFileStream, "UTF-8"));

    // find the source directory
    String testFilePath = this.getClass().getResource(path).getPath();
    File testFileDir = new File(testFilePath).getParentFile();

    // a writer for the output
    StringWriter responseWriter = new StringWriter();

    // run the translator and get the response
    YamCommand yam = new YamCommand();
    YamParseTree tree = yam.translate(
      testReader, responseWriter, YamFile.FileType.HTML, testFileDir
    );

    // check that the tree is non-empty
    SimpleNode n = tree.getRootNode();
    if(treeEmpty(n)) fail("parse tree empty");

    // check that there are the right number of links / includes
    int links = tree.getLinks().size();
    int includes = tree.getIncludes().size();
    assertTrue("wrong number of links: " + links, links == 2);
    assertTrue("wrong number of includes: " + includes, includes == 1);

    // reset, and check that the tree is empty
    tree.reset();
    if(! treeEmpty(n)) fail("parse tree not empty");
  } // testTreeStuff()


  /**
   * Test tree merging.
   */
  public void testTreeMerging() throws Exception
  {
    // path, suffixes
    String path = "/gate/yam/resources/yam-minimal.yam";

    // report
    lgr.info("testing tree merging");

    // readers for the test file
    InputStream testFileStream1 = 
      this.getClass().getResourceAsStream(path);
    if(testFileStream1 == null)
      fail("couldn't get resource " + path);
    BufferedReader testReader1 =
      new BufferedReader(new InputStreamReader(testFileStream1, "UTF-8"));
    InputStream testFileStream2 = 
      this.getClass().getResourceAsStream(path);
    if(testFileStream2 == null)
      fail("couldn't get resource " + path);
    BufferedReader testReader2 =
      new BufferedReader(new InputStreamReader(testFileStream2, "UTF-8"));

    // find the source directory
    String testFilePath = this.getClass().getResource(path).getPath();
    File testFileDir = new File(testFilePath).getParentFile();

    // writers for the output
    StringWriter responseWriter1 = new StringWriter();
    StringWriter responseWriter2 = new StringWriter();

    // run two translators
    YamCommand yam1 = new YamCommand();
    YamParseTree tree1 = yam1.translate(
      testReader1, responseWriter1, YamFile.FileType.HTML, testFileDir
    );
    YamCommand yam2 = new YamCommand();
    YamParseTree tree2 = yam2.translate(
      testReader2, responseWriter2, YamFile.FileType.HTML, testFileDir
    );

    // get stats for each tree and check they're the same
    boolean gotTitle1 = (tree1.getTitleNode() != null);
    boolean gotTitle2 = (tree2.getTitleNode() != null);
    assertTrue("gotTitle flags disagree", gotTitle1 == gotTitle2);
    int numHeaders1 = tree1.getHeadingNodes().size();
    int numHeaders2 = tree2.getHeadingNodes().size();
    assertTrue("num headers disagree", numHeaders1 == numHeaders2);
    int numNodes1 = tree1.getNumNodes(tree1.getRootNode());
    int numNodes2 = tree2.getNumNodes(tree2.getRootNode());
    assertTrue("num nodes disagree", numNodes1 == numNodes2);
    //lgr.info("headings = " + numHeaders1);
    //lgr.info("nodes = " + numNodes1);

    // merge the trees and check that their stats are combined
    tree1.merge(tree2);
    boolean gotTitleMerged = (tree1.getTitleNode() != null);
    int numHeadersMerged = tree1.getHeadingNodes().size();
    int numNodesMerged = tree1.getNumNodes(tree1.getRootNode());
    //lgr.info("merged headings = " + numHeadersMerged);
    //lgr.info("merged nodes = " + numNodesMerged);
    assertTrue("seem to have mislaid merged title", gotTitleMerged);
    assertTrue( // headings = double each
      "wrong num merged headings", numHeadersMerged == (numHeaders1 * 2)
    );
    assertTrue( // double, minus one for the root
      "wrong num merged nodes", numNodesMerged == ((numNodes1 * 2) - 1)
    );

  } // testTreeMerging()


  /** Helper to check tree contents. */
  public boolean treeEmpty(SimpleNode n) {
    if(! (
        n.getStart() == null &&
        n.getEnd() == null &&
        n.getBody() == null
      )
    ) {
      //lgr.info("non-empty node: " + n.toString());
      //lgr.info(
      //  "n.getStart/End/Body: " + n.getStart() + n.getEnd() + n.getBody()
      //);
      return false;
    }

    int i = n.jjtGetNumChildren();
    if(i == 0) return true;
    for(int j = 0; j < i; j++)
      if(! treeEmpty((SimpleNode) n.jjtGetChild(j)))
        return false;

    return true;
  } // treeEmpty(SimpleNode)
  
} // YamParseTreeTests