/*
 *
 * 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.
 *
 */
package utils;

import java.io.File;
import java.io.IOException;
import java.util.StringTokenizer;
import java.util.List;
import java.util.Vector;
import java.util.Iterator;
import java.util.ArrayList;

import utils.FileUtils;
import org.xml.sax.SAXException;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;

public class CompcUtils {
    private String compc;
    private String dir;
    private long lastRunTime;
    private RuntimeExecHelper reh;
    private String execArgs[];
    boolean printOut = false;
    private String configfileIndicator1 = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
    private String configfileIndicator2 = "<flex-config xmlns=\"http://www.adobe.com/2006/flex-config\">";
    private Vector swcs;
    private boolean bConfigFileArgs = false;

    private void debug(String msg) {
        if (System.getProperty("debug") != null && System.getProperty("debug").equals("true")) {
            System.out.println(msg);
        }
    }

    //read args from system property = compc.args
    public void compile() throws Exception {
        String strArgs = System.getProperty("compc.args");
        if (strArgs != null && !strArgs.equals("")) {
            debug("got compc args from System property - compc.args = " + strArgs);
            compile(strArgs);
        } else {
            throw new Exception("compc args from System property - compc.args are empty!");
        }
    }


    public void compile(String args) throws Exception {
    	if( !args.equals("")) {
    		ArgumentParser parser = new ArgumentParser(args);
    		ArrayList result = parser.parseArguments();
    		String a[] = new String[result.size()];
        	for(int i=0; i < result.size(); i++) a[i] = (String)result.get(i);
        	compc(a);
    	} else {
    		throw new Exception("compc args are empty!");
    	}
    }

    //read args from file
    public void compile(File argFile) throws Exception {
        if (argFile.exists()) {
            debug("reading compc args from file: " + argFile.getAbsolutePath());
            // determine if arg file is a config file or lists of commandline args
            List args = FileUtils.readLines(argFile.getAbsolutePath());
            if (args.size() == 0) {
                throw new Exception("compc args file " + argFile.getAbsolutePath() + " is empty!");
            }

            String frameworks = FileUtils.normalizeDir(System.getProperty("frameworks", "."));
            String basedir=FileUtils.normalizeDir(System.getProperty("basedir"));
            String mxunitdir=basedir+"/sdk/testsuites/mxunit";

            try {
                // if 1st 2 lines of argFile indicate that it is an xml config file, make compc args use the -config=argFile
                if (((String) args.get(0)).trim().equalsIgnoreCase(configfileIndicator1) && ((String) args.get(1)).trim().equalsIgnoreCase((configfileIndicator2))) {
                    args = new Vector();
                    args.add("--load-config " + argFile.getAbsolutePath());
                    bConfigFileArgs = true;
                }
            } catch (Exception e) {
                //must only have 1 line so do nothing
            }
            Iterator it = args.iterator();
            while (it.hasNext()) {
                compile((String) it.next() + " +frameworks-dir " + frameworks + " +mxunit-dir " + mxunitdir);
            }
        } else {
            throw new Exception("compc args file " + argFile.getAbsolutePath() + " does not exisit!");
        }

    }

    //given an mxml Testfile,
    //  if file with same name, but extension=compc exists, return that file
    //  if file with same name as parent folder and extension=compc exists, return that file
    public File getCompcArgFile(String mxmlTest) throws Exception {

        return getArgFile(mxmlTest, "compc");
    }

    public File getRSLArgFile(String mxmlTest) throws Exception {
        return getArgFile(mxmlTest, "rsl");
    }

