/*
 * @(#)DemoTCKParameters.java	1.33 01/07/24 Jonathan Gibbons
 * 
 * Copyright 2001 Sun Microsystems, Inc. All rights reserved. 
 * Use is subject to license terms.
 *
 * Copyright 2001 Sun Microsystems, Inc. Tous droits réservés. 
 * Distribueé par des licences qui en restreignent l'utilisation.
 */

package com.sun.demotck.interview;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Vector;

import com.sun.interview.AllFilesFileFilter;
import com.sun.interview.ChoiceArrayQuestion;
import com.sun.interview.DirectoryFileFilter;
import com.sun.interview.ErrorQuestion;
import com.sun.interview.ExtensionFileFilter;
import com.sun.interview.FileListQuestion;
import com.sun.interview.FileFilter;
import com.sun.interview.FileQuestion;
import com.sun.interview.FilesAndDirectoriesFileFilter;
import com.sun.interview.FinalQuestion;
import com.sun.interview.IntQuestion;
import com.sun.interview.Interview;
import com.sun.interview.NullQuestion;
import com.sun.interview.Question;
import com.sun.interview.StringQuestion;
import com.sun.interview.WizEdit;
import com.sun.interview.WizPrint;
import com.sun.interview.YesNoQuestion;
import com.sun.interview.wizard.Exporter;
import com.sun.interview.wizard.Wizard;

import com.sun.javatest.CompositeFilter;
import com.sun.javatest.ExcludeTable;
import com.sun.javatest.ExcludeTableFilter;
import com.sun.javatest.FileParameters;
import com.sun.javatest.JavaTestError;
import com.sun.javatest.Keywords;
import com.sun.javatest.KeywordsFilter;
import com.sun.javatest.InterviewParameters;
import com.sun.javatest.Status;
import com.sun.javatest.StatusFilter;
import com.sun.javatest.TestDescription;
import com.sun.javatest.TestEnvContext;
import com.sun.javatest.TestEnvironment;
import com.sun.javatest.TestFilter;
import com.sun.javatest.TestResult;
import com.sun.javatest.TestResultTable;
import com.sun.javatest.TestSuite;
import com.sun.javatest.WorkDirectory;
import com.sun.javatest.interview.ConcurrencyInterview;
import com.sun.javatest.interview.ExcludeListInterview;
import com.sun.javatest.interview.InitialFilesInterview;
import com.sun.javatest.interview.KeywordsInterview;
import com.sun.javatest.interview.ReportInterview;
import com.sun.javatest.interview.StatusInterview;
import com.sun.javatest.interview.TimeoutFactorInterview;
import com.sun.javatest.util.I18NResourceBundle;
import com.sun.javatest.util.StringArray;

public class DemoTCKParameters extends InterviewParameters 
{

    public DemoTCKParameters() throws InterviewParameters.Fault {
	this(null);
    }

    public DemoTCKParameters(TestSuite ts) throws InterviewParameters.Fault {
	super("demotck");
	setDefaultImage(getClass().getResource("wave.med.gif"));
	setHelpSet("help/demotck");

	iConcurrency = new ConcurrencyInterview(this);
	iExcludeList = new ExcludeListInterview(this);
	iInitialFiles = new InitialFilesInterview(this);
	iKeywords = new KeywordsInterview(this);
	iReport = new ReportInterview(this);
	iStatus = new StatusInterview(this);
	iTimeoutFactor = new TimeoutFactorInterview(this);

	setFirstQuestion(qIntro);
	setTestSuite(ts);
	setEdited(false);
    }

    public TestEnvironment getEnv() {
	String envName = getEnvName();
	if (envName == null)
	    return null;

	Map m = new HashMap();
	iEnvironment.export(m);
	// could bypass TestEnvContext if defaults moved to TestEnvironment
	try {
	    File f = getFile();
	    String mapName = (f != null ? f.getPath() : getTitle());
	    TestEnvContext tec = new TestEnvContext(m, mapName);
	    return tec.getEnv(getEnvName());
	}
	catch (TestEnvironment.Fault e) {
	    I18NResourceBundle i18n = I18NResourceBundle.getBundleForClass(getClass());
	    throw new JavaTestError(i18n, "unexpected exception", e);
	}
    }

    public boolean isEnvNameEditable() {
	return false;
    }

    public String getEnvName() {
	return iEnvironment.getName();
    }

    public void setEnvName(String name) {
	// ignore it? throw exception?
    }

    public boolean isEnvFilesEditable() {
	return false;
    }

    public File[] getEnvFiles() {
	return new File[] { };
    }

    public void setEnvFiles(File[] files) {
	// ignore it? throw exception?
    }

