/*
 *
 *  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 flex2.tools.oem;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.EnumSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

import macromedia.asc.util.ContextStatics;

import flash.localization.LocalizationManager;
import flash.swf.Frame;
import flash.swf.Movie;
import flash.swf.MovieDecoder;
import flash.swf.MovieEncoder;
import flash.swf.TagDecoder;
import flash.swf.TagEncoder;
import flash.swf.tags.DefineTag;
import flash.util.Trace;
import flex2.compiler.CompilerSwcContext;
import flex2.compiler.io.LocalFile;
import flex2.compiler.io.VirtualFile;
import flex2.compiler.swc.SwcCache;
import flex2.compiler.util.MimeMappings;
import flex2.compiler.util.NameMappings;
import flex2.compiler.util.OrderedProperties;
import flex2.compiler.util.QName;
import flex2.compiler.util.SwcDependencyInfo;
import flex2.compiler.util.SwcDependencyUtil;
import flex2.compiler.util.SwcExternalScriptInfo;
import flex2.compiler.util.ThreadLocalToolkit;
import flex2.compiler.util.Benchmark.MemoryUsage;
import flex2.compiler.util.graph.Vertex;
import flex2.tools.oem.OEMException.CircularLibraryDependencyException;
import flex2.tools.oem.internal.OEMUtil;

/**
 * A utility class, which supports querying for Application, Library,
 * Component, and Script information, loading properties, optimizing,
 * and querying dependency info.
 * 
 * @author Clement Wong
 * @version 3.0
 */
public class Toolkit
{
	/**
	 * 
	 * @param application
	 * @return
	 */
	public static ApplicationInfo getApplicationInfo(File application)
	{
		InputStream in = null;
		ApplicationInfo info = null;
		
		try
		{
			in = new BufferedInputStream(new FileInputStream(application));
			
			Movie movie = new Movie();
			new TagDecoder(in).parse(new MovieDecoder(movie));
			
			info = new ApplicationInfoImpl(movie);
		}
		catch (IOException ex)
		{
            if (Trace.error)
            {
                ex.printStackTrace();
            }
		}
		finally
		{
			try { if (in != null) in.close(); } catch (IOException ex) {}
		}

		return info;
	}

	/**
	 * 
	 * @param library
	 * @return
	 */
	public static LibraryInfo getLibraryInfo(File library)
	{
		return getLibraryInfo(new File[] { library });
	}
	
	/**
	 * 
	 * @param libraries
	 * @return
	 */
	public static LibraryInfo getLibraryInfo(File[] libraries)
	{
		return getLibraryInfo(libraries, false);
	}

	/**
	 * 
	 * @param libraries
	 * @param includeBytecodes
	 * @return
	 */
	public static LibraryInfo getLibraryInfo(File[] libraries, boolean includeBytecodes)
	{
		LibraryInfo info = null;

        try
        {
        	OEMUtil.init(OEMUtil.getLogger(null, new ArrayList<Message>()), new MimeMappings(), null, null, null);
        	
            CompilerSwcContext swcContext = new CompilerSwcContext();
            SwcCache cache = new SwcCache();

            swcContext.load(toVirtualFiles(libraries),
	        				new NameMappings(),
	        				".properties",
	        				cache);
            
            info = new LibraryInfoImpl(swcContext, includeBytecodes);
            
            swcContext.close();
        }
        catch (Throwable t)
        {
            if (Trace.error)
            {
                t.printStackTrace();
            }
        }
        finally
        {
        	OEMUtil.clean();
        }

		return info;
	}
	
	/**
	 * Converts a list of File(s) into a list of VirtualFile(s).
	 * The VirtualFile implementation is flex2.compiler.io.LocalFile.
	 * 
	 * @param files
	 * @return
	 */
	private static VirtualFile[] toVirtualFiles(File[] files)
	{
		if (files == null) return null;
		
		List<VirtualFile> vFiles = new ArrayList<VirtualFile>(files.length);
		for (int i = 0; i < files.length; i++)
		{
		    if (files[i] != null)
		        vFiles.add(new LocalFile(files[i]));
		}
		
		return vFiles.toArray(new VirtualFile[vFiles.size()]);
	}

	/**
	 * Creates a <code>java.util.Properties</code> object from an <code>UTF-8</code> encoded input stream.
	 * 
	 * @param in <code>java.io.InputStream</code>
	 * @return an instance of <code>java.util.Properties</code>;
	 * 						  <code>null</code> if <code>IOException</code> occurs.
	 */
	public static Properties loadProperties(InputStream in)
	{
		return loadProperties(in, "UTF-8");
	}
	
