/*
 * Copyright 2005-2006 Sun Microsystems, Inc.  All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 *  
 */

import java.util.*;
import java.io.File;

class BuildConfig {
    Hashtable vars;
    Vector basicNames, basicPaths;
    String[] context;

    static CompilerInterface ci;
    static CompilerInterface getCI() {
	if (ci == null) {
	    String comp = (String)getField(null, "CompilerVersion");
	    try {
		ci = (CompilerInterface)Class.forName("CompilerInterface" + comp).newInstance();
	    } catch (Exception cnfe) {
		System.err.println("Cannot find support for compiler " + comp);
		throw new RuntimeException(cnfe.toString());
	    }
	}
	return ci;
    }

    protected void initNames(String flavour, String build, String outDll) {
	if (vars == null) vars = new Hashtable();
	
	String flavourBuild =  flavour + "_" + build;
	put("Name", getCI().makeCfgName(flavourBuild));
	put("Flavour", flavour);
	put("Build", build);

	// ones mentioned above were needed to expand format
	String buildBase = expandFormat(getFieldString(null, "BuildBase"));
	String jdkDir =  getFieldString(null, "JdkTargetRoot");
	String sourceBase = getFieldString(null, "SourceBase");	
	String outDir = buildBase;
	
	put("Id", flavourBuild);
	put("OutputDir", outDir);
	put("SourceBase", sourceBase);
	put("BuildBase", buildBase);
	put("OutputDll", jdkDir + Util.sep + outDll);

	context = new String [] {flavourBuild, flavour, build, null};
    }
    
    protected void init(Vector includes, Vector defines) {
	initDefaultDefines(defines);
	initDefaultCompilerFlags(includes);
	initDefaultLinkerFlags();
	handleDB((String)getFieldInContext("IncludeDB"));
    }


    protected void initDefaultCompilerFlags(Vector includes) {	
	Vector compilerFlags = new Vector();

	compilerFlags.addAll(getCI().getBaseCompilerFlags(getV("Define"), 
							  includes, 
							  get("OutputDir")));
	
	put("CompilerFlags", compilerFlags);
    }

    protected void initDefaultLinkerFlags() {
	Vector linkerFlags = new Vector();

	linkerFlags.addAll(getCI().getBaseLinkerFlags( get("OutputDir"), get("OutputDll")));

	put("LinkerFlags", linkerFlags);
    }
    
    DirectoryTree getSourceTree(String sourceBase, String startAt) {
	DirectoryTree tree = new DirectoryTree();

	tree.addSubdirToIgnore("Codemgr_wsdata");
	tree.addSubdirToIgnore("deleted_files");
	tree.addSubdirToIgnore("SCCS");
	tree.setVerbose(true);
	if (startAt != null) {
	    tree.readDirectory(sourceBase + File.separator + startAt);
	} else {
	    tree.readDirectory(sourceBase);
	}

	return tree;
    }


    Vector getPreferredPaths(Database currentDB) {
	Vector preferredPaths = new Vector();
    	// In the case of multiple files with the same name in
	// different subdirectories, prefer the versions specified in
	// the platform file as the "os_family" and "arch" macros.
	for (Iterator iter = currentDB.getMacros(); iter.hasNext(); ) {
	    Macro macro = (Macro) iter.next();
	    if (macro.name.equals("os_family") ||
		macro.name.equals("arch")) {
		preferredPaths.add(macro.contents);
	    }
	}
	// Also prefer "opto" over "adlc" for adlcVMDeps.hpp
	preferredPaths.add("opto");
	
	return preferredPaths;
    }


