package org.sourceforge.jemm.client;
   
   import java.lang.reflect.Constructor;
   import java.util.HashMap;
   import java.util.Map;
   import java.util.Map.Entry;
   
   import org.sourceforge.jemm.JEMMInternalException;
   import org.sourceforge.jemm.database.ClassId;
  import org.sourceforge.jemm.database.ClassInfo;
  import org.sourceforge.jemm.database.ClientId;
  import org.sourceforge.jemm.database.FieldInfo;
  import org.sourceforge.jemm.database.FieldType;
  import org.sourceforge.jemm.database.GetObjectResp;
  import org.sourceforge.jemm.database.ObjectState;
  import org.sourceforge.jemm.database.ObjectSyncData;
  import org.sourceforge.jemm.database.ObjectSyncResp;
  import org.sourceforge.jemm.lifecycle.MethodListener;
  import org.sourceforge.jemm.lifecycle.ShadowTypeObject;
  import org.sourceforge.jemm.lifecycle.ShadowTypeObjectImpl;
  import org.sourceforge.jemm.lifecycle.ShadowUserObject;
  import org.sourceforge.jemm.lifecycle.ShadowUserObjectImpl;
  import org.sourceforge.jemm.types.ID;
  import org.sourceforge.jemm.util.JEMMObject;
  import org.sourceforge.jemm.util.JEMMType;
  
  /**
   * A Factory that converts and sets fields onto 
   * @author Paul Keeble
   *
   */
  public class JEMMObjectFieldMapper {
  	public static final ClientId DEFAULT_CLIENTID= new ClientId("CLIENT");
  	
  	MethodListener listener;
  	TypeRequestHandler typeRequestHandler;
  	
  	public JEMMObjectFieldMapper(MethodListener listener,TypeRequestHandler typeRequestHandler) {
  		this.listener = listener;
  		this.typeRequestHandler = typeRequestHandler;
  	}
  	
  	/**
  	 * Creates a new JEMMObject from the response along with introduced Tracked IDs.
  	 * 
  	 * @param resp The object response
  	 * @param ci The class information for the object to be created
  	 * @return The newly created JEMMObject
  	 */
  	public JEMMObject create(GetObjectResp resp,ClassInfo ci) {
  		if(ci.isType)
  			return createTypeObject(resp,resp.getClassId(),ci);
  		else
  			return createUserObject(resp,ci);
  	}
  	
  	private JEMMObject createTypeObject(GetObjectResp resp, ClassId classId,ClassInfo ci) {
  		try {
  			Class<?> clazz = Class.forName(ci.className);
  			Constructor<?> constructor =clazz.getDeclaredConstructor(new Class[]{ShadowTypeObject.class});
  			constructor.setAccessible(true);
  			ShadowTypeObjectImpl so = new ShadowTypeObjectImpl(null,resp.jemmId,classId,typeRequestHandler);
  			JEMMType obj = (JEMMType)constructor.newInstance(so);
  			so.setObject(obj);
  			mapFields(resp.fieldValues,obj);
  			return obj;
  		} catch (Exception e) {
  			throw new JEMMInternalException("Unable to construct object of type " + ci.className,e);
  		} 
  	}
  
  	private JEMMObject createUserObject(GetObjectResp resp, ClassInfo ci) {
  		try {
  			Class<?> clazz = Class.forName(ci.className);
  			Constructor<?> constructor =clazz.getDeclaredConstructor(new Class[]{ShadowUserObject.class});
  			ShadowUserObjectImpl so = new ShadowUserObjectImpl(listener,resp.jemmId,resp.clientVersion);
  			JEMMObject obj = (JEMMObject)constructor.newInstance(so);
  			so.setUserObject(obj);
  			
  			mapFields(resp.fieldValues,obj);
  			return obj;
  		} catch (Exception e) {
  			throw new JEMMInternalException("Unable to construct object",e);
  		} 
  	}
  
  	/**
  	 * Gets the Synchronisation data from a JEMMObject.
  	 * 
  	 * @param jo
  	 * @return
  	 */
  	public ObjectSyncData getSyncData(JEMMObject jo) {
  		ObjectAccessor oa = new ObjectAccessor(jo,null);
  		Entity e = new Entity(jo);
  		
  		Map<FieldInfo,Object> fields = oa.getAllFieldsMap();
  		ObjectSyncData data = new ObjectSyncData(e.getID(),e.getVersion(),fields);
  		
 		return data;
 	}
 	
 	/**
 	 * Updates the object with new meta and FieldData from the response.
 	 * 
 	 * Updates all primitive values. Updates and uninitialised Object fields with
 	 * the new ID.
 	 * 
 	 * Returns any 
 	 * @param jo
 	 * @param response
 	 */
 	public Map<FieldInfo,ID> syncResponseUpdateObject(JEMMObject jo,ObjectSyncResp response) {
 		Entity e = new Entity(jo);
 		e.setVersion(response.getNewVersionNo());
 		try {
 			mapFields(response.getUpdatedFields(),jo);
 			return null;
 		} catch (ClassNotFoundException e1) {
 			throw new JEMMInternalException("Unable to update object",e1);
 		}
 	}
 	
 	/**
 	 * Updates all the primitive values and uninitialised fields on a JEMMObject.
 	 * 
 	 * @param jo
 	 * @param state
 	 */
 	public void refreshPrimitiveState(JEMMObject jo, ObjectState state) {
 		Entity e = new Entity(jo);
 		e.setVersion(state.clientVersion);
 		try {
 			Map<FieldInfo,Object> primitiveFields = getPrimitiveFields(state.fieldValues);
 			mapFields(primitiveFields,jo);
 			Map<FieldKey,ID> unitialisedObjectFields = new ObjectAccessor(jo,null).getUninitialisedObjectFields();
 			
 			Map<FieldInfo,Object> uninitFieldState = getUninitialisedFields(unitialisedObjectFields,state.fieldValues);
 			mapFields(uninitFieldState,jo);
 		} catch (ClassNotFoundException e1) {
 			throw new JEMMInternalException("Unable to refresh object",e1);
 		}
 	}
 	
 	Map<FieldInfo,Object> getPrimitiveFields(Map<FieldInfo,Object> origFields)  {
 		Map<FieldInfo, Object> result = new HashMap<FieldInfo, Object>();
 		
 		for(Entry<FieldInfo,Object> fInfo : origFields.entrySet()) {
 			if(FieldType.isPrimitive(fInfo.getKey().fieldType)) {
 				result.put(fInfo.getKey(), fInfo.getValue());
 			}
 		}
 		
 		return result;
 	}
 	
 	Map<FieldInfo,Object> getUninitialisedFields(Map<FieldKey,ID> uninitialisedFields, Map<FieldInfo,Object> state) {
 		Map<FieldInfo,Object> result = new HashMap<FieldInfo,Object>();
 		
 		for(FieldKey fKey : uninitialisedFields.keySet()) {
 			FieldInfo fi = new FieldInfo(fKey.getName(),fKey.getClazz(),FieldType.OBJECT);
 			if(!state.containsKey(fi))
 				throw new JEMMInternalException("State missing field:" + fKey);
 			result.put(fi, state.get(fi));
 		}
 		return result;
 	}
 	
 	
 	private void mapFields(Map<FieldInfo,Object> origFields, JEMMObject obj) throws ClassNotFoundException {
 		ObjectAccessor oa = new ObjectAccessor(obj,null);
 		
 		for(Entry<FieldInfo,Object> fInfo : origFields.entrySet()) {
 			FieldInfo key = fInfo.getKey();
 			Object value = fInfo.getValue();
 			Class<?> declaringClass = Class.forName(key.className);
 			oa.setField(declaringClass, key.fieldName, value);
 		}
 	}
 }