/*
 * JStackAlloc (c) 2008 Martin Dvorak <jezek2@advel.cz>
 *
 * This software is provided 'as-is', without any express or implied warranty.
 * In no event will the authors be held liable for any damages arising from
 * the use of this software.
 * 
 * Permission is granted to anyone to use this software for any purpose, 
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 * 
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */

package cz.advel.stack;

import cz.advel.stack.instrument.InstrumentationTask;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import java.io.*;

/**
 * Support for stack allocation of "value" objects. The only requirements for "value"
 * objects is that they must have public zero argument constructor and <code>set</code>
 * method with one argument of the same type (or superclass) which copies data from
 * given instance.<p>
 * 
 * <b>Example usage:</b>
 * <pre>
 * public static Vector3f average(Vector3f v1, Vector3f v2, Vector3f out) {
 *     out.add(v1, v2);
 *     out.scale(0.5f);
 *     return out;
 * }
 * 
 * public static void test() {
 *     Vector3f v1 = Stack.alloc(Vector3f.class);
 *     v1.set(0f, 1f, 2f);
 * 
 *     Vector3f v2 = Stack.alloc(v1);
 *     v2.x = 10f;
 * 
 *     Vector3f avg = average(v1, v2, Stack.alloc(Vector3f.class));
 * }
 * </pre>
 * which is transformed into something like the following code. The actual
 * generated code has mangled names for unique type identification and can have
 * other minor differences.
 * <pre>
 * public static void test() {
 *     $Stack stack = $Stack.get();
 *     stack.pushVector3f();
 *     try {
 *         Vector3f v1 = stack.getVector3f();
 *         v1.set(0f, 1f, 2f);
 * 
 *         Vector3f v2 = stack.getVector3f(v1);
 *         v2.x = 10f;
 * 
 *         Vector3f avg = average(v1, v2, stack.getVector3f());
 *     }
 *     finally {
 *         stack.popVector3f();
 *     }
 * }
 * </pre>
 * 
 * <b>Rules:</b>
 * <ul>
 * <li>classes needs to be instrumented by provided InstrumentationTask for ANT, otherwise
 *     error is throwed in runtime</li>
 * <li>stack is pushed only once per method, do not use stack allocation in loops</li>
 * <li>returning of stack allocated objects is not supported, use output parameter instead (like in the
 *     example)</li>
 * <li>working with stack is thread-safe, the data are separate for each thread</li>
 * <li>combining different libraries works fine, each must have their stack stored
 *     in different package, so you'll just end up with multiple stacks in final application,
 *     which is fine, because the values are used between them without problem
 * <li>when creating and destroying threads you must be aware that the implementation
 *     uses ThreadLocal to persist stack instances between method calls, it's advisable
 *     to call <code>cleanCurrentThread</code> method on thread just before destroying
 * </li>
 * </ul>
 * 
 * @author jezek2
 */
public class Stack {
	
	private static List<WeakReference<ThreadLocal>> threadLocalList = new ArrayList<WeakReference<ThreadLocal>>();
	
	private Stack() {
	}

	/**
	 * Returns stack allocated object.<p>
	 * 
	 * Requires instrumentation of your classes in order to work.
	 * 
	 * @param cls class type, must be compile-time constant
	 * @return stack allocated instance of given class
	 */
	public static <T> T alloc(Class<T> cls)
        {
            try
            {
                return (T) cls.newInstance();
            }
            catch (Exception e)
            {
		throw new Error("not instrumented");
//                return null;
            }
	}

	/**
	 * Returns stack allocated object with copied value from given parameter.<p>
	 * 
	 * Requires instrumentation of your classes in order to work.
	 * 
	 * @param obj object to copy on stack, the type must be statically known
	 * @return stack allocated instance with copied data
	 */
	public static <T> Object alloc(T obj)
        {
            if (obj == null)
                return null;
            
            if (obj instanceof javax.vecmath.Vector3f)
            {
                return new javax.vecmath.Vector3f((javax.vecmath.Vector3f) obj);
            }
            
            if (obj instanceof javax.vecmath.Matrix3f)
            {
                return new javax.vecmath.Matrix3f((javax.vecmath.Matrix3f) obj);
            }
            if (obj instanceof com.bulletphysics.linearmath.Transform)
            {
                com.bulletphysics.linearmath.Transform t = (com.bulletphysics.linearmath.Transform) obj;
                
                com.bulletphysics.linearmath.Transform tr = new com.bulletphysics.linearmath.Transform();
                
                tr.basis.set(t.basis);
                tr.origin.set(t.origin);
                
                return tr;
            }
            
            return (T) serialclone(obj);
		//throw new Error("not instrumented");
	}
	
    static public Object serialclone(Object o)
    {
        try
        {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(baos);

            out.writeObject(o);

            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream in = new ObjectInputStream(bais);
            Object obj = in.readObject();
            in.close();
            out.close();
            return obj;
        } catch (Exception e)
        {
            System.err.println(e);
            return null;
        }
    }

	/**
	 * Used internally.
	 */
	public static synchronized void internalRegisterThreadLocal(ThreadLocal local) {
		threadLocalList.add(new WeakReference<ThreadLocal>(local));
	}
	
	/**
	 * Removes all cached stack instances for current thread.
	 */
	public static synchronized void cleanCurrentThread() {
		for (Iterator<WeakReference<ThreadLocal>> it = threadLocalList.iterator(); it.hasNext(); ) {
			WeakReference<ThreadLocal> ref = it.next();
			ThreadLocal local = ref.get();
			if (local != null) {
				local.remove();
			}
			else {
				it.remove();
			}
		}
	}

	/**
	 * Removes all cached stack instances for current thread in current library.<p>
	 * 
	 * Requires instrumentation of your classes in order to work.
	 * 
	 * @see InstrumentationTask#setIsolated(boolean)
	 */
	public static void libraryCleanCurrentThread() {
		throw new Error("not instrumented");
	}
	
}