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

import flash.swf.Action;
import flash.swf.Header;
import flash.swf.TagDecoder;
import flash.swf.TagHandler;
import flash.swf.Dictionary;
import flash.swf.ActionConstants;
import flash.swf.MovieMetaData;
import flash.swf.tags.DefineButton;
import flash.swf.tags.DoAction;
import flash.swf.tags.DoInitAction;
import flash.swf.tags.PlaceObject;
import flash.swf.tags.DefineSprite;
import flash.swf.types.ActionList;
import flash.swf.types.ButtonCondAction;
import flash.swf.types.ClipActionRecord;
import flash.swf.actions.DefineFunction;
import flash.swf.actions.ConstantPool;
import flash.util.Trace;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;

/**
 * This class implements the TagHandler interface
 * and provides a mechanism for containing the
 * actions associated with a SWF.
 */
public class SwfActionContainer extends TagHandler
{
	boolean		errorProcessing = true;
	ActionList	m_master;

	// temporaries used while decoding
	Dictionary  m_dictionary; 
	Header		m_header;

    public SwfActionContainer(byte[] swf, byte[] swd)	{ this(new ByteArrayInputStream(swf), new ByteArrayInputStream(swd));	}
    public SwfActionContainer(InputStream swfIn)		{ this(swfIn, null); }

    public SwfActionContainer(InputStream swfIn, InputStream swdIn)
	{
		TagDecoder p = new TagDecoder(swfIn, swdIn);
		try
		{
			process(p);
			errorProcessing = false;
		}
		catch(IOException io)
		{
			if (Trace.error)
				io.printStackTrace();
		}
	}

	// getters 
	public ActionList	getMasterList() { return m_master; }
	public Header		getHeader()		{ return m_header; }
	public Dictionary	getDictionary() { return m_dictionary; }

	// Did we hit an error in processing the swf? 
	public boolean hasErrors() { return errorProcessing; }

	/**
	 * Ask a TagDecoder to do its magic, calling us 
	 * upon each encounter of a new tag.
	 */
	void process(TagDecoder d) throws IOException
	{
		m_master = new ActionList(true);
        d.setKeepOffsets(true);
		d.parse(this);
	}

	/**
	 * Return a path to an ActionList that contains the given offset
	 * if an exact match is not found then return the largest
	 * that does not exceed offset.
	 */
	public ActionLocation locationLessOrEqualTo(int offset)
	{
		ActionLocation l = new ActionLocation();
		locationLessOrEqualTo(l, m_master, offset);
		return l;
	}

    public static ActionLocation locationLessOrEqualTo(ActionLocation location, ActionList list, int offset)
	{
		int at = findLessOrEqualTo(list, offset);
		if (at > -1)
		{
			// we hit so mark it and extract a constant pool if any
			location.at = at;
			location.actions = list;

			Action a = list.getAction(0);
			if (a.code == ActionConstants.sactionConstantPool)
				location.pool = (ConstantPool)a;

			// then see if we need to traverse
			a = list.getAction(at);
			if ( (a.code == ActionConstants.sactionDefineFunction) ||
				 (a.code == ActionConstants.sactionDefineFunction2) )
			{
				location.function = (DefineFunction)a;
				locationLessOrEqualTo(location, ((DefineFunction)a).actionList, offset);
			}
			else if (a instanceof DummyAction)
			{
				// our dummy container, then we drop in
				locationLessOrEqualTo(location, ((DummyAction)a).getActionList(), offset);
			}
		}
		return location;
	}

	// find the index of the largest offset in the list that does not
	// exceed the offset value provided. 
	public static int findLessOrEqualTo(ActionList list, int offset)
	{
		int i = find(list, offset);
		if (i < 0)
		{
			// means we didn't locate it, so get the next closest one
			// which is 1 below the insertion point
			i = (-i - 1) - 1;
		}
		return i;
	}

	// perform a binary search to locate the offset within the sorted
	// list of offsets within the action list.
	// if no match then (-i - 1) provides the index of where an insertion
	// would occur for this offset in the list.
	public static int find(ActionList list, int offset)
	{
        int lo = 0;
        int hi = list.size()-1;

        while (lo <= hi)
        {
            int i = (lo + hi)/2;
            int m = list.getOffset(i);
            if (offset > m)
                lo = i + 1;
            else if (offset < m)
                hi = i - 1;
            else
                return i; // offset found
        }
        return -(lo + 1);  // offset not found, low is the insertion point
	}

	/**
	 * Dummy Action container for housing all of  our
	 * topmost level actionlists in a convenient form
	 */
	public class DummyAction extends Action
	{
		public DummyAction(ActionList list)
		{
			super(ActionConstants.sactionNone);
			m_actionList = list;
		}

		// getters/setters
		public ActionList		getActionList()					{ return m_actionList; }
		public String			getClassName()					{ return m_className; }
		public void				setClassName(String name)		{ m_className = name; }

		private ActionList		m_actionList;
		private String			m_className;
	}

	/**
	 * Store away the ActionLists for later retrieval
	 */
    DummyAction recordActions(ActionList list)
    {
		DummyAction da = null;
		if (list != null && list.size() > 0)
		{
			// use the first offset as our reference point
			int offset = list.getOffset(0);

			// now create a pseudo action for this action list in our master
			da = new DummyAction(list);
			m_master.setActionOffset(offset, da);
		}
		return da;
	}

	/**
	 * -----------------------------------------------
	 * The following APIs override TagHandler.
	 * -----------------------------------------------
	 */
	public void doInitAction(DoInitAction tag)
	{
		DummyAction a = recordActions(tag.actionList);

		// now fill in the class name if we can
		if (m_header.version > 6 && tag.sprite != null)
		{
			String __Packages = MovieMetaData.idRef(tag.sprite, m_dictionary);
			String className = (__Packages != null && __Packages.startsWith("__Packages")) ? __Packages.substring(11) : null; //$NON-NLS-1$
			a.setClassName(className);
		}
	}

	public void doAction(DoAction tag)
	{
		recordActions(tag.actionList);
	}


	public void defineSprite(DefineSprite tag)
	{
		// @todo need to support actions in sprites!!! 
	}

	public void placeObject2(PlaceObject tag)
	{
		if (tag.hasClipAction())
		{
            Iterator it = tag.clipActions.clipActionRecords.iterator();
            while (it.hasNext())
            {
    		    ClipActionRecord record = (ClipActionRecord) it.next();
   			    recordActions(record.actionList);
            }
		}
	}

	public void defineButton(DefineButton tag)
	{
		recordActions(tag.condActions[0].actionList);
	}

	public void defineButton2(DefineButton tag)
	{
        if (tag.condActions.length > 0)
        {
            for (int i=0; i < tag.condActions.length; i++)
            {
                ButtonCondAction cond = tag.condActions[i];
                recordActions(cond.actionList);
            }
		}
	}

	public void setDecoderDictionary(Dictionary dict)
	{
		m_dictionary = dict;
	}

	public void header(Header h)
	{
		m_header = h;
	}

	/**
	 * -----------------------------------------------
	 * END: override TagHandler.
	 * -----------------------------------------------
	 */
}