    private File getArgFile(String mxmlTest, String extension) throws Exception {
        //see if there is a .extension file in the folder with the same name as the folder
        String folderpath = new File(mxmlTest).getParent();
        String foldername = new File(folderpath).getName();
        String folderBasedArgs = folderpath + File.separator + foldername + "." + extension;
        //if file with same name as mxml, but extension=extension exists use it for args
        String fileBasedArgs = mxmlTest.substring(0, mxmlTest.length() - 4) + extension;
        File argFile = null;

        if (new File(fileBasedArgs).exists()) {
            debug("fileBasedArgs=" + fileBasedArgs + " exists.  Reading args.");
            argFile = new File(fileBasedArgs);
        } else if (new File(folderBasedArgs).exists()) {
            debug("folderBasedArgs=" + folderBasedArgs + " exists.  Reading args.");
            argFile = new File(folderBasedArgs);
        } else {
            throw new Exception(extension + " argFile does not exist");
        }
        return argFile;
    }


    public void compile(String[] args) throws Exception {
        compc(args);
    }

    private void compc(String[] args) throws Exception {
        //compcdir and compcexe must be specified as system properties!
        String compcdir = System.getProperty("compcdir");
        String compcexe = System.getProperty("compcexe");
        compc = FileUtils.normalizeDirOS(compcdir + File.separator + compcexe);
        debug("compcdir=" + compcdir);
        debug("compcexe=" + compcexe);
        debug("compc=" + compc);

        if (compc == null || new File(compc).isFile() == false) {
            throw new Exception("compc compiler not set correctly, compc=" + compc);
        }

        // frameworks must be specified as system property.
        // This will be used later on as the working directory for compilation
        String frameworks = FileUtils.normalizeDir(System.getProperty("frameworks"));
        if (frameworks == null || new File(frameworks).isDirectory() == false) {
            throw new Exception("frameworks not set correctly, frameworks=" + frameworks);
        }
        debug("frameworks=" + frameworks);
        if (dir == null)
        	dir = frameworks;

        execArgs = new String[args.length + 1];
        execArgs[0] = compc;
        for (int i = 0; i < args.length; i++) {
            execArgs[i + 1] = args[i];
        }

        debug("cd " + dir);
        System.out.println(StringUtils.arrayToString(execArgs));

        int timeout = 300;
        try {
            timeout = Integer.parseInt(System.getProperty("compc.timeout"));
        } catch (Exception e) {
        }

        swcs = new Vector();

        //delete output swc if it already exists and add swc to list of swcs generated
        // uh...this doesn't really work if swc is relative..
        String swcname=getSwc(execArgs);
        /*
        debug(">>>>> deleting old swc if it exists: " + swcname);
        if (!swcname.endsWith(".swc")){
            debug(">>>>> swc is dir so emptying dir");
            File f = new File(swcname);
            if (f.isDirectory()){
                File[] fa=f.listFiles();
                for (int x=0;x<fa.length;x++){
                    debug(">>>>> deleting: " + fa[x].getAbsolutePath());
                    fa[x].delete();
                }
             }
        }
        */
        utils.FileUtils.deleteFile(swcname);

        reh = new RuntimeExecHelper(execArgs, dir);
        reh.setPrintOutput(printOut);
        reh.setTimeout(timeout);
        long startTime = System.currentTimeMillis();
        reh.run();
        lastRunTime = System.currentTimeMillis() - startTime;

    }

