/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.apache.tuscany.sca.impl.layout;

public class LayoutBuilder {

	private Entity[] elts = null;
	private int[][] conns = null;
	private Entity startEnt = null;
	private int currentMaxLevel= 0;
	
	/**
	 * Constructor which takes set of entities and their connection matrix
	 */
	public LayoutBuilder(Entity[] entities, int[][] connections){
		elts = entities;
		conns = connections;
	}

	/**
	 * Layout Building Algorithm
	 * ~~~~~~~~~~~~~~~~~~~~~~~~~
	 *
	 * Here we position (i.e. assigning a level and a lane) all Entities
	 * in a unique cell of a grid.
	 * 
	 * 		 	lane0	  lane1	  lane2	  lane3 ....
	 * 		 	 _______________________________
	 * level0	|		|		|		|		|
	 * 			|_______|_______|_______|_______|
	 * level1	|		|		|		|		|
	 * 			|_______|_______|_______|_______|
	 * level2	|		|		|		|		|     
	 * 
	 * 1) Determining the Entity at level0, lane0 (starting entity)
	 * 		-First Entity in the list of Entities which has one or more adjacent Entities
	 * 		-If there is only one Entity it will eventually chosen
	 * 
	 * 2) Get connected Entities of starting Entity. 
	 * 		* If there are connected entities;
	 * 			*For each connected Entity; 
	 * 				*We assign a corresponding level and a lane
	 * 				*Then recurse the procedure for connections of the assigned Entity
	 * 	
	 * 
	 */
	public Entity[] placeEntities(){
		
		/**
		 * Finding the starting entity
		 */
		for(int i = 0 ; i < elts.length; i++) {
			//System.out.println("ELts "+elts.length);
			Entity ent = elts[i];
			if( isConnected(ent.getId()) ){
				setPosition(ent, 0, 0);
				startEnt = ent;
				//System.out.println("startEnt "+ent.getId());
				break;
			}
			
		}
		
		if(startEnt!=null){
			assignPositions(startEnt);
		}
		
		assignPositionsOfOtherConncetedEntities();//such as a different cluster of components
		assignPositionsOfIdleEntities();
		assignCoordinates();
		
		return elts;

	}
	
	private void assignPositionsOfIdleEntities() {

		for(Entity ent: elts){
			if(!ent.isPossitionSet()){
				
				setPosition(ent, currentMaxLevel++, 0);
			}
		}
	}
		
	private void assignPositionsOfOtherConncetedEntities() {

		for(Entity ent: elts){
			if(!ent.isPossitionSet() && isConnected(ent.getId())){
				assignPositions(ent);
			}
		}
	}

	private void assignCoordinates() {

		for(Entity ent: elts){
			ent.setX(ent.getParent().getX() + ent.getStartPosition());
			ent.setY(ent.getParent().getY() + ent.getStartPosition()/2);
		}
	}

	private void assignPositions(Entity ent) {
		int id = ent.getId();
		int[] entConns = conns[id];
		
		for(int i=0; i<entConns.length; i++){
			if( entConns[i] == 1 ){
				Entity nextEnt = findEntity(i);
				
//				if(nextEnt.isPossitionSet()){
//					currentMaxLevel = nextEnt.getLevel()+1; // for diagram clearness purpose
//				}
				if(nextEnt != null && !nextEnt.isPossitionSet()){
					setPosition(nextEnt, currentMaxLevel, ent.getLane()+1);
					assignPositions(nextEnt);
				}
			}
			
		}
		currentMaxLevel = ent.getLevel()+1;
	}

	private Entity findEntity(int i) {

		for(Entity ent: elts){
			if(ent.getId() == i){
				return ent;
			}
		}
		return null;
	}

	/**
	 * If there's at least 1 connection, this will return true
	 */
	private boolean isConnected(int id) {
		int[] entConns = conns[id];
		
		//System.out.println("entConns "+entConns.length);
		for(int i=0; i<entConns.length; i++){
			
			if(entConns[i] == 1){
				return true;
			}
			
		}
		
		return false;
	}

	private void setPosition(Entity ent, int level, int lane){
		ent.setLevel(level);
		ent.setLane(lane);
		ent.setPossitionSet(true);
	}

	public Entity getStartEnt() {
		return startEnt;
	}

	public void setStartEnt(Entity startEnt) {
		this.startEnt = startEnt;
	}

}