	/**
	 * Creates a <code>java.util.Properties</code> object from an <code>UTF-8</code> encoded .properties file.
	 * 
	 * @param f an <code>UTF-8</code> encoded .properties file
	 * @return an instance of <code>java.util.Properties</code>;
	 * 						  <code>null</code> if the file doesn't exist or if <code>IOException</code> occurs.
	 */
	public static Properties loadProperties(File f)
	{
		return loadProperties(f, "UTF-8");
	}
	
	/**
	 * Creates a <code>java.util.Properties</code> object from an <code>UTF-8</code> encoded .properties file.
	 * 
	 * @param f an <code>UTF-8</code> encoded .properties file
	 * @param encoding character encoding
	 * @return an instance of <code>java.util.Properties</code>;
	 * 						  <code>null</code> if the file doesn't exist or if <code>IOException</code> occurs.
	 */
	public static Properties loadProperties(File f, String encoding)
	{
		if (f != null && f.isFile())
		{
			try
			{
				return loadProperties(new FileInputStream(f), encoding);
			}
			catch (IOException ex)
			{
				return null;
			}
		}
		else
		{
			return null;
		}
	}
	
	private static Properties loadProperties(InputStream in, String encoding)
	{
		if (in != null)
		{
			try
			{
				OrderedProperties p = new OrderedProperties();
				p.load(new BufferedReader(new InputStreamReader(in, encoding)));
				return p;
			}
			catch (IOException ex)
			{
				return null;
			}
		}
		else
		{
			return null;
		}
	}
	
	/**
	 * Optimizes a SWF. This operation performs the following:
	 * 
	 * <pre>
	 * 1. remove debug tags and opcodes
	 * 2. merge abc bytecodes
	 * 3. peephole optimization
	 * 4. remove unwanted metadata
	 * </pre>
	 * 
	 * @param in a SWF input stream
	 * @param out a SWF output stream
	 * @return the number of bytes written to the output stream; <code>0</code> if the optimization fails.
	 */
	public static long optimize(InputStream in, OutputStream out)
	{
		try
		{
			return flex2.tools.WebTierAPI.optimize(in, out);
		}
		catch (IOException ex)
		{
			return 0;
		}
	}
	
	/**
	 * Optimizes the library SWF. This operation performs the following:
	 * 
	 * <pre>
	 * 1. remove debug tags and opcodes
	 * 2. merge abc bytecodes
	 * 3. peephole optimization
	 * 4. remove unwanted metadata, but preserve the metadata specified in the Library object
	 * </pre>
	 * 
	 * This operation returns an optimized version of the library SWF. The SWF in the library
	 * remains unchanged.
	 * 
	 * @param in a SWF input stream
	 * @param out a SWF output stream
	 * @return the number of bytes written to the output stream; <code>0</code> if the optimization fails.
	 */
	public static long optimize(Library lib, OutputStream out)
	{
		if (lib == null || lib.data == null || lib.data.movie == null) return 0;
		
		try
		{
			TagEncoder handler = new TagEncoder();
			MovieEncoder encoder = new MovieEncoder(handler);
			encoder.export(lib.data.movie);
            
            //TODO PERFORMANCE: A lot of unnecessary recopying here
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			handler.writeTo(baos);

			return flex2.tools.WebTierAPI.optimize(new ByteArrayInputStream(baos.toByteArray()),
											out,
											lib.data.configuration);
		}
		catch (IOException ex)
		{
			return 0;
		}
	}
	
	/**
	 * 
	 *
	 */
	public static void printMemoryUsage()
	{
	    MemoryUsage mem = new flex2.compiler.util.Benchmark().getMemoryUsageInBytes();
	    long mbHeapUsed = (mem.heap / 1048576);
		long mbNonHeapUsed = (mem.nonHeap / 1048576);
		System.out.println("Heap: " + mbHeapUsed + " Non-Heap: " + mbNonHeapUsed);
	}

	// added for FB code model
    /**
     * Returns a list filled with namespaces that should be automatically
     * opened, based on the current target player, e.g. flash10, AS3.
     * 
     * @param targetPlayerMajorVersion E.g. 9, 10, ...
     * @return List<String> containing the namespaces
     */
    public static List<String> getRequiredUseNamespaces(int targetPlayerMajorVersion)
    {
        return ContextStatics.getRequiredUseNamespaces(targetPlayerMajorVersion);
    }
    

    /**
     *  The types of dependency the compiler assigns to a symbol. The possible
     *  values are as follows:
     *  
     *  <ul>
     *  <li>INHERITANCE 
     *  <li>NAMESPACE
     *  <li>SIGNATURE
     *  <li>EXPRESSION
     *  </ul>
     */
    public enum DependencyType {
        /**
         *  The class is used as a base class or is implemented by another 
         *  class.
         */
        INHERITANCE ("i"),
        
        /**
         *  The symbol is a namespace.
         */
        NAMESPACE   ("n"),
        
        /**
         *  The symbol is used in a function signature. 
         */
        SIGNATURE   ("s"),
        