    EnvironmentInterview getEnvironmentInterview() {
	return iEnvironment;
    }

    public void setFileParameters(FileParameters p) {
	// initial files...
	String initialFiles = p.getProperty(FileParameters.INITIAL_FILES);
	setInitialFiles(FileListQuestion.split(initialFiles));

	// exclude list ...
	String excludeLists = p.getProperty(FileParameters.EXCLUDE_LISTS);
	setExcludeFiles(FileListQuestion.split(excludeLists));

	// keywords ...
	String keywordOp = p.getProperty(FileParameters.KEYWORD_OP);
	String keywords = p.getProperty(FileParameters.KEYWORDS);
	iKeywords.setKeywords(keywordOp, keywords);

	// status
	String status = p.getProperty(FileParameters.STATUS);
	boolean[] values = new boolean[Status.NUM_STATES];
	for (int i = 0; i < values.length; i++) {
	    String s = p.getProperty(FileParameters.prevStrings[i]);
	    values[i] = "true".equals(s);
	}
	
	if (status == null || status.length() == 0 || status.equals(FileParameters.IGNORE))
	    setStatusTests(null);
	else
	    setStatusTests(values);

	// environment ....
	// (ignore env files, ignore env name)
	//String envName = p.getProperty(FileParameters.ENVIRONMENT);
	//if (envName != null) 
	//    iEnvironment.setName(envName);

	// concurrency ...
	try {
	    String s = p.getProperty(FileParameters.CONCURRENCY);
	    setConcurrency(s == null || s.length() == 0 ? 1 : Integer.parseInt(s));
	}
	catch (NumberFormatException e) {
	    setConcurrency(1);
	}

	// timeout factor ...
	try {
	    String s = p.getProperty(FileParameters.TIMEOUT);
	    setTimeoutFactor(s == null || s.length() == 0 ? 1 : Integer.parseInt(s));
	}
	catch (NumberFormatException e) {
	    setTimeoutFactor(1);
	}

	// report ...
	String reportDir = p.getProperty(FileParameters.REPORT_DIR);
	if (reportDir == null || reportDir.length() == 0)
	    setReportDir(null);
	else
	    setReportDir(new File(reportDir));
    }

    //----------------------------------------------------------------------------

    String getTestClassPath() {
	if (testSuite == null)
	    return null;
	else
	    return getTestSuite().getTestSuiteInfo("testclasspath");
    }

    private String testClassPath;
	    

    //----------------------------------------------------------------------------

    public TestSuite getTestSuite() {
	return testSuite;
    }

    public void setTestSuite(TestSuite newTestSuite) {
	if (!isTestSuiteEditable() || (getWorkDirectory() != null && !isWorkDirectoryEditable())) 
	    throw new IllegalStateException();

	testSuite = newTestSuite;
	workDir = null;
    }

    private TestSuite testSuite;

    //----------------------------------------------------------------------------

    public WorkDirectory getWorkDirectory() {
	TestSuite ts = getTestSuite();
	if (ts == null)
	    return null;

	return workDir;
    }

    public void setWorkDirectory(WorkDirectory newWorkDir) {
	if (!isWorkDirectoryEditable())
	    throw new IllegalStateException();

	TestSuite ts = getTestSuite();
	if (ts == null) 
	    setTestSuite(newWorkDir.getTestSuite());
	else if (newWorkDir.getTestSuite() != ts)
	    throw new IllegalArgumentException();

	workDir = newWorkDir;
    }

    private WorkDirectory workDir;

    //----------------------------------------------------------------------------
    //
    // Welcome to the JCK Configuration Editor!

    private Question qIntro = new NullQuestion(this, "intro") {
	protected Question getNext() {
	    return callInterview(iEnvironment, qParameters);
	}
    };

    //----------------------------------------------------------------------------
    //
    // Parameter questions

    private Question qParameters = new NullQuestion(this, "parameters") {
	protected Question getNext() {
	    return callInterview(iInitialFiles, getInitialFilesSuccessor());
	}
    };


    //----------------------------------------------------------------------------
    //
    // Initial files

    public File[] getInitialFiles() {
	return iInitialFiles.getInitialFiles();
    }

    public void setInitialFiles(File[] files) {
	iInitialFiles.setInitialFiles(files);
    }

    protected Question getInitialFilesSuccessor() {
	return qFilters;
    }


    //----------------------------------------------------------------------------
    //
    // Filters

    private Question qFilters = new NullQuestion(this, "filters") {
	protected Question getNext() {
	    return callInterview(iExcludeList, getExcludeListSuccessor());
	}
    };


    //----------------------------------------------------------------------------

