/*
 * 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.
 */
/*
 * $Id$
 */

package org.apache.qetest;

import java.io.File;
import java.io.FilenameFilter;
import java.lang.reflect.Constructor;
import java.util.Enumeration;
import java.util.Properties;
import java.util.Vector;

/**
 * Generic Test driver for FileTestlets.
 * 
 * <p>This driver provides basic services for iterating over a tree 
 * of test files and executing a specified testlet on each test that 
 * is selected by a set of specified filters.  It automatically handles 
 * iteration and optional recursion down the tree, and by default 
 * assumes there are three 'matching' trees for inputs, golds, and 
 * creates a tree for outputs.</p>
 *
 * <p>Key methods are separated into worker methods so subclasses can 
 * override just the parts of the algorithm they need to change.</p>
 *
 * <p>//@todo move and refactor XSLProcessorTestBase to 
 * be more generic and reduce dependencies; also reduce dependency 
 * on internal variables and instead always use lookups into 
 * our testProps object.</p>
 * 
 * @author shane_curcuru@us.ibm.com
 * @version $Id$
 */
public class FileTestletDriver extends FileBasedTest /// extends XSLProcessorTestBase
{

    //-----------------------------------------------------
    //-------- Constants for common input params --------
    //-----------------------------------------------------

    /**
     * Parameter: Run a specific list of files, instead of 
     * iterating over directories.  
     * <p>Default: null, do normal iteration.</p>
     */
    public static final String OPT_FILELIST = "fileList";

    /**
     * Parameter: FQCN or simple classname of Testlet to use.  
     * <p>User may pass in either a FQCN or just a base classname, 
     * and we will attempt to look it up in any of the most common 
     * Xalan-testing packages.  See QetestUtils.testClassForName().</p>
     * <p>Default: null, use StylesheetTestlet.</p>
     */
    public static final String OPT_TESTLET = "testlet";

    /** Classname of Testlet to use.   */
    protected String testlet = null;

    /**
     * Parameter: FQCN or simple classname of FilenameFilter for 
     * directories under testDir we will process.  
     * If fileList is not set, we simply go to our inputDir, and 
     * then use this filter to iterate through directories returned.
     * <p>Default: null, use ConformanceDirRules.</p>
     */
    public static final String OPT_DIRFILTER = "dirFilter";

    /** Classname of FilenameFilter to use for dirs.  */
    protected String dirFilter = null;

    /**
     * Parameter: FQCN or simple classname of FilenameFilter for 
     * files within subdirs we will process.  
     * If fileList is not set, we simply go through all directories 
     * specified by directoryFilter, and then use this filter to 
     * find all stylesheet test files in that directory to test.
     * Note that this does <b>not</b> handle embedded tests, where 
     * the XML document has an xml-stylesheet PI that defines the 
     * stylesheet to use to process it.
     * <p>Default: null, use ConformanceFileRules.</p>
     */
    public static final String OPT_FILEFILTER = "fileFilter";

    /** Classname of FilenameFilter to use for files.  */
    protected String fileFilter = null;

    /** Unique runId for each specific invocation of this test driver.  */
    protected String runId = null;

    /** Convenience constant: .gold extension for gold files.  */
    public static final String GLD_EXTENSION = ".gld";

    /** Convenience constant: .out extension for output result file.  */
    public static final String OUT_EXTENSION = ".out";


    /** Just initialize test name, comment; numTestCases is not used. */
    public FileTestletDriver()
    {
        testName = "FileTestletDriver";
        testComment = "Test driver for File-based Testlets";
    }


