/*
    * This file is a part of CAST project.
    * (c) Copyright 2007, AGH University of Science & Technology
    * https://caribou.iisg.agh.edu.pl/trac/cast
    *
    * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/legal/epl-v10.html
   */
  /*
   * File: BrokenDataInfo.java
   * Created: 2008-04-07
   * Author: entrop, kpietak
   * $Id: BrokenDataInfo.java 2331 2009-01-13 12:56:25Z kpietak $
   */
  
  package pl.edu.agh.cast.rawdata.stat;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import org.apache.log4j.Logger;
  import org.eclipse.core.runtime.Assert;
  
  import pl.edu.agh.cast.model.base.BasePlugin;
  import pl.edu.agh.cast.rawdata.DataRow;
  import pl.edu.agh.cast.rawdata.TabularData;
  import pl.edu.agh.cast.rawdata.logging.IRawDataMonitorable;
  import pl.edu.agh.cast.rawdata.logging.IRawDataObserver;
  
  /**
   * Class which represents information about broken data in TabularData object. It contains list of DataRow objects
   * mapped to corresponding BrokenRowInfo objects.
   * 
   * It contains statistics after data validation: all rows number, errors number, error rows number, etc. It is returned
   * as a result of <code>DataLoaderWithStatistics.validate()</code> method.
   * 
   * @author AGH CAST Team
   * 
   *         TODO: add handling broken cell list
   */
  public class BrokenDataInfo implements IRawDataMonitorable {
  
  	private static Logger log = BasePlugin.getLogger();
  
  	private Map<DataRow, BrokenRowInfo> brokenRows;
  
  	private TabularData inputData;
  
  	// used for performance improvements
  	private List<BrokenCellInfo> brokenCells;
  
  	private Map<ErrorType, List<BrokenCellInfo>> errorTypeToBrokenCells;
  
  	// removed data
  	private Map<Integer, BrokenRowInfo> rowNumberToRemovedRowInfo;
  
  	private Map<Integer, DataRow> rowNumberToRemovedDataRow;
  
  	// observers
  	private List<IRawDataObserver> observers;
  
  	/**
  	 * Default constructor. Creates an instance associated with specified TabularData object.
  	 * 
  	 * @param inputData
  	 *            TabularData which will be described by created object.
  	 */
  	public BrokenDataInfo(TabularData inputData) {
  		this.brokenRows = new HashMap<DataRow, BrokenRowInfo>();
  		this.brokenCells = new LinkedList<BrokenCellInfo>();
  		this.errorTypeToBrokenCells = new HashMap<ErrorType, List<BrokenCellInfo>>();
  		this.inputData = inputData;
  		this.observers = new LinkedList<IRawDataObserver>();
  
  		rowNumberToRemovedRowInfo = new HashMap<Integer, BrokenRowInfo>();
  		rowNumberToRemovedDataRow = new HashMap<Integer, DataRow>();
  	}
  
  	/**
  	 * Adds information about broken row in TabularData. Updates cache information about cell which contains errors or
  	 * warnings & registers observer on source row.
  	 * 
  	 * @param brokenRowInfo
  	 *            information about broken row to be added to data info object
  	 */
  	public void addBrokenRowInfo(BrokenRowInfo brokenRowInfo) {
  		brokenRows.put(brokenRowInfo.getSourceRow(), brokenRowInfo);
  		List<BrokenCellInfo> cells = brokenRowInfo.getBrokenCells();
  		for (BrokenCellInfo cell : cells) {
  			brokenCells.add(cell);
  			ErrorType errorType = cell.getErrorInfo().getType();
  			if (!errorTypeToBrokenCells.containsKey(errorType)) {
 				errorTypeToBrokenCells.put(errorType, new LinkedList<BrokenCellInfo>());
 			}
 			errorTypeToBrokenCells.get(errorType).add(cell);
 		}
 
 		// register observers
 		for (IRawDataObserver observer : observers) {
 			brokenRowInfo.getSourceRow().registerObserver(observer);
 		}
 	}
 
 	/**
 	 * Removed the specified row. If row has associated BrokenRowInfo object, method <code>removeBrokenRowInfo</code> is
 	 * called, otherwise row is removed straightforward from data. The deleted row is cached and can be restored using
 	 * method <code>restoreDataRow</code>
 	 * 
 	 * @param row
 	 *            row to be deleted
 	 * @return broken row info associated with row or null if no such object
 	 */
 	public BrokenRowInfo removeDataRow(DataRow row) {
 		BrokenRowInfo brokenRowInfo = getBrokenRowInfo(row);
 		if (brokenRowInfo != null) { // row contains errors or warnings
 			return removeBrokenRowInfo(brokenRowInfo, true);
 		}
 		// remove correct row
 		inputData.removeRow(row);
 		rowNumberToRemovedDataRow.put(row.getRowNumber(), row);
 
 		return null;
 
 	}
 
 	/**
 	 * Returns list of <code>BrokenCellInfo</code> related to input row.
 	 * 
 	 * @param row
 	 *            data row
 	 * @return list of BrokenCellInfo objects related to the specified row.
 	 */
 	public List<BrokenCellInfo> getBrokenCellsRelatedTo(DataRow row) {
 		List<BrokenCellInfo> relatedRows = new ArrayList<BrokenCellInfo>();
 		for (BrokenCellInfo cellInfo : brokenCells) {
 			DataRow related = cellInfo.getErrorInfo().getRelatedRow();
 			if (related == row) {
 				relatedRows.add(cellInfo);
 			}
 		}
 
 		return relatedRows;
 	}
 
 	/**
 	 * Removes row specified by specified <code>BrokenRowInfo</code> object. The source object is deleted from
 	 * TabularData. The broken row info object is cached for undo action.
 	 * 
 	 * @param brokenRowInfo
 	 *            broken row info object which indicated which row should be deleted.
 	 * 
 	 */
 	public void removeBrokenRowInfo(final BrokenRowInfo brokenRowInfo) {
 		removeBrokenRowInfo(brokenRowInfo, true);
 	}
 
 	private BrokenRowInfo removeBrokenRowInfo(final BrokenRowInfo brokenRowInfo, boolean deleteSourceRow) {
 		if (brokenRowInfo != null) {
 			if (deleteSourceRow) {
 				// remove data row
 				inputData.removeRow(brokenRowInfo.getSourceRow());
 			}
 			// remove broken row info
 			for (BrokenCellInfo brokenCellInfo : brokenRowInfo.getBrokenCells()) {
 				brokenCells.remove(brokenCellInfo);
 				errorTypeToBrokenCells.get(brokenCellInfo.getErrorInfo().getType()).remove(brokenCellInfo);
 
 			}
 			brokenRows.remove(brokenRowInfo.getSourceRow());
 
 			// save in cache (for restoring)
 			rowNumberToRemovedRowInfo.put(new Integer(brokenRowInfo.getSourceRow().getRowNumber()), brokenRowInfo);
 		}
 		return brokenRowInfo;
 
 	}
 
 	/**
 	 * Restores row with specified row number. The restored row is placed at the beginning of rows in tabular data.
 	 * 
 	 * @param rowNumber
 	 *            row number to be restored
 	 * @return restored broken row info, null if no row has been restored or if restored row was without broken row
 	 *         info.
 	 */
 	public BrokenRowInfo restoreDataRow(int rowNumber) {
 		Integer rowNumberL = new Integer(rowNumber);
 		BrokenRowInfo res = rowNumberToRemovedRowInfo.get(rowNumberL);
 
 		if (res != null) {
 			// add source row
 			inputData.restoreAsFirst(res.getSourceRow());
 			addBrokenRowInfo(res);
 			rowNumberToRemovedRowInfo.remove(rowNumberL);
 		} else {
 			DataRow row = rowNumberToRemovedDataRow.remove(rowNumberL);
 			if (row != null) {
 				inputData.restoreAsFirst(row);
 			}
 		}
 
 		return res;
 	}
 
 	/**
 	 * Replaces information about data row which is in newValue object. Updates statistics.
 	 * 
 	 * @param row
 	 *            row with errors or warnings which broken info will be replaced
 	 * @param newValue
 	 *            value new broken row info; if <code>null</code> the method is equal to
 	 *            <code>removeBrokenRowInfo(_brokenRows.get(row))</code>
 	 */
 	public void replaceBrokenRowInfo(DataRow row, BrokenRowInfo newValue) {
 		removeBrokenRowInfo(brokenRows.get(row), false);
 		if (newValue != null) {
 			addBrokenRowInfo(newValue);
 		}
 	}
 
 	/**
 	 * Returns list of all broken cells. Doesn't omit cells which row is marked as deleted.
 	 * 
 	 * @return unmodifiable list of broken cells
 	 */
 	public List<BrokenCellInfo> getBrokenCells() {
 		return Collections.unmodifiableList(brokenCells);
 	}
 
 	/**
 	 * Returns broken row info associated with the specified row.
 	 * 
 	 * @param row
 	 *            data row object
 	 * @return broken row info associated with the specified row
 	 */
 	public BrokenRowInfo getBrokenRowInfo(DataRow row) {
 		return brokenRows.get(row);
 	}
 
 	/**
 	 * Gets returns type mapped to number of occurrences in associated TabularData object.
 	 * 
 	 * @return map which contains error types with number of occurrences
 	 */
 	public Map<ErrorType, Integer> getErrorTypesWithOccurrences() {
 		Map<ErrorType, Integer> res = new HashMap<ErrorType, Integer>();
 		Set<ErrorType> keySet = errorTypeToBrokenCells.keySet();
 
 		for (ErrorType key : keySet) {
 			res.put(key, getErrorsCountByType(key));
 		}
 
 		return res;
 	}
 
 	/**
 	 * Returns list of <code>BrokenCellInfo</code> objects which are not removed.
 	 * 
 	 * @param errorType
 	 *            type of error
 	 * @return list of broken cell info objects
 	 */
 	public List<BrokenCellInfo> getBrokenCellsByType(ErrorType errorType) {
 		return errorTypeToBrokenCells.get(errorType);
 	}
 
 	public int getErrorsCount() {
 		return getBrokenCellsCountBySeverity(ErrorSeverity.ERROR);
 	}
 
 	public int getWarningsCount() {
 		return getBrokenCellsCountBySeverity(ErrorSeverity.WARNING);
 	}
 
 	public int getBrokenRowsCount() {
 		return brokenRows.values().size();
 	}
 
 	public int getRowsCount() {
 		return inputData.getAllRows().size();
 	}
 
 	/**
 	 * Gets errors count for given error type
 	 * 
 	 * @param errorType
 	 *            error type
 	 * @return number of occurrences of given error type
 	 */
 	int getErrorsCountByType(ErrorType errorType) {
 		List<BrokenCellInfo> cells = errorTypeToBrokenCells.get(errorType);
 		if (cells != null) {
 			return cells.size();
 		}
 		return 0;
 	}
 
 	private int getBrokenCellsCountBySeverity(ErrorSeverity severity) {
 		int res = 0;
 		for (ErrorType errorType : errorTypeToBrokenCells.keySet()) {
 			if (errorType.getSeverity().equals(severity)) {
 				res += errorTypeToBrokenCells.get(errorType).size();
 			}
 		}
 		return res;
 	}
 
 	/**
 	 * 
 	 * {@inheritDoc}
 	 * 
 	 * @see pl.edu.agh.cast.rawdata.logging.IRawDataMonitorable#
 	 *      registerObserver(pl.edu.agh.cast.rawdata.logging.IRawDataObserver)
 	 * 
 	 */
 	public void registerObserver(IRawDataObserver observer) {
 		Assert.isNotNull(observer, "Cannot register null value register"); //$NON-NLS-1$
 		if (!observers.contains(observer)) {
 			observers.add(observer);
 			log.debug("The following observer has been registered: " //$NON-NLS-1$
 			        + observer.toString());
 
 			Set<DataRow> rows = brokenRows.keySet();
 
 			for (DataRow row : rows) {
 				row.registerObserver(observer);
 			}
 		}
 	}
 
 	/**
 	 * 
 	 * {@inheritDoc}
 	 * 
 	 * @see pl.edu.agh.cast.rawdata.logging.IRawDataMonitorable#
 	 *      unregisterObserver(pl.edu.agh.cast.rawdata.logging.IRawDataObserver)
 	 */
 	public void unregisterObserver(IRawDataObserver observer) {
 		Assert.isNotNull(observer, "Cannot unregister null value register"); //$NON-NLS-1$
 		if (observers.contains(observer)) {
 			observers.remove(observer);
 			Set<DataRow> rows = brokenRows.keySet();
 
 			for (DataRow row : rows) {
 				row.unregisterObserver(observer);
 			}
 
 			log.debug("The following observer has been unregistered: " //$NON-NLS-1$
 			        + observer.toString());
 		}
 
 	}
 
 }