package com.vci.client.ui.table;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;

import javax.swing.event.EventListenerList;
import javax.swing.table.AbstractTableModel;

public class VCIBaseTableModel extends AbstractTableModel{

	/** 
	 * 
	 */
	private static final long serialVersionUID = -3143694192308233038L;
	public ArrayList<VCIBaseTableNode> list = null;
	private String[] columns = null;
	private Class[] classes = null;
	

	/**
	 * create a tableModel with the columns and the classes.
	 * 
	 * @param columns String[], the data columns
	 * @param classes String[], the data classes
	 */
	public VCIBaseTableModel(String[] columns, Class[] classes) {
		super();
		this.columns = columns;
		this.classes = classes;
		initList();
	}
	
	/**
	 * init the ArrayList, the data's type is TableNode.
	 *
	 */
	private void initList() {
		list = new ArrayList<VCIBaseTableNode>();
	}
	
	/**
	 * get column name
	 */
	public String getColumnName(int c) {
		return columns[c];
	}
	
	/**
	 * get column class
	 */
	@SuppressWarnings("unchecked")
	public Class getColumnClass(int c) {
		return classes == null ? String.class : classes[c];
	}

	/**
	 * get the count of columns
	 */
	public int getColumnCount() {
		return columns.length;
	}

	/**
	 * get the row of the model
	 */
	public int getRowCount() {
		return list.size();
	}
	
	/**
	 * get vlaue of each cell of table
	 */
	public Object getValueAt(int rowIndex, int columnIndex) {
		Object obj = null;
		try {
			VCIBaseTableNode tableNode = (VCIBaseTableNode)list.get(rowIndex);
			return tableNode.getPropertyValueByName(columns[columnIndex]);
		} catch (Exception e){
			e.printStackTrace();
			obj = null;
		}
		return obj;
	}
	/**
	 * set value to table cell
	 */
	public void setValueAt(Object obj, int row, int columnIndex) {
		VCIBaseTableNode tableNode = (VCIBaseTableNode)list.get(row);
		tableNode.setPropertyValueByName(columns[columnIndex], obj);
	}
	
	/**
	 * add a row data into the model, if the row vlaue is 0, insert data
	 * into the first line. Others, insert data into the next row of the given one.
	 * 
	 * @param row int, the current row.
	 * @param tableNode TableNode, the data which we want to insert into model.
	 * @return
	 */
	public boolean addRow(int row, VCIBaseTableNode tableNode) {
		boolean rs = false;
		try {
			if (list.size() == 0 || row == 0) {
				list.add(0, tableNode);
			} else { 
				list.add(list.size(), tableNode);
			}
			rs = true;
		} catch (Exception e) {
			e.printStackTrace();
			rs = false;
		}
		return rs;
	}
	
	/**
	 * remove the current row data from the model
	 * 
	 * @param row int
	 * @return
	 */
	public boolean removeRow(int row) {
		boolean rs = false;
		try {
			list.remove(row);
			rs = true;
		} catch (Exception e) {
			e.printStackTrace();
			rs = false;
		}
		return rs;
	}
	public VCIBaseTableNode getValueAt(int row) {
		return list.get(row); 
	}
	
	// add by xchao 2010.11.03
	// 增加单元格数据改变后的事件处理
	private boolean cancelCellValueChange = false;
	/**
	 * 是否取消单元格数据发生的改变
	 * @return
	 */
	public boolean isCancelCellValueChange(){
		return cancelCellValueChange;
	}
	/**
	 * 设置是否取消单元格数据发生的改变
	 * @param isCancel 是否取消 true:取消单元格数据发生的改变 false:保持单元格数据改变
	 */
	public void setCancelCellValueChange(boolean isCancel){
		cancelCellValueChange = isCancel;
	}
    protected EventListenerList listenerList = new EventListenerList();
    /**
     * 添加单元格数据已经修改完毕后的事件处理
     * @param l 单元格数据已经修改完毕后的事件处理程序
     */
    public void addCellValueChangedListener(CellValueChangedListener l){
    	listenerList.add(CellValueChangedListener.class, l);
    }
    /**
     * 移除单元格数据已经修改完毕后的事件处理
     * @param l 单元格数据已经修改完毕后的事件处理程序
     */
    public void removeCellValueChangedListener(CellValueChangedListener l){
    	if(l != null) listenerList.remove(CellValueChangedListener.class, l);
    }
    /**
     * 返回全部的 单元格数据已经修改完毕后的事件处理程序
     * @return
     */
    public CellValueChangedListener[] getCellValueChangedListeners(){
    	return (CellValueChangedListener[])listenerList.getListeners(CellValueChangedListener.class);
    }
    /**
     * 引发 单元格数据已经修改完毕的事件处理程序
     * @param e
     */
    public void fireCellValueChanged(CellValueChanagedEvent e){
    	CellValueChangedListener[] listeners = getCellValueChangedListeners();
    	for(int i = listeners.length - 1; i >= 0; i--){
    		((CellValueChangedListener)listeners[i]).cellValueChanged(e);
    	}
    }
    
    // xxc
    
    /**
     * 添加在单元格数据修改之前的事件处理
     * @param l 单元格数据修改之前的事件程序
     */
    public void addBeforeCellValueChangedListener(BeforeCellValueChangedListener l){
    	listenerList.add(BeforeCellValueChangedListener.class, l);
    }
    /**
     * 移除在单元格数据修改之前的事件处理
     * @param l 单元格数据修改之前的事件程序
     */
    public void removeBeforeCellValueChangedListener(BeforeCellValueChangedListener l){
    	if(l != null) listenerList.remove(BeforeCellValueChangedListener.class, l);
    }
    /**
     * 返回全部的 在单元格数据修改之前的事件处理
     * @return
     */
    public BeforeCellValueChangedListener[] getBeforeCellValueChangedListeners(){
    	return (BeforeCellValueChangedListener[])listenerList.getListeners(BeforeCellValueChangedListener.class);
    }
    /**
     * 引发 在单元格数据修改之前的事件程序
     * @param e
     */
    public void fireBeforeCellValueChanged(CellValueChanagedEvent e){
    	BeforeCellValueChangedListener[] listeners = getBeforeCellValueChangedListeners();
    	for(int i = listeners.length - 1; i >= 0; i--){
    		((BeforeCellValueChangedListener)listeners[i]).beforeCellValueChanged(e);
    	}
    }
    
    private Map<Integer, Integer> editableColumns = new LinkedHashMap<Integer, Integer>();
    /**
     * 添加可编辑列的列索引
     * @param columnIndexs 列索引序列
     */
    public void addEditableColumn(int...columnIndexs){
    	for(int col : columnIndexs){
    		addEditableColumn(col);
    	}
    }
    /**
     * 添加可编辑列的列索引
     * @param columnIndex 列索引
     */
    public void addEditableColumn(int columnIndex){
    	editableColumns.put(columnIndex, columnIndex);
    }
    /**
     * 移除可编辑列的列索引
     * @param columnIndexs 列索引序列
     */
    public void removeEditableColumn(int...columnIndexs){
    	for(int col : columnIndexs){
    		removeEditableColumn(col);
    	}
    }
    /**
     * 移除可编辑列的列索引
     * @param columnIndex 列索引
     */
    public void removeEditableColumn(int columnIndex){
    	if(editableColumns.containsKey(columnIndex)){
    		editableColumns.remove(columnIndex);
    	}
    }
	public boolean isCellEditable(int row, int col) {
		return editableColumns.containsKey(col);
	}
}