        /**
         *  The symbol is used in a class or function.
         */
        EXPRESSION  ("e");
        
        
        private final String dependency;
        
        DependencyType(String dependency)
        {
            this.dependency = dependency;
        }

        /**
         *  @return A string that represents the dependency type.
         */
        @Override
        public String toString() 
        {
            return dependency;
        }
        
    }
    
    /**
     * Get the dependency order of a given set of libraries.
     * 
     * @param libraries The set of libraries to find the dependency information for. Each
     * File in the list must be a library file or a directory of libraries files.
     * 
     * @return An ordered list of library dependencies. Each String in the 
     * list is the location of a library in the file system. The first library in the list has no
     * dependencies. Each library in the list has at least the same dependencies as its 
     * predecessor and may be dependent on its predecessor as well. 
     */
    public static List<String> getDependencyOrder(File[] libraries) throws CircularLibraryDependencyException
    {
        return getDependencyOrder(libraries, null);
    }

    /**
     * Get the dependency order of a given set of libraries.
     * 
     * @param libraries The set of libraries to find the dependency information for. Each
     * File in the list must be a library file or a directory of libraries files.
     * @param dependencySet The types of dependencies to consider when 
     * determining the dependency order. If this parameter is null or an empty set, then all
     * dependencies will be considered. 
     * 
     * @return An ordered list of library dependencies. Each String in the 
     * list is the location of a library in the file system. The first library in the list has no
     * dependencies. Each library in the list has at least the same dependencies as its 
     * predecessor and may be dependent on its predecessor as well. 
     */
    public static List<String> getDependencyOrder(File[] libraries, 
            EnumSet<DependencyType> dependencySet) throws CircularLibraryDependencyException
    {
        if (libraries == null)
            return Collections.emptyList();
        
        // Convert dependencies from an array of DependencyType to an
        // array of String.
        String[] stringDependencyTypes = dependencyEnumSetToStringArray(dependencySet);
        SwcDependencyInfo info = SwcDependencyUtil.getSwcDependencyInfo(toVirtualFiles(libraries), 
                                                                        stringDependencyTypes,
                                                                        true);
        Set<Vertex<String, SwcExternalScriptInfo>> cycles = info.detectCycles();
        if (cycles.size() > 0) 
        {
            LocalizationManager i10n = ThreadLocalToolkit.getLocalizationManager();
            if (i10n == null)
            {
                OEMUtil.setupLocalizationManager();
                i10n = ThreadLocalToolkit.getLocalizationManager();
            }
            
            String message = i10n.getLocalizedTextString(new CircularLibraryDependencyException(null, null));
            throw new CircularLibraryDependencyException(message, 
                            SwcDependencyUtil.SetOfVertexToString(cycles));
        }
        
        return info.getSwcDependencyOrder();
    }
    
    /**
     * Get the set of library dependencies of a given library.
     * 
     * @param libraries The set of libraries need to resolve all the dependencies of the targetLibrary. Each
     * File in the list must be a library file or a directory of libraries files.
     * @param targetLibrary The libraries to find dependencies for.
     * @param minimizeDependencySet If false, all of the libraries dependencies are returned. If true, the external script
     * classes are reviewed. If the set of script classes resolved in a libraryA is a subset of the script
     * classes resolved in libraryB, then libraryA will be removed as a dependency of targetLibrary.
     * @return A set of Strings; where each String is the location of a library in the file system. 
     */
    public static Set<String> getLibraryDependencies(File[] libraries, 
            File targetLibrary, 
            boolean minimizeDependencySet) throws CircularLibraryDependencyException 
    {
        return getLibraryDependencies(libraries, targetLibrary, minimizeDependencySet, null);
    }
    
    /**
     * Get the set of library dependencies of a given library.
     * 
     * @param libraries The set of libraries need to resolve all the dependencies of the targetLibrary. Each
     * File in the list must be a library file or a directory of libraries files.
     * @param targetLibrary The libraries to find dependencies for.
     * @param minimizeDependencySet If false, all of the libraries dependencies are returned. If true, the external script
     * classes are reviewed. If the set of script classes resolved in a libraryA is a subset of the script
     * classes resolved in libraryB, then libraryA will be removed as a dependency of targetLibrary.
     * @param dependencyTypes The types of dependencies to consider when 
     * determining the library's dependencies. If this parameter is null or an empty set, then all
     * dependencies will be considered. 
     * @return A set of Strings; where each String is the location of a library in the file system. 
     */
    public static Set<String> getLibraryDependencies(File[] libraries, 
            File targetLibrary, 
            boolean minimizeDependencySet,
            EnumSet<DependencyType> dependencySet) throws CircularLibraryDependencyException
    {
        if (libraries == null || targetLibrary == null)
            return Collections.emptySet();
        
        // Convert dependencies from an array of DependencyType to an
        // array of String.
        String[] stringDependencyTypes = dependencyEnumSetToStringArray(dependencySet);
        SwcDependencyInfo info = SwcDependencyUtil.getSwcDependencyInfo(toVirtualFiles(libraries), 
                                                                        stringDependencyTypes,
                                                                        minimizeDependencySet);
        Set<Vertex<String, SwcExternalScriptInfo>> cycles = info.detectCycles();
        if (cycles.size() > 0) 
        {
            LocalizationManager i10n = ThreadLocalToolkit.getLocalizationManager();
            if (i10n == null)
            {
                OEMUtil.setupLocalizationManager();
                i10n = ThreadLocalToolkit.getLocalizationManager();
            }
            
            String message = i10n.getLocalizedTextString(new CircularLibraryDependencyException(null, null));
            throw new CircularLibraryDependencyException(message, 
                            SwcDependencyUtil.SetOfVertexToString(cycles));
        }

        VirtualFile virtualLibrary = new LocalFile(targetLibrary);
        return info.getDependencies(virtualLibrary.getName());
    }

