/***
    * @version $Revision: 1.6 $
    */
   package uba.db.sql.interpreter;
   
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.Iterator;
   import java.util.List;
  
  import uba.db.Database;
  import uba.db.ar.Cartesiano;
  import uba.db.ar.ConditionEvaluator;
  import uba.db.ar.Proyector;
  import uba.db.ar.ProyectorParameter;
  import uba.db.ar.Seleccion;
  import uba.db.ar.Tupla;
  import uba.db.ar.TuplaDef;
  import uba.db.ar.TupleProvider;
  import uba.db.column.Column;
  import uba.db.sql.language.Select;
  import uba.db.sql.language.SelectionCriteria;
  import uba.db.sql.language.TableName;
  import uba.db.table.Table;
  
  public class SelectQueryPlan implements SentenceQueryPlan {
  
  	private List tables;
  
  	private List columnsToProject;
  
  	private List columnsToEvaluate;
  
  	private Select sentence;
  
  	private SelectionCriteria selectionCriteria;
  
  	private TupleProvider executionResult;
  
  	private String planDetail;
  
  	private Database database;
  
  	public SelectQueryPlan(Select sqlSentence, Database database) {
  		tables = new ArrayList();
  		columnsToProject = new ArrayList();
  		columnsToEvaluate = new ArrayList();
  		sentence = sqlSentence;
  		selectionCriteria = sqlSentence.criteria();
  		this.database = database;
  		planDetail = "";
  	}
  
  	/*
  	 * @see uba.db.sql.interpreter.SentenceQueryPlan#startExecution(uba.db.sql.language.Sentence)
  	 */
  	public void startExecution() {
  		sentence.source().accept(new TablesToJoinVisitor(this, database));
  		sentence.displayColumns().accept(new ColumnsToProjectVisitor(this));
  		sentence.criteria().accept(new ColumnsToEvaluateVisitor(this));
  
  		TupleProvider combinedTables = combine(tables);
  		TupleProvider selectedTuples = filter(combinedTables);
  		executionResult = project(selectedTuples);
  	}
  
  	public void addTable(Table table) {
  		tables.add(table);
  	}
  
  	private TupleProvider combineSigleTable(List tableNames) {
  		Table table = (Table) tables.get(0);
  		TupleProvider tupleProvider = new TableToTupleProviderAdapter(table);
  		planDetail += "Scan " + table.name() + "\t";
  		return tupleProvider;
  	}
  
  	private TupleProvider combineMultipleTables(List tableNames) {
  		Iterator it = tableNames.iterator();
  		Table firstTable = (Table) it.next();
  		TupleProvider combinedTable = new TableToTupleProviderAdapter(
  				firstTable);
  		Table nextTable;
  		TupleProvider nextTupleProvider;
  		planDetail += "Scan " + firstTable.name() + "\t";
  		while (it.hasNext()) {
  			nextTable = (Table) it.next();
  			planDetail += "Scan " + nextTable.name() + "\t";
  			nextTupleProvider = new TableToTupleProviderAdapter(nextTable);
  			combinedTable = new Cartesiano(combinedTable, nextTupleProvider);
  			planDetail += "Producto cartesiano " + combinedTable.toString()
  					+ "\t";
  		}
  		return combinedTable;
  	}
  
  	/***
  	 * Projecta. ES NECESARIO QUE EL ASTERISCO (*) SEA INTERPRETADO COMO "TODAS
  	 * LAS COLUMNAS"
 	 */
 	private TupleProvider project(TupleProvider tp) {
 		if (columnsToProject.isEmpty())
 			return tp;
 		else {
 			List indices = averiguarIndices();
 			planDetail += "Proyeccion " + columnsToProject.toString() + "\t";
 			return new Proyector(new ProyectorParameter(indices), tp);
 		}
 	}
 
 	/***
 	 * @todo mejorar esta manera de detectar el null
 	 */
 	private TupleProvider filter(TupleProvider tp) {
 		if (selectionCriteria.not() == selectionCriteria)
 			return tp;
 		else {
 			planDetail += "Filter " + selectionCriteria.toString() + "\t";
 			return filtered(tp);
 		}
 	}
 
 	public List tables() {
 		return tables;
 	}
 
 	private TupleProvider combine(List tableNames) {
 		if (tableNames.size() > 1)
 			return combineMultipleTables(tableNames);
 		else
 			return combineSigleTable(tableNames);
 	}
 
 	public Tupla nextTuple() {
 		return executionResult.next();
 	}
 
 	public String planDetail() {
 		return planDetail;
 	}
 
 	public boolean hasMoreResults() {
 		return executionResult.hasNext();
 	}
 
 	public void addColumnToProject(Column column) {
 		columnsToProject.add(column);
 	}
 
 	public Table tableNamed(TableName tableName) {
 		Iterator iterator = tables.iterator();
 		Table table = null;
 
 		while (iterator.hasNext() && table == null) {
 			Table eachTable = (Table) iterator.next();
 			if (eachTable.name().equalsIgnoreCase(tableName.toString())) {
 				table = eachTable;
 
 			}
 		}
 		return table;
 
 	}
 
 	private List averiguarIndices() {
 		Iterator iterator = columnsToProject.iterator();
 		List indices = new ArrayList();
 		while (iterator.hasNext()) {
 			Column column = (Column) iterator.next();
 			int index = column.table().indexOfColumnNamed(column.name());
 			int fieldsBefore = fieldsBeforeTableAt(indexOfTableOf(column
 					.table()));
 			indices.add(new Integer(fieldsBefore + index));
 		}
 		return indices;
 	}
 
 	private HashMap qualifiedColumnIndexes() {
 		Iterator iterator = columnsToEvaluate.iterator();
 		HashMap indexes = new HashMap();
 		while (iterator.hasNext()) {
 			Column column = (Column) iterator.next();
 			int index = column.table().indexOfColumnNamed(column.name());
 			int fieldsBefore = fieldsBeforeTableAt(indexOfTableOf(column
 					.table()));
 			indexes.put(column.table().name() + column.name(), new Integer(
 					fieldsBefore + index));
 		}
 		return indexes;
 	}
 
 	private int fieldsBeforeTableAt(int i) {
 		Table table;
 		int c;
 		c = 0;
 		for (int j = 0; j < i; j++) {
 			table = (Table) tables.get(j);
 			c += table.columns().size();
 		}
 		return c;
 	}
 
 	private int indexOfTableOf(Table table) {
 		return tables.indexOf(table);
 	}
 
 	private TupleProvider filtered(TupleProvider tp) {
 		HashMap indexes = qualifiedColumnIndexes();
 		ConditionEvaluator evaluator = new ConditionEvaluator(
 				selectionCriteria, indexes);
 		return new Seleccion(tp, evaluator);
 	} /*
 	   * @see uba.db.sql.interpreter.SentenceQueryPlan#tuplaDefinition()
 	   */
 
 	public TuplaDef tuplaDefinition() {
 		return executionResult.tupleDefinition();
 	}
 
 	public void addColumnToEvaluate(Column column) {
 		columnsToEvaluate.add(column);
 	}
 
 }