/*-
 * ================================================================================
 * eCOMP Portal SDK
 * ================================================================================
 * Copyright (C) 2017 AT&T Intellectual Property
 * ================================================================================
 * Licensed 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 org.openecomp.portalsdk.core.domain.support;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

public class Layout {
	
	public Map<String,Domain> domainRowCol;          
		
	Map<String,Domain> originalDomainRowCol;  

	//Horizontal space between a pair of domains
	double interDomainWd;
	//Vertical space between a pair of domains
	double interDomainH;
	//Computing the co-ordinates of any domain
	int numberofRowsofDomains;
	
	int numberofColsofDomains;
	
	Map<String, Domain> collapsedDomains;
	
	List<Domain> collapsedDomainsNewList;
	
	public List<Domain> getCollapsedDomainsNewList() {
		return collapsedDomainsNewList;
	}

	public void setCollapsedDomainsNewList(List<Domain> collapsedDomainsNewList) {
		this.collapsedDomainsNewList = collapsedDomainsNewList;
	}

	public void setCollapsedDomains(Map<String, Domain> collapsedDomains) {
		this.collapsedDomains = collapsedDomains;
	}

	public Map<String, Domain> getCollapsedDomains() {
		return collapsedDomains;
	}

	public int getNumberofColsofDomains() {
		return numberofColsofDomains;
	}

	public void setNumberofColsofDomains(int numberofColsofDomains) {
		this.numberofColsofDomains = numberofColsofDomains;
	}

	public Layout(Map<String,Domain> domainRowCol, double interDomainWd, double interDomainH, 
				  int numberofRowsofDomains, int numberofColsofDomains) {
		
		this.domainRowCol = domainRowCol;
		this.interDomainWd = interDomainWd;
		this.interDomainH = interDomainH;
		this.numberofRowsofDomains = numberofRowsofDomains;
		this.numberofColsofDomains = numberofColsofDomains;
		this.collapsedDomains = new HashMap<String, Domain>();
		this.originalDomainRowCol = new TreeMap<String,Domain>();
		this.collapsedDomainsNewList = new ArrayList<Domain>();
	}
	
	public Map<String, Domain> getDomainRowCol() {
		return domainRowCol;
	}

	public void setDomainRowCol(Map<String, Domain> domainRowCol) {
		this.domainRowCol = domainRowCol;
	}
	
	
	public void computeDomainPositions() {
		double xsum = 0;
		double domainTolayout = 10.6;
		for (int i=0; i< numberofRowsofDomains; i++){
			for (int j=0; j<numberofColsofDomains; j++){
				if (domainRowCol.containsKey(String.valueOf(i)+ String.valueOf(j))) {
					Domain d = domainRowCol.get(String.valueOf(i)+ String.valueOf(j));
					Position p = new Position();
					if (j==0)
						p.x = domainTolayout;
					else
						p.x = j*interDomainWd + xsum + domainTolayout;
					if (getCollapsedDomainsNewList().size() > 0)
						p.x+= accountForPlusSpaceBefore(d);
					xsum+=d.computeSize().getWidth();
					double ysum=0;
					for (int k=0; k<i; k++) {
						if (domainRowCol.containsKey(String.valueOf(k)+ String.valueOf(j)))
							ysum+= domainRowCol.get(String.valueOf(k)+ String.valueOf(j)).computeSize().getHeight();
					}
					p.y = (i+1)* interDomainH + ysum;
					d.setP(p);
				
				} 
			}
			xsum = 0;
		}
	}

	public void computeDomainPositionsModified() {
		for (int i=0; i< numberofRowsofDomains; i++){
			for (int j=0; j<numberofColsofDomains; j++){
				if (domainRowCol.containsKey(String.valueOf(i)+ String.valueOf(j))) {
					Domain d = domainRowCol.get(String.valueOf(i)+ String.valueOf(j));
					Position p = new Position();
					Map<String,Container> enclosedContainers = d.getContainerRowCol();
					for (Map.Entry<String, Container> entry : enclosedContainers.entrySet()) {
						if (entry.getKey().equals("00")) {
							double containerX = entry.getValue().getP().getX();
							p.x = containerX;
							double ysum=0;
							for (int k=0; k<i; k++) {
								if (domainRowCol.containsKey(String.valueOf(k)+ String.valueOf(j)))
									ysum+= domainRowCol.get(String.valueOf(k)+ String.valueOf(j)).computeSize().getHeight();
							}
							p.y = (i+1)* interDomainH + ysum;
							d.setP(p);
							break;
						}
					}
				}
			}
		}
					
	
	}
	public Layout collapseDomainModified(String domainsToCollapse) {
	
	   if(domainsToCollapse == null || domainsToCollapse.isEmpty())
		   return null;
		   
		Map<String,Domain> updatedRC = new HashMap<String, Domain>();
		
		for (Map.Entry<String, Domain> copyEntry : domainRowCol.entrySet()) {
			updatedRC.put(copyEntry.getKey(), copyEntry.getValue());
			System.out.println("copyEntry.getKey() "+copyEntry.getKey()+ " copyEntry.getValue() "+copyEntry.getValue());
		}
		
		Map<String, Domain> updatedRCSorted = new TreeMap<String, Domain>(updatedRC);
		
		Map<String, Domain> collapsedDomainMap =  getCollapsedDomains();
		
		List<Domain> collapsedDomainNewL = getCollapsedDomainsNewList();
		
		
		if (collapsedDomainNewL.size() == 0) {
			for (Map.Entry<String, Domain> copyEntry : domainRowCol.entrySet()) {
				originalDomainRowCol.put(copyEntry.getKey(), copyEntry.getValue());
			}
		}
			
		
		Map<String, Domain> updatedRCSortedTrunc = new TreeMap<String, Domain>();
	
			int colToDelete = 0;
			for (Map.Entry<String, Domain> entry : updatedRCSorted.entrySet()) {
				if (entry.getValue().getName().equals(domainsToCollapse)) {
					if (entry.getValue().isIndexChanged()) {
						collapsedDomainMap.put("0"+String.valueOf(Integer.parseInt(entry.getKey())+1), entry.getValue());
						
					}
					else {
						collapsedDomainMap.put(entry.getKey(),entry.getValue());
					}
					
					collapsedDomainNewL.add(entry.getValue());
					setNumberofColsofDomains(getNumberofColsofDomains()-1);
					updatedRC.remove(entry.getKey());
					colToDelete = Character.getNumericValue(entry.getKey().toCharArray()[1]);
					break;
				}
			}
			
			
			for (Map.Entry<String, Domain> copyEntry : updatedRCSorted.entrySet()) {
				updatedRCSortedTrunc.put(copyEntry.getKey(), copyEntry.getValue());
				System.out.println("copyEntry.getKey() "+copyEntry.getKey()+ " copyEntry.getValue() "+copyEntry.getValue());
			}
			
			for (Map.Entry<String, Domain> rmv : updatedRCSorted.entrySet()) {
				if (Character.getNumericValue(rmv.getKey().toCharArray()[1]) <= colToDelete) {
					updatedRCSortedTrunc.remove(rmv.getKey());
				}
			}
			
			for (Map.Entry<String, Domain> updateOthers : updatedRCSortedTrunc.entrySet()) {
						char update[] = updateOthers.getKey().toCharArray();
						int charToupdate = Character.getNumericValue(update[1]);
						--charToupdate;
						String resultRowCol = String.valueOf(update[0])+String.valueOf(charToupdate);
						updateOthers.getValue().setIndexChanged(true);
						updatedRC.put(resultRowCol, updateOthers.getValue());
						updatedRC.remove(updateOthers.getKey());
			
			}
		setDomainRowCol(updatedRC);
		
		double currDistFromLftM = 11.0;
		for (Map.Entry<String,Domain> cd : updatedRC.entrySet()) {
			
			Domain d = cd.getValue();
			double accountPlus = accountForPlusSpaceBefore(d);
			d.setDomainToLayoutWd(currDistFromLftM+accountPlus);
			d.computeConatinerPositions();
			for (Map.Entry<String, Container> entry1 : d.getContainerRowCol().entrySet()) {
				Container c = entry1.getValue();
				c.computeSize();
				c.computeElementPositions();
				if (c.getContainerRowCol() != null) {
					for (Map.Entry<String, Container> entryInner : c.getContainerRowCol().entrySet()) {
						Container inner = entryInner.getValue();
						inner.computeElementPositions();
					}	
				}
			}
			currDistFromLftM += d.computeSize().getWidth()+2;
		
		}
		
		
		
		
		//nline
		// Insert method invocation
		updatePlusPosition(collapsedDomainNewL, updatedRC);
		
		//order changed
		setCollapsedDomains(collapsedDomainMap);
		setCollapsedDomainsNewList(collapsedDomainNewL);
		
		
		computeDomainPositionsModified();
		return this;
   } 
	
	
	
	public Layout collapseDomainNew(String domainsToCollapse) {
		
		   if(domainsToCollapse == null || domainsToCollapse.isEmpty())
			   return null;
			   
			Map<String,Domain> updatedRC = new HashMap<String, Domain>();
			
			for (Map.Entry<String, Domain> copyEntry : domainRowCol.entrySet()) {
				updatedRC.put(copyEntry.getKey(), copyEntry.getValue());
				System.out.println("copyEntry.getKey() "+copyEntry.getKey()+ " copyEntry.getValue() "+copyEntry.getValue());
			}
			
			Map<String, Domain> updatedRCSorted = new TreeMap<String, Domain>(updatedRC);
			
			Map<String, Domain> collapsedDomainMap =  getCollapsedDomains();
			
			List<Domain> collapsedDomainNewL = getCollapsedDomainsNewList();
			
			
			if (collapsedDomainNewL.size() == 0) {
				for (Map.Entry<String, Domain> copyEntry : domainRowCol.entrySet()) {
					originalDomainRowCol.put(copyEntry.getKey(), copyEntry.getValue());
				}
			}
				
			
			Map<String, Domain> updatedRCSortedTrunc = new TreeMap<String, Domain>();
		
				int colToDelete = 0;
				for (Map.Entry<String, Domain> entry : updatedRCSorted.entrySet()) {
					if (entry.getValue().getName().equals(domainsToCollapse)) {
						if (entry.getValue().isIndexChanged()) {
							collapsedDomainMap.put("0"+String.valueOf(Integer.parseInt(entry.getKey())+1), entry.getValue());
							
						}
						else {
							collapsedDomainMap.put(entry.getKey(),entry.getValue());
						}
						
						collapsedDomainNewL.add(entry.getValue());
						setNumberofColsofDomains(getNumberofColsofDomains()-1);
						updatedRC.remove(entry.getKey());
						colToDelete = Character.getNumericValue(entry.getKey().toCharArray()[1]);
						break;
					}
				}
				
				
				for (Map.Entry<String, Domain> copyEntry : updatedRCSorted.entrySet()) {
					updatedRCSortedTrunc.put(copyEntry.getKey(), copyEntry.getValue());
					System.out.println("copyEntry.getKey() "+copyEntry.getKey()+ " copyEntry.getValue() "+copyEntry.getValue());
				}
				
				for (Map.Entry<String, Domain> rmv : updatedRCSorted.entrySet()) {
					if (Character.getNumericValue(rmv.getKey().toCharArray()[1]) <= colToDelete) {
						updatedRCSortedTrunc.remove(rmv.getKey());
					}
				}
			
				for (Map.Entry<String, Domain> updateOthers : updatedRCSortedTrunc.entrySet()) {
							char update[] = updateOthers.getKey().toCharArray();
							int charToupdate = Character.getNumericValue(update[1]);
							--charToupdate;
							String resultRowCol = String.valueOf(update[0])+String.valueOf(charToupdate);
							updateOthers.getValue().setIndexChanged(true);
							updatedRC.put(resultRowCol, updateOthers.getValue());
							updatedRC.remove(updateOthers.getKey());
				
				}
			setDomainRowCol(updatedRC);
			
			double currDistFromLftM = 11.0;
			
			boolean isDisplayed;
			for (Map.Entry<String,Domain> orgEntry : originalDomainRowCol.entrySet()) {
				isDisplayed = false;
				for (Map.Entry<String,Domain> cd : updatedRC.entrySet()) {
					if (cd.getValue().getName().equals(orgEntry.getValue().getName())) {
						Domain d = cd.getValue();
						d.setDomainToLayoutWd(currDistFromLftM);
						d.computeConatinerPositions();
						for (Map.Entry<String, Container> entry1 : d.getContainerRowCol().entrySet()) {
							Container c = entry1.getValue();
							c.computeSize();
							c.computeElementPositions();
							if (c.getContainerRowCol() != null) {
								for (Map.Entry<String, Container> entryInner : c.getContainerRowCol().entrySet()) {
									Container inner = entryInner.getValue();
									inner.computeElementPositions();
								}	
							}
						}
						currDistFromLftM += d.computeSize().getWidth()+1;
						isDisplayed = true;
						break;
					}
				}
			
				if (!isDisplayed) {
					Domain myCollapsed = orgEntry.getValue(); 
					myCollapsed.setNewXafterColl(currDistFromLftM);
					myCollapsed.setYafterColl(myCollapsed.getP().getY());
					currDistFromLftM += 4;
				}
			}
			
			setCollapsedDomains(collapsedDomainMap);
			setCollapsedDomainsNewList(collapsedDomainNewL);
			
			
			computeDomainPositionsModified();
			return this;
	
	}
	
	
	public Layout collapseDomain(String domainsToCollapse) {
		
		Map<String,Domain> updatedRC = new HashMap<String, Domain>();
		
		for (Map.Entry<String, Domain> copyEntry : domainRowCol.entrySet()) {
			updatedRC.put(copyEntry.getKey(), copyEntry.getValue());
			System.out.println("copyEntry.getKey() "+copyEntry.getKey()+ " copyEntry.getValue() "+copyEntry.getValue());
		}
		
		Map<String, Domain> updatedRCSorted = new TreeMap<String, Domain>(updatedRC);
		
		Map<String, Domain> collapsedDomainMap =  getCollapsedDomains();
		
		if (collapsedDomainMap.size() == 0) {
			for (Map.Entry<String, Domain> copyEntry : domainRowCol.entrySet()) {
				originalDomainRowCol.put(copyEntry.getKey(), copyEntry.getValue());
			}
		}
			
		
		double prevDomXCordinate = 0.0;
		Map<String, Domain> updatedRCSortedTrunc = new TreeMap<String, Domain>();
		int colToDelete = 0;
		for (Map.Entry<String, Domain> entry : updatedRCSorted.entrySet()) {
				if (entry.getValue().getName().equals(domainsToCollapse)) {
					if (entry.getValue().isIndexChanged())
						collapsedDomainMap.put("0"+String.valueOf(Integer.parseInt(entry.getKey())+1), entry.getValue());
					else
						collapsedDomainMap.put(entry.getKey(),entry.getValue());
					prevDomXCordinate = entry.getValue().getP().getX();
					entry.getValue().getP().setX(prevDomXCordinate-2);
					setNumberofColsofDomains(getNumberofColsofDomains()-1);
					updatedRC.remove(entry.getKey());
					colToDelete = Character.getNumericValue(entry.getKey().toCharArray()[1]);
					break;
				}
			}
			
			setCollapsedDomains(collapsedDomainMap);
			
			for (Map.Entry<String, Domain> copyEntry : updatedRCSorted.entrySet()) {
				updatedRCSortedTrunc.put(copyEntry.getKey(), copyEntry.getValue());
				System.out.println("copyEntry.getKey() "+copyEntry.getKey()+ " copyEntry.getValue() "+copyEntry.getValue());
			}
			
			for (Map.Entry<String, Domain> rmv : updatedRCSorted.entrySet()) {
				if (Character.getNumericValue(rmv.getKey().toCharArray()[1]) <= colToDelete) {
					updatedRCSortedTrunc.remove(rmv.getKey());
				}
			}
			
			for (Map.Entry<String, Domain> updateOthers : updatedRCSortedTrunc.entrySet()) {
						char update[] = updateOthers.getKey().toCharArray();
						int charToupdate = Character.getNumericValue(update[1]);
						--charToupdate;
						String resultRowCol = String.valueOf(update[0])+String.valueOf(charToupdate);
						updateOthers.getValue().setIndexChanged(true);
						updatedRC.put(resultRowCol, updateOthers.getValue());
						updatedRC.remove(updateOthers.getKey());
			}
		
		setDomainRowCol(updatedRC);
		
		
		
		for (Map.Entry<String, Domain> entry : updatedRCSortedTrunc.entrySet()) {
			Domain d = entry.getValue();
				if (collapsedDomains.size() == 2 && collapsedDomains.containsKey("00") && collapsedDomains.containsKey("01") && domainsToCollapse.equals("RAN")) {
					if (d.getName().equals("USP"))
						d.setDomainToLayoutWd(prevDomXCordinate);
					else if (d.getName().equals("VNI"))
						d.setDomainToLayoutWd(prevDomXCordinate+8);
					else
						d.setDomainToLayoutWd(prevDomXCordinate+10);
				} 
				else if (domainsToCollapse.equals("RAN") && !d.getName().equals("EPC") && collapsedDomains.size() < 3)
					d.setDomainToLayoutWd(prevDomXCordinate+11);
				else if (domainsToCollapse.equals("RAN") && collapsedDomains.size() == 3 && collapsedDomains.containsKey("01") && collapsedDomains.containsKey("04")) {
					if (d.getName().equals("USP"))
						d.setDomainToLayoutWd(prevDomXCordinate);
					else
						d.setDomainToLayoutWd(prevDomXCordinate+10);
				}
					
				else if (collapsedDomains.containsKey("00") && collapsedDomains.size() == 3 && collapsedDomains.containsKey("01") && collapsedDomains.containsKey("02")) {
					if (d.getName().equals("VNI"))
						d.setDomainToLayoutWd(prevDomXCordinate+10);
					else
						d.setDomainToLayoutWd(prevDomXCordinate);
					
				}
				
				else if (collapsedDomains.containsKey("00") && collapsedDomains.size() == 3 && collapsedDomains.containsKey("01") && collapsedDomains.containsKey("03")) {
					if (d.getName().equals("VNI"))
						d.setDomainToLayoutWd(prevDomXCordinate+10);
					else
						d.setDomainToLayoutWd(prevDomXCordinate);
					
				}
				
				
				
				else {
					d.setDomainToLayoutWd(prevDomXCordinate);
				}
				d.computeConatinerPositions();
				prevDomXCordinate = d.getP().getX();
				for (Map.Entry<String, Container> entry1 : d.getContainerRowCol().entrySet()) {
					Container c = entry1.getValue();
					c.computeSize();
					c.computeElementPositions();
					if (c.getContainerRowCol() != null) {
						for (Map.Entry<String, Container> entryInner : c.getContainerRowCol().entrySet()) {
							Container inner = entryInner.getValue();
							inner.computeElementPositions();
						}	
					}
				}
		} 
		computeDomainPositions();
		return this;
		
	} 
	
	public Layout uncollapseDomainModified(String domainToUnCollapse) {
		 Map<String, Domain> currentDomainsSorted = new TreeMap<String,Domain>(domainRowCol);
		 Map<String, Domain> updateDomains = new TreeMap<String,Domain>();
		 Map<String, Domain> collapsedDomainList =  getCollapsedDomains();
		 Map<String, Domain> collapsedDomainListSorted =  new TreeMap<String, Domain>(collapsedDomainList);
	
		 List<Domain> domainstoUpd = new ArrayList<Domain>();
		 
		 int colToUnCollapse = 99;
		 
		 Domain domainToInsert = null;
		 
		 if (collapsedDomains.size() == 0) {
			 for (Map.Entry<String, Domain> unindexDomain : originalDomainRowCol.entrySet()) {
				 Domain dm = unindexDomain.getValue();
				 dm.setIndexChanged(false);
			 }
		 }
		 
		 
		 for (Map.Entry<String, Domain> entry : collapsedDomainListSorted.entrySet()) {
			 if (entry.getValue().getName().equals(domainToUnCollapse)) {
				 colToUnCollapse  = Character.getNumericValue(entry.getKey().toCharArray()[1]);
				 domainToInsert = entry.getValue(); 
				 collapsedDomainList.remove(entry.getKey());
				 break;
			 }
		 }
		 
		 domainstoUpd.add(domainToInsert);
		 
		 for (Map.Entry<String, Domain> e : originalDomainRowCol.entrySet())
		     System.out.println("Original key value"+e.getKey()+":"+e.getValue().getName());
		 
		 int lastKeyCol = -1;
		 for (Map.Entry<String, Domain> entry : originalDomainRowCol.entrySet()) {
			 int currcol  = Character.getNumericValue(entry.getKey().toCharArray()[1]);
			 if (currcol < colToUnCollapse) {
				 for (Map.Entry<String, Domain> currDomainsEntry : currentDomainsSorted.entrySet()) {
					 if (currDomainsEntry.getValue().getName().equals(entry.getValue().getName())) {
						 updateDomains.put(currDomainsEntry.getKey(), currDomainsEntry.getValue());
						 lastKeyCol = Character.getNumericValue(currDomainsEntry.getKey().toCharArray()[1]);
						 break;
					 }
				 }	 
			} else {
				String newKey = "0"+String.valueOf(lastKeyCol+1);
				if (currcol == colToUnCollapse) {
					updateDomains.put(newKey, domainToInsert);
					++lastKeyCol;
				} else {
					for (Map.Entry<String, Domain> currDomainsEnt : currentDomainsSorted.entrySet()) {
						 if (currDomainsEnt.getValue().getName().equals(entry.getValue().getName())) {
							 updateDomains.put(newKey, currDomainsEnt.getValue());
							 domainstoUpd.add(currDomainsEnt.getValue());
							 ++lastKeyCol;
							 break;
						 }
					 }
				}
				
			}
		 }
		 
		 setNumberofColsofDomains(getNumberofColsofDomains()+1);
		 setDomainRowCol(updateDomains);
		 setCollapsedDomains(collapsedDomainList);
		 
		 for (Map.Entry<String, Domain> e : updateDomains.entrySet())
		     System.out.println("me Updatedomains key value"+e.getKey()+":"+e.getValue().getName());
		 
		 for (int i = 0; i < domainstoUpd.size(); i++) {
			Domain d = domainstoUpd.get(i);
			double newX = 0.0;
			if (i+1 < domainstoUpd.size()) 
				newX = domainstoUpd.get(i+1).getP().getX();
			else
				newX = domainstoUpd.get(i).getP().getX()+32;
				
			if (d.getName().equals("Datacenter"))
				newX+= 2;
			d.setDomainToLayoutWd(newX);
			d.computeConatinerPositions();
			for (Map.Entry<String, Container> entry1 : d.getContainerRowCol().entrySet()) {
				Container c = entry1.getValue();
				c.computeSize();
				c.computeElementPositions();
				if (c.getContainerRowCol() != null) {
					for (Map.Entry<String, Container> entryInner : c.getContainerRowCol().entrySet()) {
						Container inner = entryInner.getValue();
						inner.computeElementPositions();
					}	
				}
			}
		} 
		 
		 computeDomainPositions();
		 return this;
	
	}
	
	
	
	public Layout uncollapseDomain(String domainToCollapse) {
		 Map<String, Domain> currentDomainsSorted = new TreeMap<String,Domain>(domainRowCol);
		 Map<String, Domain> updateDomains = new TreeMap<String,Domain>();
		 Map<String, Domain> collapsedDomainList =  getCollapsedDomains();
		 Map<String, Domain> collapsedDomainListSorted =  new TreeMap<String, Domain>(collapsedDomainList);
		 
		 List<Domain> domainstoUpd = new ArrayList<Domain>();
	
		 
		 for (Map.Entry<String, Domain> entry : collapsedDomainListSorted.entrySet()) {
			 if (entry.getValue().getName().equals(domainToCollapse)) {
				 if (currentDomainsSorted != null) {
					 int colToUnCollapse  = Character.getNumericValue(entry.getKey().toCharArray()[1]);
					 for (Map.Entry<String, Domain> curr : currentDomainsSorted.entrySet()) {
						 if (Character.getNumericValue(curr.getKey().toCharArray()[1]) < colToUnCollapse) {
							updateDomains.put(curr.getKey(),curr.getValue());
						 } else {
							 updateDomains.put("0"+String.valueOf(Integer.parseInt(curr.getKey())+1),curr.getValue());
							 domainstoUpd.add(curr.getValue());
						 }
					 }
				 }	 
				 updateDomains.put(entry.getKey(), entry.getValue()); 
				 collapsedDomainList.remove(entry.getKey());
				 break;
				 
			 }
		 }
		 setNumberofColsofDomains(getNumberofColsofDomains()+1);
		 setDomainRowCol(updateDomains);
		 setCollapsedDomains(collapsedDomainList);
		 
		 for (Map.Entry<String, Domain> e : updateDomains.entrySet())
		     System.out.println("Updatedomains key value"+e.getKey()+":"+e.getValue().getName());
		 
		 
		 for (int i = 0; i < domainstoUpd.size(); i++) {
			Domain d = domainstoUpd.get(i);
			double newX = 0.0;
			if (i+1 < domainstoUpd.size()) 
				newX = domainstoUpd.get(i+1).getP().getX();
			else
				newX = domainstoUpd.get(i).getP().getX()+38;
				
			if (d.getName().equals("Datacenter"))
				newX+= 5;
			d.setDomainToLayoutWd(newX);
			d.computeConatinerPositions();
			for (Map.Entry<String, Container> entry1 : d.getContainerRowCol().entrySet()) {
				Container c = entry1.getValue();
				c.computeSize();
				c.computeElementPositions();
				if (c.getContainerRowCol() != null) {
					for (Map.Entry<String, Container> entryInner : c.getContainerRowCol().entrySet()) {
						Container inner = entryInner.getValue();
						inner.computeElementPositions();
					}	
				}
			}
		} 
		 
		 computeDomainPositions();
		 return this;
	}

	public Layout uncollapseDomainNew(String domainToUnCollapse) {
		 Map<String, Domain> currentDomainsSorted = new TreeMap<String,Domain>(domainRowCol);
		 Map<String, Domain> updateDomains = new TreeMap<String,Domain>();
		 Map<String, Domain> collapsedDomainList =  getCollapsedDomains();
		 List<Domain> domainstoUpd = new ArrayList<Domain>();
		 
		 //nline
		 List<Domain> collapsedDomainNewLL = getCollapsedDomainsNewList();
		 
		 int colToUnCollapse = 99;
		 
		 Domain domainToInsert = null;
		 
		 //nline
		 if (collapsedDomainNewLL.size() == 0) {
			 for (Map.Entry<String, Domain> unindexDomain : originalDomainRowCol.entrySet()) {
				 Domain dm = unindexDomain.getValue();
				 dm.setIndexChanged(false);
			 }
		 }
		 
		 
		 for (Map.Entry<String, Domain> entry : originalDomainRowCol.entrySet()) {
			 if (entry.getValue().getName().equals(domainToUnCollapse)) {
				 colToUnCollapse  = Character.getNumericValue(entry.getKey().toCharArray()[1]);
				 domainToInsert = entry.getValue(); 
				 collapsedDomainList.remove(entry.getKey());
				 //nline
				 collapsedDomainNewLL.remove(entry.getValue());
				 break;
			 }
		 }
		 
		 domainstoUpd.add(domainToInsert);
		 
		 for (Map.Entry<String, Domain> e : originalDomainRowCol.entrySet())
		     System.out.println("Original key value"+e.getKey()+":"+e.getValue().getName());
		 
		 int lastKeyCol = -1;
		 for (Map.Entry<String, Domain> entry : originalDomainRowCol.entrySet()) {
			 int currcol  = Character.getNumericValue(entry.getKey().toCharArray()[1]);
			 if (currcol < colToUnCollapse) {
				 for (Map.Entry<String, Domain> currDomainsEntry : currentDomainsSorted.entrySet()) {
					 if (currDomainsEntry.getValue().getName().equals(entry.getValue().getName())) {
						 updateDomains.put(currDomainsEntry.getKey(), currDomainsEntry.getValue());
						 lastKeyCol = Character.getNumericValue(currDomainsEntry.getKey().toCharArray()[1]);
						 break;
					 }
				 }	 
			} else {
				String newKey = "0"+String.valueOf(lastKeyCol+1);
				if (currcol == colToUnCollapse) {
					updateDomains.put(newKey, domainToInsert);
					++lastKeyCol;
				} else {
					for (Map.Entry<String, Domain> currDomainsEnt : currentDomainsSorted.entrySet()) {
						 if (currDomainsEnt.getValue().getName().equals(entry.getValue().getName())) {
							 updateDomains.put(newKey, currDomainsEnt.getValue());
							 domainstoUpd.add(currDomainsEnt.getValue());
							 ++lastKeyCol;
							 break;
						 }
					 }
				}
				
			}
		 }
		 
		setNumberofColsofDomains(getNumberofColsofDomains()+1);
		setDomainRowCol(updateDomains);
		 
		for (Map.Entry<String, Domain> e : updateDomains.entrySet())
			System.out.println("me Updatedomains key value"+e.getKey()+":"+e.getValue().getName());
		 
		
		 
		double currDistFromLftMargin = 11.0;
		for (Map.Entry<String,Domain> cd : updateDomains.entrySet()) {
			Domain d = cd.getValue();
			double accountPlus = accountForPlusSpaceBefore(d);
			d.setDomainToLayoutWd(currDistFromLftMargin+accountPlus);
			d.computeConatinerPositions();
			for (Map.Entry<String, Container> entry1 : d.getContainerRowCol().entrySet()) {
				Container c = entry1.getValue();
				c.computeSize();
				c.computeElementPositions();
				if (c.getContainerRowCol() != null) {
					for (Map.Entry<String, Container> entryInner : c.getContainerRowCol().entrySet()) {
						Container inner = entryInner.getValue();
						inner.computeElementPositions();
					}	
				}
			}
			currDistFromLftMargin += d.computeSize().getWidth()+2;
		
		}
		
		 //nline
		updatePlusPosition(collapsedDomainNewLL, updateDomains);
		
		 //order changed
		setCollapsedDomains(collapsedDomainList);
		 
		 //nline
		setCollapsedDomainsNewList(collapsedDomainNewLL);
		
		
		computeDomainPositionsModified();
		return this;
		
	}	
		
	public Layout uncollapseDomainNew1(String domainToUnCollapse) {
		
		 if(domainToUnCollapse == null || domainToUnCollapse.isEmpty())
			   return null;
		 
		 Map<String, Domain> currentDomainsSorted = new TreeMap<String,Domain>(domainRowCol);
		 Map<String, Domain> updateDomains = new TreeMap<String,Domain>();
		 Map<String, Domain> collapsedDomainList =  getCollapsedDomains();
		 List<Domain> domainstoUpd = new ArrayList<Domain>();
		 
		 //nline
		 List<Domain> collapsedDomainNewLL = getCollapsedDomainsNewList();
		 
		 int colToUnCollapse = 99;
		 
		 Domain domainToInsert = null;
		 
		 //nline
		 if (collapsedDomainNewLL.size() == 0) {
			 for (Map.Entry<String, Domain> unindexDomain : originalDomainRowCol.entrySet()) {
				 Domain dm = unindexDomain.getValue();
				 dm.setIndexChanged(false);
			 }
		 }
		 
		 
		 for (Map.Entry<String, Domain> entry : originalDomainRowCol.entrySet()) {
			 if (entry.getValue().getName().equals(domainToUnCollapse)) {
				 colToUnCollapse  = Character.getNumericValue(entry.getKey().toCharArray()[1]);
				 domainToInsert = entry.getValue(); 
				 collapsedDomainList.remove(entry.getKey());
				 //nline
				 collapsedDomainNewLL.remove(entry.getValue());
				 break;
			 }
		 }
		 
		 domainstoUpd.add(domainToInsert);
		 
		 for (Map.Entry<String, Domain> e : originalDomainRowCol.entrySet())
		     System.out.println("Original key value"+e.getKey()+":"+e.getValue().getName());
		 
		 int lastKeyCol = -1;
		 for (Map.Entry<String, Domain> entry : originalDomainRowCol.entrySet()) {
			 int currcol  = Character.getNumericValue(entry.getKey().toCharArray()[1]);
			 if (currcol < colToUnCollapse) {
				 for (Map.Entry<String, Domain> currDomainsEntry : currentDomainsSorted.entrySet()) {
					 if (currDomainsEntry.getValue().getName().equals(entry.getValue().getName())) {
						 updateDomains.put(currDomainsEntry.getKey(), currDomainsEntry.getValue());
						 lastKeyCol = Character.getNumericValue(currDomainsEntry.getKey().toCharArray()[1]);
						 break;
					 }
				 }	 
			} else {
				String newKey = "0"+String.valueOf(lastKeyCol+1);
				if (currcol == colToUnCollapse) {
					updateDomains.put(newKey, domainToInsert);
					++lastKeyCol;
				} else {
					for (Map.Entry<String, Domain> currDomainsEnt : currentDomainsSorted.entrySet()) {
						 if (currDomainsEnt.getValue().getName().equals(entry.getValue().getName())) {
							 updateDomains.put(newKey, currDomainsEnt.getValue());
							 domainstoUpd.add(currDomainsEnt.getValue());
							 ++lastKeyCol;
							 break;
						 }
					 }
				}
				
			}
		 }
		 
		setNumberofColsofDomains(getNumberofColsofDomains()+1);
		setDomainRowCol(updateDomains);
		 
		for (Map.Entry<String, Domain> e : updateDomains.entrySet())
			System.out.println("me Updatedomains key value"+e.getKey()+":"+e.getValue().getName());
		 
		
		 
		
		double currDistFromLftM = 11.0;
		
		boolean isDisplayed;
		for (Map.Entry<String,Domain> orgEntry : originalDomainRowCol.entrySet()) {
			isDisplayed = false;
			for (Map.Entry<String,Domain> cd : updateDomains.entrySet()) {
				if (cd.getValue().getName().equals(orgEntry.getValue().getName())) {
					Domain d = cd.getValue();
					d.setDomainToLayoutWd(currDistFromLftM);
					d.computeConatinerPositions();
					for (Map.Entry<String, Container> entry1 : d.getContainerRowCol().entrySet()) {
						Container c = entry1.getValue();
						c.computeSize();
						c.computeElementPositions();
						if (c.getContainerRowCol() != null) {
							for (Map.Entry<String, Container> entryInner : c.getContainerRowCol().entrySet()) {
								Container inner = entryInner.getValue();
								inner.computeElementPositions();
							}	
						}
					}
					currDistFromLftM += d.computeSize().getWidth()+1;
					isDisplayed = true;
					break;
				}
			}
		
			if (!isDisplayed) {
				Domain myCollapsed = orgEntry.getValue(); 
				myCollapsed.setNewXafterColl(currDistFromLftM);
				currDistFromLftM += 4;
			}
		}
		
		
		//order changed
		setCollapsedDomains(collapsedDomainList);
		 
		 //nline
		setCollapsedDomainsNewList(collapsedDomainNewLL);
		
		
		computeDomainPositionsModified();
		return this;
		
	}	
	
	private void updatePlusPosition(List<Domain> collapsedDNewL, Map<String, Domain> displayedDomainMap) {
		List<Domain> copyCollapseList = new ArrayList<Domain>(); 
		
		for (Domain copyCollapse : collapsedDNewL) {
			copyCollapseList.add(copyCollapse);
		}
		
		int orgColofCollapsed = -1;
		int orgColofDisplayed = -1;
		int orgColofDisplayedOtherPlus = -1;
		for (Domain plus : collapsedDNewL) {
			double distOfCollFrmLft = 0.0;
			for (Map.Entry<String, Domain> colCheck : originalDomainRowCol.entrySet()) {
				if (colCheck.getValue().getName().equals(plus.getName())) {
					orgColofCollapsed = Character.getNumericValue(colCheck.getKey().toCharArray()[1]);
					break;		
				}
			}
			for (Map.Entry<String, Domain> displayedEntry : displayedDomainMap.entrySet()) {
				
				for (Map.Entry<String, Domain> colCheck1 : originalDomainRowCol.entrySet()) {
					if (colCheck1.getValue().getName().equals(displayedEntry.getValue().getName())) {
						orgColofDisplayed = Character.getNumericValue(colCheck1.getKey().toCharArray()[1]);
						break;		
					}
				}
				if (orgColofDisplayed < orgColofCollapsed) {
					distOfCollFrmLft+= displayedEntry.getValue().computeSize().getWidth();
				
				}
				
			}
			
			for (Domain collp : copyCollapseList) {
				if (!collp.getName().equals(plus.getName())) {
					for (Map.Entry<String, Domain> colCheck2 : originalDomainRowCol.entrySet()) {
						if (colCheck2.getValue().getName().equals(collp.getName())) {
							orgColofDisplayedOtherPlus = Character.getNumericValue(colCheck2.getKey().toCharArray()[1]);
							break;		
						}
					}
					if (orgColofDisplayedOtherPlus < orgColofCollapsed) {
						distOfCollFrmLft+=3.0;
					}
				}
			}
			
			plus.setNewXafterColl(distOfCollFrmLft+1.5);
			
		
		}
	}
	

	private double accountForPlusSpaceBefore(Domain d) {
		
		int orgColofCollapsed = 0;
		int orgColofDisplayed = 0; 
		double distFromLftM = 0.0;
		
		for (Map.Entry<String, Domain> colCheckk : originalDomainRowCol.entrySet()) {
			if (colCheckk.getValue().getName().equals(d.getName())) {
				orgColofDisplayed = Character.getNumericValue(colCheckk.getKey().toCharArray()[1]);
				break;		
			}
		}
		
		for (Domain collapsed :  getCollapsedDomainsNewList()) {
			for (Map.Entry<String, Domain> colCheck : originalDomainRowCol.entrySet()) {
				if (colCheck.getValue().getName().equals(collapsed.getName())) {
					orgColofCollapsed = Character.getNumericValue(colCheck.getKey().toCharArray()[1]);
					break;		
				}
			}
			
			if (orgColofCollapsed < orgColofDisplayed) {
				distFromLftM+= 2;
			}
		}
		return distFromLftM;
	
	}
	
}