    public TestFilter getRelevantTestFilter() {
	TestFilter tsF = getTestSuite().createTestFilter(getEnv());
	TestFilter jtx = getExcludeFilter();
	I18NResourceBundle i18n = I18NResourceBundle.getBundleForClass(getClass());

	// get the non-null filters
	Vector v = new Vector(2);
	if (tsF != null) v.add(tsF);
	if (jtx != null) v.add(jtx);

	// create an array
	TestFilter[] set = new TestFilter[v.size()];
	v.copyInto(set);

	// create composite
	CompositeFilter cf = new CompositeFilter(set, i18n, "params.rFilter");
	return cf;
    }

    //----------------------------------------------------------------------------
    //
    // Exclude Lists

    public File[] getExcludeFiles() {
	return iExcludeList.getExcludeFiles();
    }

    public void setExcludeFiles(File[] files) {
	    iExcludeList.setExcludeFiles(files);
    }

    public TestFilter getExcludeFilter() {
	return iExcludeList.getExcludeFilter();
    }

    public ExcludeTable getExcludeTable() {
	return iExcludeList.getExcludeTable();
    }

    protected Question getExcludeListSuccessor() {
	return callInterview(iKeywords, getKeywordsSuccessor());
    }

    //----------------------------------------------------------------------------
    //
    // Keywords

    public Keywords getKeywords() {
	return iKeywords.getKeywords();
    }

    public String getKeywordExpr() {
	return iKeywords.getKeywordExpr();
    }	

    public void setKeywordExpr(String expr) {
	iKeywords.setKeywordExpr(expr);
    }

    public TestFilter getKeywordFilter() {
	return iKeywords.getKeywordFilter();
    }

    protected Question getKeywordsSuccessor() {
	return callInterview(iStatus, getStatusSuccessor());
    }


    //----------------------------------------------------------------------------
    //
    // Status

    public boolean[] getStatusTests() {
	return iStatus.getStatusTests();
    }

    public void setStatusTests(boolean[] b) {
	iStatus.setStatusTests(b);
    }

    public TestFilter getStatusFilter() {
	return iStatus.getStatusFilter();
    }

    protected Question getStatusSuccessor() {
	return callInterview(iConcurrency, getConcurrencySuccessor());
    }

    //----------------------------------------------------------------------------
    //
    // Concurrency

    public int getConcurrency() {
	return iConcurrency.getConcurrency();
    }

    public void setConcurrency(int conc) {
	iConcurrency.setConcurrency(conc);
    }

    protected Question getConcurrencySuccessor() {
	return callInterview(iTimeoutFactor, getTimeoutFactorSuccessor());
    }

    //----------------------------------------------------------------------------
    //
    // Time Factor

    public int getTimeoutFactor() {
	return iTimeoutFactor.getTimeoutFactor();
    }

    public void setTimeoutFactor(int t) {
	iTimeoutFactor.setTimeoutFactor(t);
    }

    protected Question getTimeoutFactorSuccessor() {
	return callInterview(iReport, getReportSuccessor());
    }


    //----------------------------------------------------------------------------
    //
    // Report

    public File getReportDir() {
	return iReport.getReportDir();
    }

    public void setReportDir(File dir) {
	iReport.setReportDir(dir);
    }

    protected Question getReportSuccessor() {
	return qEnd;
    }

    //----------------------------------------------------------------------------
    //
    // This completes the JCK configuration for your product.

    private Question qEnd = new FinalQuestion(this, "end");

    //----------------------------------------------------------------------------

    private final EnvironmentInterview iEnvironment = new EnvironmentInterview(this);

    // default interviews
    private final ConcurrencyInterview iConcurrency;
    private final ExcludeListInterview iExcludeList;
    private final InitialFilesInterview iInitialFiles;
    private final KeywordsInterview iKeywords;
    private final ReportInterview iReport;
    private final StatusInterview iStatus;
    private final TimeoutFactorInterview iTimeoutFactor;

    //----------------------------------------------------------------------------


    private static boolean equal(File f1, File f2) {
	return (f1 == null ? f2 == null : f1.equals(f2));
    }

    private static boolean equal(File[] f1, File[] f2) {
	if (f1 == null || f2 == null)
	    return (f1 == f2);

	if (f1.length != f2.length)
	    return false;

	for (int i = 0; i < f1.length; i++) {
	    if (f1[i] != f2[i])
		return false;
	}

	return true;
    }

    private static boolean equal(String s1, String s2) {
	return (s1 == null ? s2 == null : s1.equals(s2));
    }

    //----------------------------------------------------------------------------

    private static final File userDir = new File(System.getProperty("user.dir"));
}