    /**
     * Initialize this test - fill in parameters.
     * Simply fills in convenience variables from user parameters.
     *
     * @param p unused
     * @return true
     */
    public boolean doTestFileInit(Properties p)
    {
        // Copy any of our parameters from testProps to 
        //  our local convenience variables
        testlet = testProps.getProperty(OPT_TESTLET, testlet);
        dirFilter = testProps.getProperty(OPT_DIRFILTER, dirFilter);
        fileFilter = testProps.getProperty(OPT_FILEFILTER, fileFilter);

        // Grab a unique runid for logging out with our tests 
        //  Used in results reporting stylesheets to differentiate 
        //  between different test runs
        runId = QetestUtils.createRunId(testProps.getProperty("runId"));
        testProps.put("runId", runId);  // put back in the properties 
                                        // for later use
        return true;
    }


    /**
     * Run through the directory given to us and run tests found
     * in subdirs; or run through our fileList.
     *
     * This method logs some basic runtime data (like the actual 
     * testlet and ProcessorWrapper implementations used) and 
     * then decides to either run a user-specified fileList or to 
     * use our dirFilter to iterate over the inputDir.
     *
     * @param p Properties block of options to use - unused
     * @return true if OK, false if we should abort
     */
    public boolean runTestCases(Properties p)
    {
        // First log out any other runtime information, like the 
        //  actual current testlet and filters
        try
        {
            // Note that each of these calls actually force the 
            //  creation of an actual object of each type: this is 
            //  required since we may default the types or our call 
            //  to QetestUtils.testClassForName() may return a 
            //  different classname than the user actually specified
            // Care should be taken that the construction of objects 
            //  here does not affect our testing later on
            Properties runtimeProps = new Properties();
            // ... and add a few extra things ourselves
            runtimeProps.put("actual.testlet", getTestlet());
            runtimeProps.put("actual.dirFilter", getDirFilter());
            runtimeProps.put("actual.fileFilter", getFileFilter());
            reporter.logHashtable(Logger.CRITICALMSG, runtimeProps, 
                                  "actual.runtime information");
        }
        catch (Exception e)
        {
            // This is not necessarily an error
            reporter.logThrowable(Logger.WARNINGMSG, e, "Logging actual.runtime threw");
        }

        // Now either run a list of specific tests the user specified, 
        //  or do the default of iterating over a set of directories
        String fileList = testProps.getProperty(OPT_FILELIST);
        if (null != fileList)
        {
            // Process the specific list of tests the user supplied
            String desc = "User-supplied fileList: " + fileList; // provide default value
            // Use static worker class to process the list
            Vector datalets = FileDataletManager.readFileList(reporter, fileList, desc, testProps);

            // Actually process the specified files in a testCase
            processFileList(datalets, desc);
        }
        else
        {
            // Do the default, which is to iterate over the inputDir
            // Note that this calls the testCaseInit/testCaseClose
            //  logging methods itself
            processInputDir();
        }
        return true;
    }


    /**
     * Do the default: test all files found in subdirs
     * of our inputDir, using FilenameFilters for dirs and files.
     * Parameters: none, uses our internal members inputDir, 
     * outputDir, goldDir, etc.  Will attempt to use a default 
     * inputDir if the specified one doesn't exist.
     *
     * This is a special case of recurseSubDir, since we report 
     * differently from the top level.
     */
    public void processInputDir()
    {
        // Ensure the inputDir is there - we must have a valid location for input files
        File topInputDir = new File(inputDir);

        if (!topInputDir.exists())
        {
            // Try a default inputDir
            String oldInputDir = inputDir; // cache for potential error message
            topInputDir = new File((inputDir = getDefaultInputDir()));
            if (!topInputDir.exists())
            {
                // No inputDir, can't do any tests!
                // Note we put this in a fake testCase, since this
                //  is likely the only thing our test reports
                reporter.testCaseInit("processInputDir - mock testcase");
                reporter.checkErr("topInputDir(" + oldInputDir
                                  + ", or " + inputDir + ") does not exist, aborting!");
                reporter.testCaseClose();
                return;
            }
        }

        FileDatalet topDirs = new FileDatalet(topInputDir.getPath(), outputDir, goldDir);

        // Optionally process this topDirs, and always recurse at 
        //  least one level below it
        recurseSubDir(topDirs, getProcessTopDir(), true);
    }