    void handleDB(String dbFile) {	
	WinGammaPlatform platform = (WinGammaPlatform)getField(null, "PlatformObject");
	Database db = new Database(platform, platform.defaultGrandIncludeThreshold());

	try {
	    File incls = new File(get("OutputDir")+Util.sep+"incls");
	    FileName oldInclTempl = platform.getInclFileTemplate();
	    FileName oldGITempl = platform.getGIFileTemplate();
	    FileName oldGDTempl = platform.getGDFileTemplate();
	    
	    platform.setInclFileTemplate(new FileName(platform, incls.getPath()+Util.sep, 
						      "_", "", ".incl", "", ""));
	    platform.setGIFileTemplate(new FileName(platform, incls.getPath()+Util.sep, 
						    "",  "_precompiled", ".incl", "", ""));
	    
	    incls.mkdirs();
	    
	    db.get(getFieldString(null, "Platform"), dbFile);
	    db.compute();
	    
	    db.put();

	    //platform.setInclFileTemplate(oldInclTempl);
	    //platform.setGIFileTemplate(oldInclTempl);
	} catch (Exception e) {
	    e.printStackTrace();
	    throw new RuntimeException("cannot do db: "+e);
	}
	
	putSpecificField("AllFilesHash", computeAllFiles(platform, db));
    }


    void addAll(Iterator i, Hashtable hash, 
		WinGammaPlatform platform, DirectoryTree tree, 
		Vector preferredPaths, Vector filesNotFound, Vector filesDuplicate) {
	for (; i.hasNext(); ) {
	    String fileName = (String) i.next();
	    if (lookupHashFieldInContext("IgnoreFile", fileName) == null) {		
		String prefixedName = platform.envVarPrefixedFileName(fileName,
								      0, /* ignored */
								      tree,
								      preferredPaths,
								      filesNotFound,
								      filesDuplicate);
		if (prefixedName != null) {
		    addTo(hash, Util.normalize(prefixedName), fileName);
		}
	    }
	}
    }

    void addTo(Hashtable ht, String key, String value) {
	ht.put(expandFormat(key), expandFormat(value));
    }

    Hashtable computeAllFiles(WinGammaPlatform platform, Database db) {
	Hashtable rv = new Hashtable();
	DirectoryTree tree = getSourceTree(get("SourceBase"), getFieldString(null, "StartAt"));
	Vector preferredPaths = getPreferredPaths(db);
	
	// Hold errors until end
	Vector filesNotFound = new Vector();
	Vector filesDuplicate = new Vector();


	// find all files
	Vector dbFiles = new Vector();
	for (Iterator i=db.getAllFiles().iterator(); i.hasNext(); ) {
	    FileList fl = (FileList) i.next();	    
	    dbFiles.add(fl.getName());
	}
	addAll(dbFiles.iterator(), rv,   
	       platform, tree, 
	       preferredPaths, filesNotFound, filesDuplicate);

	Vector addFiles = new Vector();	
	collectRelevantVectors(addFiles, "AdditionalFile");
	addAll(addFiles.iterator(), rv,
	       platform, tree, 
	       preferredPaths, filesNotFound, filesDuplicate);
	
	collectRelevantHashes(rv, "AdditionalGeneratedFile");	 
		
	if ((filesNotFound.size() != 0) ||
	    (filesDuplicate.size() != 0)) {
	    System.err.println("Error: some files were not found or " +
			       "appeared in multiple subdirectories of " +
			       "directory " + get("SourceBase") + " and could not " +
			       "be resolved with the os_family and arch " +
			       "macros in the platform file.");
	    if (filesNotFound.size() != 0) {
		System.err.println("Files not found:");
		for (Iterator iter = filesNotFound.iterator();
		     iter.hasNext(); ) {
		    System.err.println("  " + (String) iter.next());
		}
	    }
	    if (filesDuplicate.size() != 0) {
		System.err.println("Duplicate files:");
		for (Iterator iter = filesDuplicate.iterator();
		     iter.hasNext(); ) {
		    System.err.println("  " + (String) iter.next());
		}
	    }
	    throw new RuntimeException();
	}

	return rv;
    }

    void initDefaultDefines(Vector defines) { 
    	Vector sysDefines = new Vector();
	sysDefines.add("WIN32");
	sysDefines.add("_WINDOWS");
	sysDefines.add("HOTSPOT_BUILD_USER="+System.getProperty("user.name"));
	sysDefines.add("HOTSPOT_BUILD_TARGET=\\\""+get("Build")+"\\\"");
	sysDefines.add("_JNI_IMPLEMENTATION_");

	sysDefines.addAll(defines);
	
	put("Define", sysDefines);
    }	

    String get(String key) {
	return (String)vars.get(key);
    }