    /**
     * Convert an EnumSet of DependencyType to an Array of Strings. 
     * 
     * @param dependencySet EnumSet of dependencies to convert.
     * @return Array of Strings. Each string in the Array represents a type of
     * dependency. Returns null if dependencySet is null or an empty set.
     */
    private static String[] dependencyEnumSetToStringArray(EnumSet<DependencyType> dependencySet)
    {
        // Convert dependencies from an array of DependencyType to an
        // array of String.
        String[] stringDependencyTypes = null;
        if (dependencySet != null && dependencySet.size() > 0)
        {
            int n = dependencySet.size();
            int i = 0;
            stringDependencyTypes = new String[n];
            
            for (DependencyType dependency : dependencySet)
            {
                stringDependencyTypes[i++] = dependency.toString();
            }
        }
        
        return stringDependencyTypes;
    }

}


/**
 * 
 *
 */
class ApplicationInfoImpl implements ApplicationInfo
{
    ApplicationInfoImpl(Movie movie)
    {
        version = movie.version;
        
        List frames = movie.frames;
        Set<String> symbols = new TreeSet<String>();
        
        for (int i = 0, size = frames == null ? 0 : frames.size(); i < size; i++)
        {
            Frame f = (Frame) frames.get(i);
            for (Iterator j = f.exportIterator(); j.hasNext(); )
            {
                DefineTag t = (DefineTag) j.next();
                if (t.name != null)
                {
                    symbols.add(t.name);
                }
            }
        }
        
        symbols.toArray(symbolNames = new String[symbols.size()]);
    }
    
    private String[] symbolNames;
    private int version;

    public String[] getSymbolNames()
    {
        return symbolNames;
    }
    
    public int getSWFVersion()
    {
        return version;
    }
}


/**
 * 
 *
 */
class LibraryInfoImpl implements LibraryInfo
{
    LibraryInfoImpl(CompilerSwcContext swcContext, boolean includeBytecodes)
    {
        List<QName> names = new ArrayList<QName>();
        
        for (Iterator i = swcContext.getDefinitionIterator(); i.hasNext(); )
        {
            names.add((QName) i.next());
        }
        
        definitionNames = new String[names.size()];
        
        for (int i = 0; i < definitionNames.length; i++)
        {
            definitionNames[i] = names.get(i).toString();
        }
        
        scripts = new TreeMap<String, Script>();
        
        for (int i = 0; i < definitionNames.length; i++)
        {
            QName def = names.get(i);
            Script s = swcContext.getScript(def, includeBytecodes);
            scripts.put(def.toString(), s);
        }
        
        components = new TreeMap<String, Component>();
        
        for (Iterator i = swcContext.getComponentIterator(); i.hasNext(); )
        {
            Component c = (Component) i.next();
            components.put(c.getClassName(), c);
        }
        
        mappings = swcContext.getNameMappings();
        
        fileNames = new TreeSet<String>(swcContext.getFiles().keySet());
    }
    
    private String[] definitionNames;
    private Map<String, Script> scripts;
    private Map<String, Component> components;
    private NameMappings mappings;
    private Set<String> fileNames;

    public Component getComponent(String namespaceURI, String name)
    {
        return getComponent(mappings.lookupClassName(namespaceURI, name));
    }

    public Component getComponent(String definition)
    {
        return (definition != null) ? components.get(definition) : null;
    }

    public Iterator<Component> getComponents()
    {
        return components.values().iterator();
    }

    public String[] getDefinitionNames()
    {
        return definitionNames;
    }

    public Script getScript(String definition)
    {
        return scripts.get(definition);
    }

    public Iterator<Script> getScripts()
    {
        return scripts.values().iterator();
    }
    
    public Iterator<String> getFiles()
    {
        return fileNames.iterator();
    }
}