    /**
     * Optionally process all the files in this dir and optionally 
     * recurse downwards using our dirFilter.
     * 
     * This is a pre-order traversal; we process files in this 
     * dir first and then optionally recurse.
     *
     * @param base FileDatalet representing the input, output, 
     * gold directory triplet we should use
     * @param process if we should call processSubDir on this dir
     * @param recurse if we should recurse below this directory, 
     * or just stop here after processSubDir()
     */
    public void recurseSubDir(FileDatalet base, boolean process, boolean recurse)
    {
        // Process this directory first: pre-order traversal
        if (process)
            processSubDir(base);

        if (!recurse)
            return;

        // If we should recurse, do so now
        File inputDir = new File(base.getInput());
        FilenameFilter filter = getDirFilter();
        reporter.logTraceMsg("recurseSubDir(" + inputDir.getPath()
                            + ") looking for subdirs with: " + filter);

        // Use our filter to get a list of directories to process
        String subdirs[] = inputDir.list(filter);

        // Validate that we have some valid directories to process
        if ((null == subdirs) || (subdirs.length <= 0))
        {
            reporter.logWarningMsg("recurseSubDir(" + inputDir.getPath()
                               + ") no valid subdirs found!");
            return;
        }

        // For every subdirectory, check if we should run tests in it
        for (int i = 0; i < subdirs.length; i++)
        {
            File subTestDir = new File(inputDir, subdirs[i]);

            if ((null == subTestDir) || (!subTestDir.exists()))
            {
                // Just log it and continue; presumably we'll find 
                //  other directories to test
                reporter.logWarningMsg("subTestDir(" + subTestDir.getPath() 
                                       + ") does not exist, skipping!");
                continue;
            }
            FileDatalet subdir = new FileDatalet(base, subdirs[i]);

            // Process each other directory, and optionally continue 
            //  to recurse downwards
            recurseSubDir(subdir, true, getRecurseDirs());
        } // end of for...
    }


    /**
     * Process a single subdirectory and run our testlet over 
     * every file found by our fileFilter therein.
     *
     * @param base FileDatalet representing the input, output, 
     * gold directory triplet we should use
     */
    public void processSubDir(FileDatalet base)
    {
        // Validate that each of the specified dirs exists
        // Ask it to be strict in ensuring output, gold are created
        if (!base.validate(true))
        {
            // Just log it and continue; presumably we'll find 
            //  other directories to test
            reporter.logWarningMsg("processSubDir(" + base.getInput() 
                                   + ", " + base.getOutput()
                                   + ", " + base.getGold()
                                   + ") some dir does not exist, skipping!");
            return;
        }

        File subInputDir = new File(base.getInput());
        // Call worker method to process the individual directory
        //  and get a list of .xsl files to test
        Vector files = getFilesFromDir(subInputDir, getFileFilter());

        if ((null == files) || (0 == files.size()))
        {
            reporter.logStatusMsg("processSubDir(" + base.getInput() 
                                   + ") no files found(1), skipping!");
            return;
        }

        // 'Transform' the list of individual test files into a 
        //  list of Datalets with all fields filled in
        //@todo should getFilesFromDir and buildDatalets be combined?
        Vector datalets = buildDatalets(files, base);

        if ((null == datalets) || (0 == datalets.size()))
        {
            reporter.logWarningMsg("processSubDir(" + base.getInput() 
                                   + ") no tests found(2), skipping!");
            return;
        }

        // Now process the list of files found in this dir
        processFileList(datalets, "Testing subdir: " + base.getInput());
    }