    Vector getV(String key) {
	return (Vector)vars.get(key);
    }

    Object getO(String key) {
	return vars.get(key);
    }
    
    Hashtable getH(String key) {
	return (Hashtable)vars.get(key);
    }

    Object getFieldInContext(String field) {
	for (int i=0; i<context.length; i++) {
	    Object rv = getField(context[i], field);
	    if (rv != null) {
		return rv;
	    }
	}
	return null;
    }

    Object lookupHashFieldInContext(String field, String key) {
	for (int i=0; i<context.length; i++) {
	    Hashtable ht = (Hashtable)getField(context[i], field);
	    if (ht != null) {
		Object rv = ht.get(key);		
		if (rv != null) {
		    return rv;
		}
	    }
	}
	return null;
    }

    void put(String key, String value) {
	vars.put(key, value);
    }

    void put(String key, Vector vvalue) {
	vars.put(key, vvalue);
    }

    void add(String key, Vector vvalue) {
	getV(key).addAll(vvalue);
    }   

    String flavour() {
	return get("Flavour");
    }
    
    String build() {
	return get("Build");
    }

    Object getSpecificField(String field) {
	return getField(get("Id"), field);
    }

    void putSpecificField(String field, Object value) {
	putField(get("Id"), field, value);
    }
    
    void collectRelevantVectors(Vector rv, String field) {
	for (int i = 0; i < context.length; i++) {
	    Vector v = getFieldVector(context[i], field);
	    if (v != null) {
		for (Iterator j=v.iterator(); j.hasNext(); ) {
		    String val = (String)j.next();
		    rv.add(expandFormat(val));
		}
	    }
	}
    }

    void collectRelevantHashes(Hashtable rv, String field) {
	for (int i = 0; i < context.length; i++) {
	    Hashtable v = (Hashtable)getField(context[i], field);
	    if (v != null) {
		for (Enumeration e=v.keys(); e.hasMoreElements(); ) {
		    String key = (String)e.nextElement();
		    String val =  (String)v.get(key);
		    addTo(rv, key, val);
		}
	    }
	}
    }


    Vector getDefines() {
	Vector rv = new Vector();
	collectRelevantVectors(rv, "Define");	
	return rv;
    }

    Vector getIncludes() {
	Vector rv = new Vector();
	
	// for generated includes
	rv.add(get("OutputDir"));

       	collectRelevantVectors(rv, "AbsoluteInclude");
	
	Vector ri = new Vector();
	String sourceBase = getFieldString(null, "SourceBase");
	collectRelevantVectors(ri, "RelativeInclude");
	for (Iterator i = ri.iterator(); i.hasNext(); ) {
	    String f = (String)i.next();
	    rv.add(sourceBase + Util.sep + f);
	}

	return rv;
    }

    static Hashtable cfgData = new Hashtable();
    static Hashtable globalData = new Hashtable();

    static boolean appliesToTieredBuild(String cfg) {
        return (cfg != null &&
                (cfg.startsWith("compiler1") ||
                 cfg.startsWith("compiler2")));
    }

    // Filters out the IncludeDB statement, which is the only command-
    // line argument we explicitly specialize for the tiered build
    static boolean appliesToTieredBuild(String cfg, String key) {
        return (appliesToTieredBuild(cfg) &&
                (key != null &&
                 !key.equals("IncludeDB")));
    }

    static String getTieredBuildCfg(String cfg) {
        assert appliesToTieredBuild(cfg) : "illegal configuration " + cfg;
        return "tiered" + cfg.substring(9);
    }

    static Object getField(String cfg, String field) {
	if (cfg == null) {
	    return globalData.get(field);
	}

	Hashtable ht =  (Hashtable)cfgData.get(cfg);
	return ht == null ? null : ht.get(field);
    }

    static String getFieldString(String cfg, String field) {
	return (String)getField(cfg, field);
    }

    static Vector getFieldVector(String cfg, String field) {
	return (Vector)getField(cfg, field);
    }
    
    static void putField(String cfg, String field, Object value) {
        putFieldImpl(cfg, field, value);
        if (appliesToTieredBuild(cfg, field)) {
            putFieldImpl(getTieredBuildCfg(cfg), field, value);
        }
    }

