package Sequenic.T2.Seq;

import java.io.IOException;
import java.io.InvalidClassException;
import java.io.NotSerializableException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.lang.reflect.InvocationTargetException;

import Sequenic.T2.Pool;
import Sequenic.T2.Engines.Util;

/**
 * Utilities to (de)Serialize MkValSteps
 * 

 * @author Jeiel Schalkwijk
 *
 */
public final class Externalize_MkValStep {
	
	//typeCodes. They are negative, since positive values are reserved for REF.
	private final static int CONST_NULL = -1;
	private final static int CONST_NON_NULL = -2;
	private final static int CREATE_OBJECT = -3;
	private final static int CREATE_COLLECTION_LIKE = -4;
	
	//if REF.index >= Byte.MAX_VALUE (or < 0), use this.
	private final static int REF_INT = -5;
	
	public static void write(MkValStep ms, ObjectOutput out) throws IOException {
		if(ms==null)
		{
			throw new NullPointerException();
		}
		else if(ms instanceof REF) 
		{
			int i = ((REF)ms).index;
			if(i>=0 && i<Byte.MAX_VALUE)
				out.write(i);
			else {
				out.write(REF_INT);
				out.writeInt(i);
			}
		}
		else if(ms instanceof CONST) 
		{
			CONST c = (CONST) ms;
			if(c.isNull()) {
    			out.write(CONST_NULL);
    			out.writeObject(c.getObjectClassName().intern());
			} else {
				out.write(CONST_NON_NULL);
				out.writeObject(c.getObject());
			}
		} 

		else if (ms instanceof CREATE_OBJECT) 
		{
			externalize((CREATE_OBJECT) ms).write(out);
		} else if (ms instanceof CREATE_COLLECTION_LIKE) 
		{
			externalize((CREATE_COLLECTION_LIKE) ms).write(out);
		}
		else if (ms instanceof ObsoleteMkValStep) 
		{
			((ObsoleteMkValStep) ms).write(out);
		} 
		else 
		{
			throw new NotSerializableException("Unknown type of MkValStep... "+ ms.getClass().toString());
		}
	}
	
	public static MkValStep read(ObjectInput in) throws IOException, ClassNotFoundException {
		final int code = in.readByte();
		
		if(code>=0)
			return new REF(code);
		else if(code==REF_INT)
			return new REF(in.readInt());
		else if(code==CONST_NULL)
			return CONST.nullConst(Class.forName((String) in.readObject()));
		else if(code==CONST_NON_NULL)
			return CONST.nonNull(in.readObject());
		else if(code==CREATE_OBJECT)
			return ObsoleteMkValStep.read(true,in);
		else if(code==CREATE_COLLECTION_LIKE)
			return ObsoleteMkValStep.read(false,in);
		else 
			throw new InvalidClassException("Unknown type code for a MkValStep... "+ code);
	}
	
	private static ObsoleteMkValStep externalize(CREATE_OBJECT co) {
        Class[] paramTypes = co.con.getParameterTypes();
    	String[] classNames = new String[paramTypes.length+1];
    	
        for (int i = 0; i < paramTypes.length; i++) {
            classNames[i] = paramTypes[i].getName();
        }
    	
        classNames[paramTypes.length] = co.con.getDeclaringClass().getName();
        
    	return new ObsoleteMkValStep(StringList.create(classNames), co.params, co.indexOfNewObject, true);
	}
	
	private static ObsoleteMkValStep externalize(CREATE_COLLECTION_LIKE ms)
	{
		return new ObsoleteMkValStep(StringList.create(ms.elementType.getName(), ms.collectionType)
		, ms.elements, ms.size, false);
	}
	
	/**
	 * This class can serialize CREATE_OBJECT and CREATE_COLLECTION_LIKE.
	 * It can also represent Obsolete versions of these MkValSteps.
	 * 
	 * See also resolve.
	 * 
	 * @author Jeiel Schalkwijk
	 *
	 */
	private static final class ObsoleteMkValStep extends MkValStep {

		/* An array of type names.
		 * 
		 * For CREATE_OBJECT this contains: 
		 * types = [x.getName() | x in constructor.paramTypes] ++ [constructor.getDeclaredClass.getName]
		 * 
		 * FOR CREATE_COLLECTION_LIKE this contains 2 type names:
		 * types = [ElementType.getName(), CollectionType]
		 */
		private final StringList types;
		
		/* Either the values of the constructor arguments (CREATE_OBJECT)
		 * Or, the values of the elements in the collection (CREATE_COLLECTION_LIKE)
		 */
		private final MkValStep[] vals;
		