    /**
     * Run a list of stylesheet tests through a Testlet.
     * The file names are assumed to be fully specified, and we assume
     * the corresponding directories exist.
     * Each fileList is turned into a testcase.
     *
     * @param vector of Datalet objects to pass in
     * @param desc String to use as testCase description
     */
    public void processFileList(Vector datalets, String desc)
    {
        // Validate arguments
        if ((null == datalets) || (0 == datalets.size()))
        {
            // Bad arguments, report it as an error
            // Note: normally, this should never happen, since 
            //  this class normally validates these arguments 
            //  before calling us
            reporter.checkErr("processFileList: Testlet or datalets are null/blank, nothing to test!");
            return;
        }

        // Put each fileList into a testCase
        reporter.testCaseInit(desc);

        // Now just go through the list and process each set
        int numDatalets = datalets.size();
        reporter.logInfoMsg("processFileList() with " + numDatalets
                            + " potential tests");
        // Iterate over every datalet and test it
        for (int ctr = 0; ctr < numDatalets; ctr++)
        {
            try
            {
                // Create a Testlet to execute a test with this 
                //  next datalet - the Testlet will log all info 
                //  about the test, including calling check*()
                getTestlet().execute((Datalet)datalets.elementAt(ctr));
            } 
            catch (Throwable t)
            {
                // Log any exceptions as fails and keep going
                reporter.logThrowable(Logger.ERRORMSG, t, "Datalet threw");
                reporter.checkErr("Datalet num " + ctr + " threw: " + t.toString());
            }
        }  // of while...
        reporter.testCaseClose();
    }


    /**
     * Use the supplied filter on given directory to return a list 
     * of tests to be run.
     * 
     * The real logic is in the filter, which can be specified as 
     * an option or by overriding getDefaultFileFilter().
     *
     * @param dir directory to scan
     * @param filter to use on this directory; if null, uses default
     * @return Vector of local path\filenames of tests to run;
     * the tests themselves will exist; null if error
     */
    public Vector getFilesFromDir(File dir, FilenameFilter filter)
    {
        // Validate arguments
        if ((null == dir) || (!dir.exists()))
        {
            // Bad arguments, report it as an error
            // Note: normally, this should never happen, since 
            //  this class normally validates these arguments 
            //  before calling us
            reporter.logWarningMsg("getFilesFromDir(" + dir.toString() + ") dir null or does not exist");
            return null;
        }
        // Get the list of 'normal' test files
        String[] files = dir.list(filter);
        Vector v = new Vector(files.length);
        for (int i = 0; i < files.length; i++)
        {
            v.addElement(files[i]);
        }
        reporter.logTraceMsg("getFilesFromDir(" + dir.toString() + ") found " + v.size() + " total files to test");
        return v;
    }


    /**
     * Transform a vector of individual test names into a Vector 
     * of filled-in datalets to be tested
     *
     * This basically just calculates local path\filenames across 
     * the three presumably-parallel directory trees of  
     * inputDir, outputDir and goldDir.  
     * It then stuffs each of these values plus some 
     * generic info like our testProps into each datalet it creates.
     * 
     * @param files Vector of local path\filenames to be tested
     * @param base FileDatalet denoting directories 
     * input, output, gold
     * @return Vector of FileDatalets that are fully filled in,
     * i.e. output, gold, etc are filled in respectively 
     * to input
     */
    public Vector buildDatalets(Vector files, FileDatalet base)
    {
        // Validate arguments
        if ((null == files) || (files.size() < 1))
        {
            // Bad arguments, report it as an error
            // Note: normally, this should never happen, since 
            //  this class normally validates these arguments 
            //  before calling us
            reporter.logWarningMsg("buildDatalets null or empty file vector");
            return null;
        }
        Vector v = new Vector(files.size());

        // For every file in the vector, construct the matching 
        //  out, gold, and xml/xsl files
        for (Enumeration elements = files.elements();
                elements.hasMoreElements(); /* no increment portion */ )
        {
            String file = null;
            try
            {
                file = (String)elements.nextElement();
            }
            catch (ClassCastException cce)
            {
                // Just skip this entry
                reporter.logWarningMsg("Bad file element found, skipping: " + cce.toString());
                continue;
            }
            v.addElement(buildDatalet(base, file));
        }
        return v;
    }