    private static void putFieldImpl(String cfg, String field, Object value) {
	if (cfg == null) {
	    globalData.put(field, value);
	    return;
	}

	Hashtable ht = (Hashtable)cfgData.get(cfg);
	if (ht == null) {
	    ht = new Hashtable();
	    cfgData.put(cfg, ht);
	}

	ht.put(field, value);	
    }

    static Object getFieldHash(String cfg, String field, String name) {
	Hashtable ht = (Hashtable)getField(cfg, field);

	return ht == null ? null : ht.get(name);
    }    

    static void putFieldHash(String cfg, String field, String name, Object val) {
        putFieldHashImpl(cfg, field, name, val);
        if (appliesToTieredBuild(cfg)) {
            putFieldHashImpl(getTieredBuildCfg(cfg), field, name, val);
        }
    }

    private static void putFieldHashImpl(String cfg, String field, String name, Object val) {
	Hashtable ht = (Hashtable)getField(cfg, field);

	if (ht == null) {
	    ht = new Hashtable();
	    putFieldImpl(cfg, field, ht);
	}

	ht.put(name, val);
    }

    static void addFieldVector(String cfg, String field, String element) {
        addFieldVectorImpl(cfg, field, element);
        if (appliesToTieredBuild(cfg)) {
            addFieldVectorImpl(getTieredBuildCfg(cfg), field, element);
        }
    }

    private static void addFieldVectorImpl(String cfg, String field, String element) {
	Vector v = (Vector)getField(cfg, field);

	if (v == null) {
	    v = new Vector();
	    putFieldImpl(cfg, field, v);
	}

	v.add(element);
    }

    String expandFormat(String format) {
	if (format == null) {
	    return null;
	}

	if (format.indexOf('%') == -1) {
	    return format;
	}

	StringBuffer sb = new StringBuffer();
	int len = format.length();
	for (int i=0; i<len; i++) {
	    char ch = format.charAt(i);
	    if (ch == '%') {
		char ch1 = format.charAt(i+1);
		switch (ch1) {
		case '%':
		    sb.append(ch1);
		    break;
		case 'b':
		    sb.append(build());
		    break;
		case 'f':
		    sb.append(flavour());
		    break;
		default:
		    sb.append(ch);
		    sb.append(ch1);
		}
		i++;
	    } else {
		sb.append(ch);
	    }
	}
	
	return sb.toString();
    }
}

abstract class GenericDebugConfig extends BuildConfig {
    abstract String getOptFlag();

    protected void init(Vector includes, Vector defines) {
	defines.add("_DEBUG");
	defines.add("ASSERT");

	super.init(includes, defines);

	getV("CompilerFlags").addAll(getCI().getDebugCompilerFlags(getOptFlag()));
	getV("LinkerFlags").addAll(getCI().getDebugLinkerFlags());
   }
}

class C1DebugConfig extends GenericDebugConfig {
    String getOptFlag() {
	return getCI().getNoOptFlag();
    }

    C1DebugConfig() {
	initNames("compiler1", "debug", "fastdebug\\jre\\bin\\client\\jvm.dll");
	init(getIncludes(), getDefines());
    }
}

class C1FastDebugConfig extends GenericDebugConfig {
    String getOptFlag() {
	return getCI().getOptFlag();
    }

    C1FastDebugConfig() {
	initNames("compiler1", "fastdebug", "fastdebug\\jre\\bin\\client\\jvm.dll");
	init(getIncludes(), getDefines());
    }
}

class C2DebugConfig extends GenericDebugConfig {
    String getOptFlag() {
	return getCI().getNoOptFlag();
    }

    C2DebugConfig() {
	initNames("compiler2", "debug", "fastdebug\\jre\\bin\\server\\jvm.dll");
	init(getIncludes(), getDefines());
    }
}

class C2FastDebugConfig extends GenericDebugConfig {
    String getOptFlag() {
	return getCI().getOptFlag();
    }

    C2FastDebugConfig() {
	initNames("compiler2", "fastdebug", "fastdebug\\jre\\bin\\server\\jvm.dll");
	init(getIncludes(), getDefines());
    }
}