    private String getSwc(String[] execArgs) {
        // add swc that results from compile to private array of swcs
        //parse execArgs to find -output value
        //todo:this will need to be refactored when compc really works
        String swc = "";
        if (!bConfigFileArgs) {
            for (int i = 0; i < execArgs.length; i++) {
                if (execArgs[i].equals("--o") || execArgs[i].equals("-o") || execArgs[i].equals("--output") || execArgs[i].equals("-output")) {
                    swc = execArgs[i + 1];
                    swcs.add(swc);
                    break;
                }
            }
        } else {
            String configFile = "";
            for (int i = 0; i < execArgs.length; i++) {
                if (execArgs[i].equals("--load-config") || execArgs[i].equals("-load-config")) {
                    configFile = execArgs[i + 1];
                    break;
                }
            }

            try {
                debug("configFile=" + configFile);
                Document doc = DocumentUtils.parseDocument(configFile);
                doc.getDocumentElement().normalize();
                NodeList nd = doc.getElementsByTagName("output");
                swc = nd.item(0).getFirstChild().getNodeValue();
                debug(">>>>>>>>>>>swc=" + swc);
                swcs.add(swc);
            } catch (SAXException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        return swc;
    }

    public List getSwcs() {
        return swcs;
    }

    public long getLastRunTime() {
        return lastRunTime;
    }

    public RuntimeExecHelper getRuntimeExecHelper() {
        return reh;
    }

    public String[] getExecArgs() {
        return execArgs;
    }

    public String getDir() {
        return dir;
    }
    
    public void setDir(String newDir) {
        dir = newDir;
    }

    public void setPrintOut(boolean b) {
        printOut = b;
    }

    //use the internal swc returned via compc and validate it
    public void validateSwcs() {
        validateSwcs(getSwcs());

    }

    private boolean validateSwc(String swc) {
        //todo: this will need to be refactored to improve validation criteria
        if (new File(swc).exists() && new File(swc).length() > 0) {
            return true;
        } else {
            return false;
        }
    }

    private void validateSwcs(List swcs) {
        Iterator it = swcs.iterator();
        while (it.hasNext()) {
            String swc = (String) it.next();
            if (validateSwc(swc)) {
                junit.framework.Assert.fail("compc failed to compile swc using these args: \n" + swc);
            }
        }
    }


//    todo: I think this is the correct thing do to when compc will really be working?? - kq
    public ArrayList addSwcToClassPath(ArrayList mxmlArgs) {
        //tack the swc onto the end of the --library-path

        //debug(">>>>>> original mxmlArgs >>> " + StringUtils.arrayToString(mxmlArgs));

        validateSwcs();

        boolean bFound = false;
        String sep = " ";
        int insertPos = 0;
        ArrayList l = new ArrayList();
        for (int i = 0; i < mxmlArgs.size(); i++) {
        	String anArg = (String)mxmlArgs.get(i);
            if (anArg.trim().toLowerCase().indexOf("--library-path") > 0 || anArg.trim().toLowerCase().indexOf("-library-path") > 0) {
                bFound = true;
                insertPos = i;
                debug("found library-path");
            }
            if (bFound) {
                if ((anArg.startsWith("-") || anArg.startsWith("+")) && insertPos != i) {
                    insertPos = i;
                    bFound = false;
                }
                if (anArg.indexOf("=") > 0) {
                    sep = ",";
                    debug(">>> sepaprator is ',' ");
                }
            }
            l.add(anArg);

        }
        if (insertPos != 0) {
            debug("found library-path at pos = " + insertPos);
            Iterator it = getSwcs().iterator();
            if (sep.equals(",")) {
                String ins = (String) l.get(insertPos - 1);
                while (it.hasNext()) {
                    ins += sep + it.next();
                }
                l.set(insertPos - 1, ins);
            } else {
                while (it.hasNext()) {
                    l.add(insertPos, (String) it.next());
                    insertPos++;
                }

                //l.add(insertPos, "--");
            }
        } else {
            //hack to make skinning.as last
            boolean skinning = false;
            if (((String) l.get(l.size() - 1)).trim().equalsIgnoreCase("skinning.as")) {
                skinning = true;
                l.remove(l.size() - 1);
            }

            //l.add("--library-path=");
            String swcNames = "";
            Iterator it = getSwcs().iterator();
            while (it.hasNext()) {
                //l.add((String) it.next());
                swcNames += (String) it.next();
            }
			l.add("--library-path+=" + swcNames);
			
            if (skinning) {
                if (!((String) l.get(l.size())).startsWith("-")) {
                    l.add("--");
                }
                l.add("skinning.as");
            }
        }

        return l;

    }


}