    /**
     * Construct a FileDatalet with corresponding output, gold files.  
     *
     * This basically just calls worker methods to construct and 
     * set options on a datalet to return.
     *
     * @param base FileDatalet denoting directories 
     * input, output, gold
     * @param name bare name of the input file
     * @return FileDatalet that is fully filled in,
     * i.e. output, gold, etc are filled in respectively 
     * to input and any options are set
     */
    protected FileDatalet buildDatalet(FileDatalet base, String name)
    {
        // Worker method to construct paths
        FileDatalet d = buildDataletPaths(base, name);
        // Worker method to set any other options, etc.
        setDataletOptions(d);
        return d;
    }

    /**
     * Construct a FileDatalet with corresponding output, gold files.  
     *
     * This worker method just has the logic to construct the 
     * corresponding output and gold filenames; feel free to subclass.
     *
     * This class simply appends .out and .gld to the end of the 
     * existing names: foo.xml: foo.xml.out, foo.xml.gld.
     *
     * @param base FileDatalet denoting directories 
     * input, output, gold
     * @param name bare name of the input file
     * @return FileDatalet that is fully filled in,
     * i.e. output, gold, etc are filled in respectively 
     * to input
     */
    protected FileDatalet buildDataletPaths(FileDatalet base, String name)
    {
        return new FileDatalet(base.getInput() + File.separator + name, 
                base.getOutput() + File.separator + name + OUT_EXTENSION,
                base.getGold() + File.separator + name + GLD_EXTENSION);
    }

    /**
     * Fillin FileDatalet.setOptions and any other processing.  
     *
     * This is designed to be overriden so subclasses can put any 
     * special items in the datalet's options or do other 
     * preprocessing of the datalet.
     *
     * @param base FileDatalet to apply options, etc. to
     */
    protected void setDataletOptions(FileDatalet base)
    {
        base.setDescription(base.getInput());
        // Optimization: put in a copy of our fileChecker, so 
        //  that each testlet doesn't have to create it's own
        //  fileCheckers should not store state, so this 
        //  shouldn't affect the testing at all
        base.setOptions(testProps);
        // Note: set our options in the datalet first, then 
        //  put the fileChecker directly into their options
        base.getOptions().put("fileCheckerImpl", fileChecker);
    }

    /** If we should process the top level directory (default:false).   */
    protected boolean getProcessTopDir()
    { return false; }

    /** If we should always recurse lower level directories (default:false).   */
    protected boolean getRecurseDirs()
    { return false; }

    /** Default FilenameFilter FQCN for directories.   */
    protected String getDefaultDirFilter()
    { return "org.apache.qetest.DirFilter"; }

    /** Default FilenameFilter FQCN for files.   */
    protected String getDefaultFileFilter()
    { return "org.apache.qetest.FilePatternFilter"; }

    /** Default Testlet FQCN for executing stylesheet tests.   */
    protected String getDefaultTestlet()
    { return "org.apache.qetest.FileTestlet"; }

    /** Default list of packages to search for classes.   */
    protected String[] getDefaultPackages()
    { return QetestUtils.defaultPackages; }

    /** Cached Testlet Class; used for life of this test.   */
    protected Class cachedTestletClazz = null;

