package net.sf.crispy.impl.rest;
   
   import java.lang.reflect.Method;
   import java.util.ArrayList;
   import java.util.Hashtable;
   import java.util.Iterator;
   import java.util.List;
   import java.util.Map;
   import java.util.TreeMap;
  import java.util.Vector;
  import java.util.Map.Entry;
  
  import net.sf.crispy.impl.http.Constant;
  import net.sf.crispy.util.Converter;
  import net.sf.crispy.util.Invoker;
  import net.sf.crispy.util.Util;
  
  public class ParameterDeserializer {
  	
  	public static Map convertString2Map (String pvParamStr) {
  		String lvParams[] = pvParamStr.split("&");
  		Map lvMap = new Hashtable(lvParams.length);
  		for (int i = 0; i < lvParams.length; i++) {
  			String lvKeyVal[] = lvParams[i].split("=");
  			String lvValue[] = (String[]) lvMap.get(lvKeyVal[0]);
  			if (lvValue == null) {
  				lvMap.put(lvKeyVal[0], new String[] {lvKeyVal[1]});
  			} else {
  				String lvNewValue [] = new String[lvValue.length + 1];
  				for (int j = 0; j < lvValue.length; j++) {
  					lvNewValue[j] = lvValue[j];
  				}
  				lvNewValue[lvValue.length] = lvKeyVal[1];
  				lvMap.put(lvKeyVal[0], lvNewValue);
  			}
  			
  		}
  		return lvMap;
  	}
  	
  
  	public Object deserialize(final Map pvParamMap) throws Exception {
  		Map lvMap = new Hashtable();
  		Map lvRefMap = new TreeMap();
  		pvParamMap.remove(Constant.PARAM_TYPES);
  
  		Iterator itMap = pvParamMap.entrySet().iterator();
  		while (itMap.hasNext()) {
  			Map.Entry lvMapEntry = (Entry) itMap.next();
  			String lvKey = (String) lvMapEntry.getKey();
  			Object o = lvMapEntry.getValue();
  			String lvValue[] = null;
  			if (o.getClass().isArray()) { 
  				lvValue = (String[]) pvParamMap.get(lvKey); 
  				}
  				else {
  					lvValue = new String[] { o.toString() };
  				}
  
  			// Parameter einsammeln
  			// alles was vor dem Unterstrich ist, gehoert zu einer Klasse
  			// param0_name und param0_vorname werden in eine Gruppe (Map) unter dem Namen param0 abgelegt
  			String lvParam[] = lvKey.split(ParameterSerializer.DELIMITTER);
  			Map lvClassMap = (Map) lvMap.get(lvParam[0]);
  			if (lvClassMap == null) { lvClassMap = new Hashtable(); }
  			
  			switch (lvParam.length) {
  				// simple Parameter
  				case 1:
  					lvClassMap.put(lvParam[0], lvValue[0]);
  					break;
  				case 2:
  					// param1_name="Peter" --> name=Peter
  					lvClassMap.put(lvParam[1], lvValue[0]);
  					break;
  					
  				// References (MAP, MAPSIMPLE, LIST)
  				case 3:
  					lvRefMap.put(lvKey, lvValue);
  					break;
  
  				// param1_MAP_childrenMap_Node2
  				case 4:
  					lvRefMap.put(lvKey, lvValue);
  					break;
  					
  				default:
  					// lvClassMap.put(lvParam[1], lvValue[0]);
  					System.out.println("???? ParameterDeserializer: " + lvParam.length 
  							+ " --> " + Util.array2String(lvParam)
  							+ " --> " + Util.array2String(lvValue));
  					break;
  			}
  			if (lvClassMap.size() > 0) { lvMap.put(lvParam[0], lvClassMap); }
  		} // WHILE
  		
  		// aus einzelnen werten wieder ein Objekt bauen
  		itMap = lvMap.entrySet().iterator();
  		// sortieren der Attribute param0, param1, param2, ...
 		Map lvParamObject = new TreeMap();
 		while(itMap.hasNext()) {
 			Map.Entry lvMapEntry = (Entry) itMap.next();
 			String lvKey = (String) lvMapEntry.getKey();
 			Map lvClassMap = (Map) lvMapEntry.getValue();
 			String lvClassStr = (String) lvClassMap.get("class");
 			if (lvClassStr != null) {
 				Class lvClass = Class.forName(lvClassStr);
 				// alle Properties in den richtigen datentyp umwandeln
 				Iterator itClassMap = lvClassMap.entrySet().iterator();
 				while (itClassMap.hasNext()) {
 					Map.Entry lvMapEntry_Class = (Entry) itClassMap.next();
 					String lvKeyClassMap = (String) lvMapEntry_Class.getKey();
 					if (!(lvKeyClassMap.equals("class"))) {
 						Object lvValue = lvMapEntry_Class.getValue();
 						
 						if (lvKeyClassMap.startsWith(Converter.HASH_CODE_KEY)) {
 							 lvClassMap.put(lvKeyClassMap, lvValue);
 						} else if (lvValue.toString().startsWith(Converter.HASH_CODE_KEY)) {
 							 lvClassMap.put(lvKeyClassMap, lvValue);
 						} else {
 							// alle setter aufrufen, um die Werte zu setzen
 							String lvProperty = "set" + lvKeyClassMap.substring(0,1).toUpperCase() + lvKeyClassMap.substring(1);
 							Vector v = new Vector(1);
 							v.add(lvValue);
 							Method lvMethod = Invoker.findMethod(lvClass, lvProperty, v);
 							lvValue = Converter.convertStringParams2MethodParams(lvMethod, v)[0];
 							lvValue = new Converter().makeSimple(lvValue);
 							lvClassMap.put(lvKeyClassMap, lvValue);
 						}
 						
 					}
 				} // WHILE
 				// einzelne Instancen erzeugen
 				lvParamObject.put(lvKey, lvClassMap);
 				
 			} // IF lvClassStr != null 
 			// einfache Parameter
 			else if (lvClassMap.size() > 0) {
 					String lvSimpleKey = (String) lvClassMap.keySet().iterator().next();
 					lvParamObject.put(lvSimpleKey, lvClassMap.get(lvSimpleKey));
 			}
 			
 		} // WHILE
 
 		// ----- alle Referenzen zwischen den Objeten wieder aufbauen -----
 		Iterator it = lvRefMap.entrySet().iterator();
 		List lvDelList = new ArrayList();
 		
 		while (it.hasNext()) {
 			Map.Entry lvMapEntry = (Entry) it.next();
 			String lvKey = (String) lvMapEntry.getKey();
 			Object lvRefValue = lvMapEntry.getValue();
 			String lvValues[] = (String[]) lvRefValue;
 			String lvParam[] = lvKey.split(ParameterSerializer.DELIMITTER);
 			
 			Vector lvParamVector = null;
 			
 			for (int i = 0; i < lvValues.length; i++) {
 				String lvValue = lvValues[i];	
 				Object o = lvParamObject.get(lvValue);
 				
 				if (lvParam[1].equals(ParameterSerializer.LIST)) {
 					Object ob = lvParamObject.get(lvParam[0]);
 					
 					// Referenz finden
 					Map m = findListReferences(lvMap, lvValue);
 					if (ob == null) {
 						if (lvParamVector == null) {lvParamVector = new Vector(); }
 						if ((m != null) && (m.size() > 0)) {
 							lvParamVector.add(m);
 							lvDelList.add(lvValue);
 						} else { 
 							lvParamVector.add(lvValue);
 						}
 						lvParamObject.put(lvParam[0], lvParamVector);
 					}
 					else if (ob instanceof Vector) {
 						lvParamVector = (Vector) ob;
 						// Wert setzen
 						if ((m != null) && (m.size() > 0)) { lvParamVector.add(m); }
 							// Referenz setzen
 							else {  lvParamVector.add(lvValue); }
 						lvParamObject.put(lvParam[0], lvParamVector);
 						lvDelList.add(lvValue);
 					}
 					else {
 						Map lvMap2 = (Map) ob;
 						lvParamVector = (Vector) lvMap2.get(lvParam[2]);
 						if (lvParamVector == null) {lvParamVector = new Vector(); }
 						// Referenz setzen
 						if (lvValue.startsWith(Converter.HASH_CODE_KEY)) { lvParamVector.add(lvValue); }
 							// Wert setzen
 							else { 
 								// Wert setzen
 								if ((m != null) && (m.size() > 0)) { lvParamVector.add(m); }
 								// Referenz setzen
 								else {  lvParamVector.add(lvValue); }
 							}
 						lvMap2.put(lvParam[2], lvParamVector);
 						lvParamObject.put(lvParam[0], lvMap2);
 						lvDelList.add(lvValue);
 					}
 				} // IF LIST
 				
 				else if (lvParam[1].equals(ParameterSerializer.MAPSIMPLE)) {
 					Map lvParamMap = (Map) lvParamObject.get(lvParam[0]);
 					if (lvParamMap == null) { lvParamMap =  new Hashtable(); }
 					// handelt es sich um eine Referenz?
 					Map m = findListReferences(lvParamObject, lvValue);
 					if ((m != null) && (m.size() > 0)) { lvParamMap.put(lvParam[2], m); }
 						// sonst ist es ein Wert
 						else { lvParamMap.put(lvParam[2], lvValue); }
 					if (lvParamMap.size() > 0) {
 						lvParamObject.remove(lvValue);
 						lvParamObject.put(lvParam[0], lvParamMap); 
 					}
 				} // ELSE IF MAPSIMPLE
 				
 				else if (lvParam[1].equals(ParameterSerializer.MAP)) {
 					// Referenz finden
 					if (lvMap.get(lvParam[0]) != null) {
 						Map m = findMapReferences(lvRefMap, lvMap, lvValue);
 						if ((m != null) && (m.size() > 0)){
 //							System.out.println("--- " + lvParam[0] + ": " + lvMap.get(lvParam[0]));
 							String lvMapKey = lvKey.split(ParameterSerializer.DELIMITTER)[2];
 							
 							Iterator lvIterator = m.keySet().iterator();
 							while (lvIterator.hasNext()) {
 								String lvDelKey = lvValue + ParameterSerializer.DELIMITTER  
 										+ ParameterSerializer.MAP + ParameterSerializer.DELIMITTER + lvMapKey
 										+ ParameterSerializer.DELIMITTER + lvIterator.next();
 								Object obj = lvRefMap.get(lvDelKey);
 								if (obj != null) {
 									lvDelKey = ((String[]) obj)[0];
 									lvDelList.add(lvDelKey);
 								}
 							}
 							((Map) lvParamObject.get(lvParam[0])).put(lvMapKey, m);
 						}
 					}
 				} // ELSE IF MAP
 				
 				else if (o != null) {
 					System.out.println("---- Invalid type in param (ParameterDeserializer): " + lvParam[1] + " -- " + o);
 				}
 				else {
 					System.out.println("????????????? ParameterDeserializer");
 				}
 			} // FOR
 		} // WHILE
 		
 		
 		// Alle durch referenzen ersetzten Objekte Loeschen
 		for (Iterator iter = lvDelList.iterator(); iter.hasNext();) {
 			String lvDel = (String) iter.next();
 			lvParamObject.remove(lvDel);
 		}
 
 		
 		 // System.out.println("PARAM-MAP-AFTER: " + lvParamObject);
 		
 		// ----- richtige Reihenfolge herstellen und als return zurueckgeben -----
 		Vector lvRetVec = new Vector();
 		it = lvParamObject.keySet().iterator();
 		while (it.hasNext()) {
 			Object lvKey = it.next();
 			Object lvValue = lvParamObject.get(lvKey);
 			lvValue = new Converter().makeComplex(lvValue);
 			lvRetVec.add(lvValue);
 		}
 
 		
 		if (lvRetVec.size() == 1) { return lvRetVec.get(0); }
 			else { return lvRetVec; }
 	}
 	
 	
 	public Map findListReferences (Map pvClassMap, String pvFindString) {
 		Map ret = new Hashtable();
 		Map lvMap = (Map) pvClassMap.get(pvFindString);
 		// z.B.: param0_LIST_children=param2
 		if (lvMap != null) {  return lvMap;  }
 			// z.B.: param4_LIST_children=~hashCode~8029412 -> bereits bekanntes Objekt suchen
 			else {
 				String lvSearchHashCode = null;
 				if (pvFindString.indexOf(Converter.HASH_CODE_KEY) == 0) {
 					lvSearchHashCode =  pvFindString.substring(Converter.HASH_CODE_KEY.length());
 					Iterator it2 = pvClassMap.entrySet().iterator();
 					while (it2.hasNext()) {
 						Map.Entry lvMapEntry = (Entry) it2.next();
 						Map lvValue2 = (Map) lvMapEntry.getValue();
 						Object o = lvValue2.get(Converter.HASH_CODE_KEY);
 						if ((o != null) && (o.equals(lvSearchHashCode))) {
 							return lvValue2;
 						}
 					}
 				}
 			} // ELSE
 		return ret;
 	}
 	
 	public Map findMapReferences (Map pvRefMap, Map pvClassMap, String pvFindString) {
 		Iterator it = pvRefMap.entrySet().iterator();
 		Map ret = new Hashtable();
 		while (it.hasNext()) {
 			Map.Entry lvMapEntry = (Entry) it.next();
 			String lvKey = (String) lvMapEntry.getKey();
 			String lvValue[] = (String[]) lvMapEntry.getValue();
 			if (lvKey.startsWith(pvFindString)) {
 				String lvNewMapKey = lvKey.split(ParameterSerializer.DELIMITTER)[3];
 				String lvFindRefKey[] = (String[]) pvRefMap.get(lvKey);
 				if (lvFindRefKey[0].startsWith(Converter.HASH_CODE_KEY)) {
 					ret.put(lvNewMapKey, lvFindRefKey[0]);
 				} else {
 					ret.put(lvNewMapKey, pvClassMap.get(lvFindRefKey[0]));
 				}
 			}
 		} // WHILE
 		return ret;
 	}
 		
 }