		//The size of the CREATE_COLLECTION_LIKE, or the index of the CREATE_OBJECT
		private final int size_or_index;
		
		//True if this class is an instance of CREATE_OBJECT, 
		//false if it's an instance of CREATE_COLLECTION_LIKE
		private final boolean isCREATE_OBJECT;
		
		
		private ObsoleteMkValStep(StringList types, MkValStep[] vals,
				int sizeOrIndex, boolean isCREATE_OBJECT) {
			this.types = types;
			this.vals = vals;
			size_or_index = sizeOrIndex;
			this.isCREATE_OBJECT = isCREATE_OBJECT;
		}

		/** Returns a CREATE_OBJECT or CREATE_COLLECTION_LIKE if possible,
		 * but if the MkValStep is obsolete, it returns this.
		 * 
		 * @return
		 */
		private MkValStep resolve() 
		{
			
			//First recursively resolve the vals 
			for(int i = 0; i<vals.length;i++) 
			{				
				if(vals[i] instanceof ObsoleteMkValStep)
					vals[i] = ((ObsoleteMkValStep) vals[i]).resolve();

				//If one of the values is obsolete, then so is this step.
				if(vals[i].isObsolete())
					return this;
			}
			
			try
			{
				String[] types = this.types.getStrings();

				if(isCREATE_OBJECT) 
				{
	    			Class[] paramTypes = new Class[types.length-1];				
	    			for (int i = 0; i < paramTypes.length; i++) {
	    				paramTypes[i] = Util.classOf(types[i]);
	    			}  
	    							
	                return new CREATE_OBJECT(
	                		
	                		// Class of Contstructor              . Actual Constructor
	                		Util.classOf(types[paramTypes.length]).getDeclaredConstructor(paramTypes)
	                		,vals
	                		,size_or_index
	                );
				} 
				else 
				{
					//CREATE_COLLECTION_LIKE case
					
		            return new CREATE_COLLECTION_LIKE(types[1], Util.classOf(types[0]), size_or_index, vals);
				}
	        } catch (ClassNotFoundException e)
			{
			} catch (SecurityException e)
			{
			} catch (NoSuchMethodException e)
			{
			}
			
			//An exception was thrown: one of the types used is obsolete, so return this.
			return this;
		}
		
		@Override
		public Object exec(Class CUT, Pool pool) throws InvocationTargetException
		{
			final String s = isCREATE_OBJECT ? "Obsolete CREATE_OBJECT can not be executed"
					: "Obsolete CREATE_COLLECTION_LIKE can not be executed";
			throw new UnsupportedOperationException(s);
		}

		@Override
		public boolean isObsolete()
		{
			return true;
		}
		
		private void write(ObjectOutput out) throws IOException
		{
			//These are common for both cases
			
			//write the typeCode
			out.write(isCREATE_OBJECT? CREATE_OBJECT : CREATE_COLLECTION_LIKE);
			
			out.writeInt(size_or_index); //size_or_index
			out.writeObject(this.types); //type names
			
			if(isCREATE_OBJECT)
			{
				//The CREATE_OBJECT case
				
				int i;
				for(i = 0; i<vals.length;i++) {  //for constructor arg i
					Externalize_MkValStep.write(vals[i],out);   //value of i
				}
				
			} else {
				
				//The CREATE_COLLECTION_LIKE case
				
				//The elements
				out.writeInt(vals.length);
				for(MkValStep v : vals)
					Externalize_MkValStep.write(v,out);
				
			}
		}

		private static MkValStep read(boolean isCREATE_OBJECT, ObjectInput in) throws IOException, ClassNotFoundException
		{
			//Note the typeCode has already been deserialized 
			//The boolean isCREATE_OBJECT indicates the value
			
			//Common for both cases
			int s_or_i = in.readInt();			
			StringList typesList = (StringList) in.readObject();
			MkValStep[] vals;
			
			if(isCREATE_OBJECT) 
			{	
				//CREATE_OBJECT case
				vals = new MkValStep[typesList.getStrings().length-1];
				
				//Constructor arguments
				for(int i=0;i<vals.length;i++)
					vals[i] = Externalize_MkValStep.read(in);
			
			} else {
			
				//Elements in Collection
				vals = new MkValStep[in.readInt()];
				for(int i=0;i<vals.length;i++)
					vals[i] = Externalize_MkValStep.read(in);
				
			}
			return new ObsoleteMkValStep(typesList, vals, s_or_i, isCREATE_OBJECT).resolve();
		}
		
	}
}