class TieredDebugConfig extends GenericDebugConfig {
    String getOptFlag() {
	return getCI().getNoOptFlag();
    }

    TieredDebugConfig() {
	initNames("tiered", "debug", "fastdebug\\jre\\bin\\server\\jvm.dll");
	init(getIncludes(), getDefines());
    }
}

class TieredFastDebugConfig extends GenericDebugConfig {
    String getOptFlag() {
	return getCI().getOptFlag();
    }

    TieredFastDebugConfig() {
	initNames("tiered", "fastdebug", "fastdebug\\jre\\bin\\server\\jvm.dll");
	init(getIncludes(), getDefines());
    }
}


abstract class ProductConfig extends BuildConfig {
    protected void init(Vector includes, Vector defines) {
	defines.add("NDEBUG");
	defines.add("PRODUCT");

	super.init(includes, defines);

	getV("CompilerFlags").addAll(getCI().getProductCompilerFlags());
	getV("LinkerFlags").addAll(getCI().getProductLinkerFlags());
    }
}

class C1ProductConfig extends ProductConfig {
    C1ProductConfig() {
	initNames("compiler1", "product", "jre\\bin\\client\\jvm.dll");
	init(getIncludes(), getDefines());
    }
}

class C2ProductConfig extends ProductConfig {
    C2ProductConfig() {
	initNames("compiler2", "product", "jre\\bin\\server\\jvm.dll");
        init(getIncludes(), getDefines());        
    }
}

class TieredProductConfig extends ProductConfig {
    TieredProductConfig() {
	initNames("tiered", "product", "jre\\bin\\server\\jvm.dll");
        init(getIncludes(), getDefines());        
    }
}


class CoreDebugConfig extends GenericDebugConfig {
    String getOptFlag() {
	return getCI().getNoOptFlag();
    }

    CoreDebugConfig() {
	initNames("core", "debug", "fastdebug\\jre\\bin\\core\\jvm.dll");
	init(getIncludes(), getDefines());
    }
}


class CoreFastDebugConfig extends GenericDebugConfig {
    String getOptFlag() {
	return getCI().getOptFlag();
    }

    CoreFastDebugConfig() {
	initNames("core", "fastdebug", "fastdebug\\jre\\bin\\core\\jvm.dll");
	init(getIncludes(), getDefines());
    }
}


class CoreProductConfig extends ProductConfig {
    CoreProductConfig() {
	initNames("core", "product", "jre\\bin\\core\\jvm.dll");
        init(getIncludes(), getDefines());        
    }
}

class KernelDebugConfig extends GenericDebugConfig {
    String getOptFlag() {
	return getCI().getNoOptFlag();
    }

    KernelDebugConfig() {
	initNames("kernel", "debug", "fastdebug\\jre\\bin\\kernel\\jvm.dll");
	init(getIncludes(), getDefines());
    }
}


class KernelFastDebugConfig extends GenericDebugConfig {
    String getOptFlag() {
	return getCI().getOptFlag();
    }

    KernelFastDebugConfig() {
	initNames("kernel", "fastdebug", "fastdebug\\jre\\bin\\kernel\\jvm.dll");
	init(getIncludes(), getDefines());
    }
}


class KernelProductConfig extends ProductConfig {
    KernelProductConfig() {
	initNames("kernel", "product", "jre\\bin\\kernel\\jvm.dll");
        init(getIncludes(), getDefines());        
    }
}
abstract class CompilerInterface {
    abstract Vector getBaseCompilerFlags(Vector defines, Vector includes, String outDir);
    abstract Vector getBaseLinkerFlags(String outDir, String outDll);
    abstract Vector getDebugCompilerFlags(String opt);
    abstract Vector getDebugLinkerFlags();
    abstract Vector getProductCompilerFlags();
    abstract Vector getProductLinkerFlags();
    abstract String getOptFlag();
    abstract String getNoOptFlag();
    abstract String makeCfgName(String flavourBuild);

    void addAttr(Vector receiver, String attr, String value) {
	receiver.add(attr); receiver.add(value); 
    }
}