    /**
     * Convenience method to get a Testlet to use.  
     * Attempts to return one as specified by our testlet parameter, 
     * otherwise returns a default StylesheetTestlet.
     * 
     * @return Testlet for use in this test; null if error
     */
    public Testlet getTestlet()
    {
        // Find a Testlet class to use if we haven't already
        if (null == cachedTestletClazz)
        {
            cachedTestletClazz = QetestUtils.testClassForName(testlet, 
                                                              getDefaultPackages(),
                                                              getDefaultTestlet());
        }
        try
        {
            // Create it and set our reporter into it
            Testlet t = (Testlet)cachedTestletClazz.newInstance();
            t.setLogger((Logger)reporter);
            return (Testlet)t;
        }
        catch (Exception e)
        {
            // Ooops, none found! This should be very rare, since 
            //  we know the defaultTestlet should be found
            return null;
        }
    }


    /**
     * Convenience method to get a default filter for directories.  
     * Uses category member variable if set.
     * 
     * @return FilenameFilter using DirFilter(category, null).
     */
    public FilenameFilter getDirFilter()
    {
        // Find a FilenameFilter class to use
        Class clazz = QetestUtils.testClassForName(dirFilter, 
                                                   getDefaultPackages(),
                                                   getDefaultDirFilter());
        try
        {
            // Create it, optionally with a category
            String category = testProps.getProperty(OPT_CATEGORY);
            if ((null != category) && (category.length() > 1))  // Arbitrary check for non-null, non-blank string
            {
                Class[] parameterTypes = 
                { 
                    java.lang.String.class, 
                    java.lang.String.class 
                };
                Constructor ctor = clazz.getConstructor(parameterTypes);

                Object[] ctorArgs = 
                {
                    category, 
                    null
                };
                return (FilenameFilter)ctor.newInstance(ctorArgs);
            }
            else
            {
                return (FilenameFilter)clazz.newInstance();
            }
        }
        catch (Exception e)
        {
            // Ooops, none found!
            return null;
        }
    }


    /**
     * Convenience method to get a default filter for files.  
     * Uses excludes member variable if set.
     * 
     * @return FilenameFilter using FileExtensionFilter(null, excludes).
     */
    public FilenameFilter getFileFilter()
    {
        // Find a FilenameFilter class to use
        Class clazz = QetestUtils.testClassForName(fileFilter, 
                                                   getDefaultPackages(),
                                                   getDefaultFileFilter());
        try
        {
            // Create it, optionally with excludes
            String excludes = testProps.getProperty(OPT_EXCLUDES);
            if ((null != excludes) && (excludes.length() > 1))  // Arbitrary check for non-null, non-blank string
            {
                Class[] parameterTypes = 
                { 
                    java.lang.String.class, 
                    java.lang.String.class 
                };
                Constructor ctor = clazz.getConstructor(parameterTypes);

                Object[] ctorArgs = 
                {
                    null, 
                    excludes
                };
                return (FilenameFilter)ctor.newInstance(ctorArgs);
            }
            else
            {
                return (FilenameFilter)clazz.newInstance();
            }
        }
        catch (Exception e)
        {
            // Ooops, none found!
            return null;
        }
    }


    /**
     * Convenience method to get a default inputDir when none or
     * a bad one was given.  
     * @return String pathname of default inputDir "tests\conf".
     */
    public String getDefaultInputDir()
    {
        return "tests" + File.separator + "conf";
    }


    /**
     * Convenience method to print out usage information - update if needed.  
     * @return String denoting usage of this test class
     */
    public String usage()
    {
        return ("Additional options supported by FileTestletDriver:\n"
                + "    -" + OPT_FILELIST
                + "   <name of listfile of tests to run>\n"
                + "    -" + OPT_DIRFILTER
                + "  <classname of FilenameFilter for dirs>\n"
                + "    -" + OPT_FILEFILTER
                + " <classname of FilenameFilter for files>\n"
                + "    -" + OPT_TESTLET
                + "    <classname of Testlet to execute tests with>\n"
                + super.usage());   // Grab our parent classes usage as well
    }


    /**
     * Main method to run test from the command line - can be left alone.  
     * @param args command line argument array
     */
    public static void main(String[] args)
    {
        FileTestletDriver app = new FileTestletDriver();
        app.doMain(args);
    }
}