/*
    *  Copyright (C) 2003-2005 SINTEF
    *  Author:  Fredrik Vraalsen (fredrik dot vraalsen at sintef dot no)
    *  Webpage: http://coras.sourceforge.net/
    *
    *  This program is free software; you can redistribute it and/or
    *  modify it under the terms of the GNU Lesser General Public License
    *  as published by the Free Software Foundation; either version 2.1
    *  of the License, or (at your option) any later version.
   *
   *  This program is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   *  Lesser General Public License for more details.
   *
   *  You should have received a copy of the GNU Lesser General Public
   *  License along with this program; if not, write to the Free
   *  Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   *  02111-1307 USA
   */
  package coras.table;
  
  import java.beans.PropertyChangeListener;
  import java.beans.PropertyChangeSupport;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import javax.swing.table.AbstractTableModel;
  
  import no.sintef.xml.XmlHelper;
  
  import org.apache.log4j.Logger;
  
  import coras.table.columnchoices.jaxb.ChoiceType;
  import coras.table.columnchoices.jaxb.ColumnChoicesType;
  import coras.table.columnchoices.jaxb.ColumnType;
  import coras.table.jaxb.CellType;
  import coras.table.jaxb.ColumnDefType;
  import coras.table.jaxb.RowType;
  import coras.table.jaxb.TableType;
  import coras.table.jaxb.impl.CellTypeImpl;
  import coras.table.jaxb.impl.ColumnDefTypeImpl;
  import coras.table.jaxb.impl.RowTypeImpl;
  
  /***
   * @author fvr
   *
   * To change the template for this generated type comment go to
   * Window - Preferences - Java - Code Generation - Code and Comments
   */
  public class CorasTableModel extends AbstractTableModel {
  	
  	public static final String DIRTY = "dirty";
  	private static final Logger LOGGER = Logger.getLogger(CorasTableModel.class);
  
  	private TableType table = null;
  	private Map columnChoicesMap = new HashMap();
  
  	private boolean dirty = false;
  	private PropertyChangeSupport propertyChangeHandler = new PropertyChangeSupport(this);
  	
  	public TableType getTable() {
  		return table;
  	}
  	
  	public void setTable(TableType table) {
  		this.table = table;
  		fireTableChanged(null);
  	}
  	
  	public boolean isFixedStructure() {
  		return table == null || table.isFixedStructure();
  	}
  	
  	public boolean isDirty() {
  		return dirty;
  	}
  
  	private void setDirty(boolean newDirty) {
  		boolean oldDirty = dirty;
  		dirty = newDirty;
  		if (oldDirty != newDirty) {
  			propertyChangeHandler.firePropertyChange(DIRTY, oldDirty, newDirty);
  		}
  	}
  	
  	public void makeClean() {
  		setDirty(false);
  	}
  	
  	private void makeDirty() {
  		setDirty(true);
  	}
  	
  	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#getColumnCount()
 	 */
 	public int getColumnCount() {
 		if (table == null) {
 			return 0;
 		} else {
 			return getVisibleColumnDefs().size();
 		}
 	}
 	
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#getRowCount()
 	 */
 	public int getRowCount() {
 		if (table == null) {
 			return 0;
 		} else {
 			return table.getRows().getRow().size();
 		}
 	}
 	
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#getValueAt(int, int)
 	 */
 	public Object getValueAt(int rowIndex, int columnIndex) {
 		CellType cell = getCell(rowIndex, columnIndex);
 		if (cell != null)
 			return cell.getValue(); // TODO: clone!? Otherwise content may be changed but model remain clean?
 		else
 			return "";
 	}
 	
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#getColumnName(int)
 	 */
 	public String getColumnName(int columnIndex) {
 		if (table == null) {
 			return null;
 		}
 
 		ColumnDefType columnDef = getColumnDef(columnIndex);
 		if (columnDef == null) {
 			return null;
 		}
 
 		// Attemt to first look up externalized column name,
 		// fall back to column name defined in table.
 		String tableType = getTable().getType();
 		String columnId = columnDef.getId();
 		String key = tableType.replaceAll("//s", "_") + "." + columnId; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
 		String name = Messages.getColumnName(key);
 		if (name.equals('!' + key + '!')) {
 			key = columnId;
 			name = Messages.getColumnName(key);
 		}
 		if (name.equals('!' + key + '!')) {
 			name = null;
 		}
 		if (name != null) {
 			return name;
 		} else {
 			return columnDef.getName();
 		}
 	}
 
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#getColumnName(int)
 	 */
 	public String getColumnDescription(int columnIndex) {
 		if (table == null) {
 			return null;
 		}
 
         // Attempt to get column description.
         // First look for table type + column ID, then only column ID
 		String tableType = getTable().getType();
         String columnId = getColumnId(columnIndex);
 		String key = tableType.replaceAll("//s", "_") + "." + columnId; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
 		String description = Messages.getColumnDescription(key);
         if (description.equals('!' + key + '!')) {
         	key = columnId;
         	description = Messages.getColumnDescription(key);
         }
         if (description.equals('!' + key + '!')) {
         	description = null;
         }
         return description;
 	}
 	
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#getColumnClass(int)
 	 */
 	public Class getColumnClass(int columnIndex) {
 		return String.class;
 	}
 
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#setValueAt(java.lang.Object, int, int)
 	 */
 	public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
 		if (aValue instanceof String) {
 			if (!isValidValue(aValue, rowIndex, columnIndex)) {
 				System.err.println("invalid cell value: " + aValue);
 				Thread.dumpStack();
 				return;
 			}
 			CellType cell = getCell(rowIndex, columnIndex);
 			if (cell == null) {
 				System.err.println("This should never happen: cell is null");
 				Thread.dumpStack();
 				return;
 			}
 			if (aValue.equals(cell.getValue())) {
 				return;
 			}
 			cell.setValue((String) aValue);
 			makeDirty();
 			fireTableCellUpdated(rowIndex, columnIndex);
 		} else {
 			System.err.println("Unsupported cell value type: " + aValue + (aValue != null ? " [" + aValue.getClass() + "]" : ""));
 			Thread.dumpStack();
 		}
 	}
 	
 	/* (non-Javadoc)
 	 * @see javax.swing.table.TableModel#isCellEditable(int, int)
 	 */
 	public boolean isCellEditable(int rowIndex, int columnIndex) {
 		ColumnDefType columnDef = getColumnDef(columnIndex);
 		return columnDef != null && columnDef.isEditable();
 	}
 
 	/***
 	 * 
 	 */
 	public void addRow(int rowIndex) {
 		if (table == null) {
 			return;
 		}
 		if (table.isFixedStructure()) {
 			return; // FIXME throw exception?
 		}
 		List rows = table.getRows().getRow();
 		LOGGER.debug("addRow(" + rowIndex + ") of " + rows.size());
 		if (rowIndex < 0 || rowIndex > rows.size())
 			return;
 		RowType row = new RowTypeImpl();
 		List cells = row.getCell();
 		for (Iterator i = getColumnDefs().iterator(); i.hasNext(); ) {
 			ColumnDefType columnDef = (ColumnDefType) i.next();
 			CellType cell = new CellTypeImpl();
 			cell.setColumnId(columnDef.getId());
 			cell.setValue("");
 			cells.add(cell);
 		}
 		rows.add(rowIndex, row);
 		makeDirty();
 		fireTableRowsInserted(rowIndex, rowIndex);
 		// fireTableStructureChanged();
 	}
 
 	public void deleteRow(int rowIndex) {
 		if (table == null) {
 			return;
 		}
 		if (table.isFixedStructure()) {
 			return; // FIXME throw exception?
 		}
 		List rows = table.getRows().getRow();
 		if (rows.size() <= 1) {
 			return; // FIXME throw exception?
 		}
 		if (rowIndex < 0 || rowIndex >= rows.size()) {
 			return;
 		}
 		rows.remove(rowIndex);
 		makeDirty();
 		fireTableRowsDeleted(rowIndex, rowIndex);
 	}
 	
 
 	/***
 	 * @param columnChoices
 	 */
 	public void setColumnChoices(ColumnChoicesType columnChoices) {
 		columnChoicesMap = createColumnChoicesMap(columnChoices); 
 	}
 	
 	public void addPropertyChangeListener(PropertyChangeListener listener) {
 		propertyChangeHandler.addPropertyChangeListener(listener);
 	}
 	
 	public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
 		propertyChangeHandler.addPropertyChangeListener(propertyName, listener);
 	}
 	
 	public void removePropertyChangeListener(PropertyChangeListener listener) {
 		propertyChangeHandler.removePropertyChangeListener(listener);
 	}
 	
 	public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
 		propertyChangeHandler.removePropertyChangeListener(propertyName, listener);
 	}
 	
 	protected boolean isValidValue(Object aValue, int rowIndex, int columnIndex) {
 		if (isUserEditable(columnIndex)) {
 			return true;
 		}
 		Collection choices = getColumnChoices(columnIndex);
 		if (choices == null || choices.size() == 0) {
 			return true;
 		}
 		for (Iterator i = choices.iterator(); i.hasNext();) {
 			ChoiceType choice = (ChoiceType) i.next();
 			if (choice.getValue().equals(aValue)) {
 				return true;
 			}
 		}
 		return false;
 	}
 
 	protected Collection getColumnChoices(int col) {
 		String columnId = getColumnId(col);
 		// TableColumn tableColumn = getColumnModel().getColumn(i);
 		ColumnType column = (ColumnType) columnChoicesMap.get(columnId);
 		return column != null ? column.getChoice() : null;
 	}
 
 	/***
 	 * @param column
 	 * @return
 	 */
 	protected boolean isUserEditable(int col) {
 		String columnId = getColumnId(col);
 		// TableColumn tableColumn = getColumnModel().getColumn(i);
 		ColumnType column = (ColumnType) columnChoicesMap.get(columnId);
 		return column != null ? column.isUserEditable() : false;
 	}
 
 	/***
 	 * @param string
 	 * @return
 	 */
 	private String getColumnId(int columnIndex) {
 		if (table == null) {
 			return null;
 		}
 		ColumnDefType columnDef = getColumnDef(columnIndex);
 		if (columnDef != null)
 			return columnDef.getId();
 		else
 			return null;
 	}
 
 	private CellType getCell(int rowIndex, int columnIndex) {
 		if (table == null) {
 			return null;
 		}
 		List rows = table.getRows().getRow();
 		if (rowIndex >= rows.size()) {
             return null;
         }
 		RowType row = (RowType) rows.get(rowIndex);
 		ColumnDefType columnDef = getColumnDef(columnIndex);
 		if (row == null || columnDef == null) {
 			return null;
 		}
 		String columnId = columnDef.getId();
 		List cells = row.getCell();
 		for (Iterator i = cells.iterator(); i.hasNext(); ) {
 			CellType cell = (CellType) i.next();
 			if (columnId.equals(cell.getColumnId()))
 				return cell;
 		}
 		// Add missing cell
 		CellType cell = new CellTypeImpl();
 		cell.setColumnId(columnId);
 		cell.setValue("");
 		cells.add(cell);
 		return cell;
 	}
 
 	/***
 	 * @param includeHidden TODO
 	 * @return
 	 */
 	private List getVisibleColumnDefs() {
 		return getColumnDefs(true, false);
 	}
 
 	public List getHiddenColumnDefs() {
 		return getColumnDefs(false, true);
 	}
 	
 	private List getColumnDefs() {
 		return getColumnDefs(true, true);
 	}
 	
 	private List getColumnDefs(boolean visible, boolean hidden) {
 		List defs = table.getColumnDefs().getColumnDef();
 		List result = new ArrayList();
 		for (Iterator i = defs.iterator(); i.hasNext();) {
 			ColumnDefType def = (ColumnDefType) i.next();
 			if ((hidden && def.isHidden()) || (visible && !def.isHidden())) {
 				result.add(def);
 			}
 		}
 		return result;
 	}
 	
 	/***
 	 * @param columnIndex
 	 * @return
 	 */
 	private ColumnDefType getColumnDef(int columnIndex) {
 		ColumnDefType columnDef = (ColumnDefType) getVisibleColumnDefs().get(columnIndex);
 		return columnDef;
 	}
 
 	private ColumnDefType getColumnDef(String columnId) {
 		if (columnId == null) {
 			return null;
 		}
 		List defs = table.getColumnDefs().getColumnDef();
 		for (Iterator i = defs.iterator(); i.hasNext();) {
 			ColumnDefType col = (ColumnDefType) i.next();
 			if (columnId.equals(col.getId())) {
 				return col;
 			}
 		}
 		return null;
 	}
 
 	/***
 	 * @param columnChoices
 	 * @return
 	 */
 	private Map createColumnChoicesMap(ColumnChoicesType columnChoices) {
 		Map map = new HashMap();
 		if (columnChoices == null)
 			return map;
 		List columns = columnChoices.getColumn();
 		for (Iterator i = columns.iterator(); i.hasNext(); ) {
 			ColumnType column = (ColumnType) i.next();
 			map.put(column.getId(), column);
 		}
 		return map;
 	}
 	
 	public boolean canHideColumn(int columnIndex) {
 		return getVisibleColumnDefs().size() > 1;
 	}
 	
 	/***
 	 * @param selectedColumn
 	 */
 	public void hideColumn(int columnIndex) {
 		if (canHideColumn(columnIndex)) {
 			return;
 		}
 		ColumnDefType columnDef = getColumnDef(columnIndex);
 		columnDef.setHidden(true);
 		fireTableStructureChanged();
 	}
 
 	public void showColumn(String columnId) {
 		ColumnDefType columnDef = getColumnDef(columnId);
 		columnDef.setHidden(false);
 		fireTableStructureChanged();
 	}
 	
 	public void addColumn(int columnIndex, String name) {
 		if (table.isFixedStructure()) {
 			return; // FIXME throw exception?
 		}
 		List columnDefs = table.getColumnDefs().getColumnDef();
 		int realIndex = getColumnDefIndex(columnIndex, columnDefs);
 		if (realIndex == -1) { // one past the end of the column list
 			realIndex = columnDefs.size();
 		} else if (realIndex < -1) {
 			return;
 		}  
 		ColumnDefType newColumnDef = new ColumnDefTypeImpl();
 		newColumnDef.setId(XmlHelper.genID());
 		newColumnDef.setName(name);
 		columnDefs.add(realIndex, newColumnDef);
 		// cells are added automagically by getCell as necessary
 		fireTableStructureChanged();
 	}
 
 	public void deleteColumn(int columnIndex) {
 		if (table.isFixedStructure()) {
 			return; // FIXME throw exception?
 		}
 		List columnDefs = table.getColumnDefs().getColumnDef();
 		int realIndex = getColumnDefIndex(columnIndex, columnDefs);
 		if (realIndex < 0) {
 			return;
 		}
 		ColumnDefType columnDef = (ColumnDefType) columnDefs.remove(realIndex);
 		String columnId = columnDef.getId();
 		List rows = table.getRows().getRow();
 		for (Iterator i = rows.iterator(); i.hasNext();) {
 			RowType row = (RowType) i.next();
 			List cells = row.getCell();
 			int j = 0;
 			boolean found = false;
 			while (!found && j < cells.size()) {
 				CellType cell = (CellType) cells.get(j);
 				if (columnId.equals(cell.getColumnId())) {
 					cells.remove(j);
 					found = true;
 				} else {
 					j++;
 				}
 			}
 		}
 		fireTableStructureChanged();
 	}
 
 	public void fireTableStructureChanged() {
 	    super.fireTableStructureChanged();
 	    makeDirty();
 	}
 
 	/***
 	 * @param columnIndex
 	 * @param columnDefs
 	 * @return
 	 */
 	private int getColumnDefIndex(int columnIndex, List columnDefs) {
 		int realIndex = 0;
 		while (realIndex < columnDefs.size() && ((ColumnDefType)columnDefs.get(realIndex)).isHidden()) {
 			realIndex++;
 		}
 		while (columnIndex > 0 && realIndex < columnDefs.size()) {
 			ColumnDefType columnDef = (ColumnDefType) columnDefs.get(realIndex);
 			if (!columnDef.isHidden()) {
 				columnIndex--;
 			}
 			realIndex++;
 		}
 		return columnIndex == 0 ? realIndex : -columnIndex;
 	}
 	
 }