package com.vci.client.ui.swing.components.table;


import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.swing.DefaultCellEditor;
import javax.swing.JRadioButton;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.event.CellEditorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;

/**
 * 
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2012</p>
 * <p>Company: VCI</p>
 * @author xchao
 * @time 2012-5-10
 * @version 1.0
 */
public class VCIJTableRadioManager implements IVCIJTableBaseCheckManager {

    public static final int SELECT_PART = 0;

    public static final int SELECT_ALL = 1;

    public static final int SELECT_NONE = 2;

    private byte[] tableCheck = new byte[0];

    private IndexJRadioButton[] templetRadioButton = new IndexJRadioButton[] {
            new IndexJRadioButton((String) null, false),
            new IndexJRadioButton((String) null, true) };

    private JTable table;

    private JRadioButton headerRadioButton;



    private Map<Integer, Object> selectedIndexMap = new HashMap<Integer, Object>();

    private int tableCheckedCount = 0;

    private boolean fireChanged = true;

    private int headerCheckBoxColumn = 0;

    private int checkBoxColumn = 0;

    private static final int DFAULT_MAX_WIDTH = 23;

    private static final int DFAULT_MIN_WIDTH = 23;

    private static final int DFAULT_PREFERRED_WIDTH = 23;

    private int maxWidth = DFAULT_MAX_WIDTH;

    private int minWidth = DFAULT_MIN_WIDTH;

    private int preferredWidth = DFAULT_PREFERRED_WIDTH;

    private IndexJRadioButton editorCheckBox = new IndexJRadioButton();

    private MouseListener nowMouseListen = null;

    private ActionListener actionChange = new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            clickCheckBox(table.getEditingRow());
            checkedChanged2(table.getEditingRow());
        }
    };
    
    private void responseCheckListener(ActionEvent ae){
    	VCIJTableCheckListener[] checkListeners = tablePanel.getListeners(VCIJTableCheckListener.class);
        if(checkListeners != null){
        	for (int i = 0; i < checkListeners.length; i++) {
			}
        }
    }

    private void setTableModelFireTableDataChanged(){
    	table.getModel().addTableModelListener(new TableModelListener(){
			public void tableChanged(TableModelEvent e) {
				clearSelect();
			}
    	});
    }
    
    public void close() {
        clear();
        table = null;
    }

    private void clear() {
        tableCheck = new byte[0]; //  @jve:decl-index=0:

        table = null;

        headerRadioButton = null;


        selectedIndexMap = new HashMap<Integer, Object>();

        tableCheckedCount = 0;

        fireChanged = true;

        //        addCheckBox = null;

        headerCheckBoxColumn = 0;

        checkBoxColumn = 0;

        removeSet();
    }

    public void setCheckBoxColumn(int col) {
        checkBoxColumn = col;
        if (table != null) {
            setColumnAttributes();
        }
    }

    public void setSelected(int[] indexs) {
        for (int i = 0; i < indexs.length; i++) {
            tableCheck[indexs[i]] = 1;
            tableCheckedCount++;
        }
        updateStata();
        table.revalidate();
        table.repaint();
    }

    private void setColumnAttributes() {
        TableColumn tc = table.getColumnModel().getColumn(checkBoxColumn);
        tc.setPreferredWidth(preferredWidth);
        tc.setMaxWidth(maxWidth);
        tc.setMinWidth(minWidth);
        tc.setCellRenderer(getCheckBoxsCellRenderer());
        tc.setCellEditor(getCheckBoxsCellEditor(true));
    }

    private void addTableMouseListener() {
        nowMouseListen = new java.awt.event.MouseAdapter() {
            public void mouseClicked(java.awt.event.MouseEvent e) {
                 if (e.getButton() != java.awt.event.MouseEvent.BUTTON1)
                    return;
                if (e.getClickCount() == 1) {
                    int selectRow = VCIJTableRadioManager.this.table
                    		.getSelectedRow();
                    if (selectRow > -1) {
                        int col = VCIJTableRadioManager.this.table
                                .columnAtPoint(e.getPoint());
                        if (col != -1 && col == checkBoxColumn) {
                        	// add by xchao 2012.08.20
                        	// 放开 clickedRow(selectRow) 将导致，点击列头的CheckBox时，需要单击两次才能实现选择中效果
                        	// 估计是与table添加了鼠标单击事件导致的，将其注释掉时，效果与预期一致，因此注释了此行
                            // clickedRow(selectRow);
                        	// add by xchao 2012.08.20
                        }
                    }
                }
            }

            /**
             * Invoked when the mouse exits a component.
             */
            public void mouseExited(MouseEvent e) {
            }
        };
        table.addMouseListener(nowMouseListen);
    }
    
    public void clickedRow(int rowIndex){
    	clearSelected();
    	clickCheckBox(rowIndex);
        checkedChanged(rowIndex);
        table.revalidate();
        table.repaint();
    }

    private void clearSelected() {
    	 Arrays.fill(tableCheck, new Byte("0"));
    	 selectedIndexMap.clear();
    	 tableCheckedCount = 0;
	}

	protected VCIJTablePanel<?> tablePanel = null;
    public VCIJTableRadioManager(VCIJTablePanel<?> tablePanel, JTable table) {
    	this.tablePanel = tablePanel;
        this.table = table;
        addTableMouseListener();
        setColumnAttributes();
        setTableModelFireTableDataChanged();
    }

    public void removeSet() {
        if (table != null) {
            table.removeMouseListener(nowMouseListen);
            TableColumn tc = table.getColumnModel().getColumn(checkBoxColumn);
            tc.setCellRenderer(null);
            tc.setCellEditor(null);
        }
    }

    public IndexJRadioButton getCheckBox(int i) {
        return templetRadioButton[tableCheck[i]];
    }

    public boolean isSelected(int i) {
        return tableCheck[i] == 0 ? false : true;
    }

    public int size() {
        return tableCheck.length;
    }

    public void clearCheckBoxList() {
        createCheckBoxList();
    }

    public void createCheckBoxList() {
        tableCheck = new byte[0];
        selectedIndexMap = new HashMap<Integer, Object>();
        tableCheckedCount = 0;
        selectLogicRadionButtonChecked(true);
    }

    public void resetCheckBox(int size) {
        createCheckBoxList();
        addCheckBoxs(size);
        selectLogicRadionButtonChecked(true);
    }

    public JTable getTable() {
        return this.table;
    }

    {
        initCheckBox();
    }

	public void initCheckBox() {
		for (int i = 0; i < templetRadioButton.length; i++) {
			templetRadioButton[i].setVisible(true);
		}
		editorCheckBox.addActionListener(actionChange);
		editorCheckBox.addMouseListener(new MouseAdapter() {
			public void mousePressed(MouseEvent e) {
				if (table.getEditingRow() > 0
						&& table.getEditingRow() < tableCheck.length) {
					editorCheckBox
							.setSelected(tableCheck[table.getEditingRow()] == 0 ? false
									: true);
				}
			}
		});
	}

    public void addCheckBoxs(int size) {
        tableCheck = new byte[size];
        selectedIndexMap.clear();
        //        addTableMouseListener();
        //        setColumnAttributes();
    }

	public void setHeaderShowCheckbox(int col) {
		headerCheckBoxColumn = col;
		final JTableHeader jh = table.getTableHeader();
		TableColumnModel headerColumnMode = jh.getColumnModel();
		headerColumnMode.getColumn(0).setHeaderRenderer(
				new TableHeaderRenderer(getHeaderCheckBox()));
		jh.addMouseListener(new java.awt.event.MouseAdapter() {
			public void mouseClicked(java.awt.event.MouseEvent e) {
				int column;
				if ((column = jh.columnAtPoint(e.getPoint())) != -1) {
					TableColumn tc = table.getColumnModel().getColumn(
							checkBoxColumn);
					tc.getCellEditor().cancelCellEditing();
					if (column == headerCheckBoxColumn) {
						selectLogicRadionButtonChecked(true);
						jh.repaint();
					}
				}
			}
		});
	}

    private void selectLogicRadionButtonChecked(boolean seleteSaveTable) {
       
            getHeaderCheckBox().setSelected(true);
            getHeaderCheckBox().setEnabled(false);
            if (seleteSaveTable) {
                seletedRadioButtonCheck();
            }
         
        table.getTableHeader().repaint();
    }

    private void checkedChanged(int index) {
        if (fireChanged && !table.isEditing()) {
            changeStata(index);
        }
    }

    private void checkedChanged2(int index) {
        if (table.isEditing()) {
            changeStata(index);
        }
    }
    
    private void changeStata(int index) {
       
        if (tableCheck[index] == 1) {
            tableCheckedCount++;
            selectedIndexMap.put(index, null);
        } else {
            tableCheckedCount--;
            selectedIndexMap.remove(index);
        }

        updateStata();
    }

    private void updateStata() {
            selectLogicRadionButtonChecked(false);
            table.getTableHeader().repaint();
    }

    private void selectAllTable(boolean check) {
        fireChanged = false;
        byte nowCheckStata = (byte) (check ? 1 : 0);
        for (int i = 0; i < tableCheck.length; i++) {
            tableCheck[i] = nowCheckStata;
        }
        if (check) {
            tableCheckedCount = tableCheck.length;
        } else {
            tableCheckedCount = 0;
        }
        table.revalidate();
        table.repaint();
        fireChanged = true;
    }

    private JRadioButton getHeaderCheckBox() {
        if (headerRadioButton == null) {
            headerRadioButton = new JRadioButton();
            headerRadioButton.setBorderPainted(true);
            headerRadioButton.setEnabled(false);
            headerRadioButton.addActionListener(new ActionListener() {
				@Override
				public void actionPerformed(ActionEvent e) {
		            responseCheckListener(e);
				}
			});
        }
        return headerRadioButton;
    }

    private void clickCheckBox(int i) {
        if (tableCheck != null) {
            tableCheck[i] = (byte) (tableCheck[i] == 0 ? 1 : 0);
        }
    }

    protected class TableHeaderRenderer implements TableCellRenderer {
        private JRadioButton renderCheckBoxs;

        public TableHeaderRenderer(JRadioButton tableCheck) {
            renderCheckBoxs = tableCheck;
        }

        public Component getTableCellRendererComponent(JTable table,
                Object value, boolean isSelected, boolean hasFocus, int row,
                int column) {
            return renderCheckBoxs;
        }
    }

    private void seletedRadioButtonCheck() {
        fireChanged = false;
        tableCheckedCount = 0;

        Set<Integer> keys = selectedIndexMap.keySet();
        int checkIndex = 0;
        for (Iterator<Integer> keyItr = keys.iterator(); keyItr.hasNext();) {
            checkIndex = keyItr.next();
            if (tableCheck.length > checkIndex) {
                tableCheck[checkIndex] = 1;
                tableCheckedCount++;
            }
        }

        if (tableCheckedCount == 0) {
            selectLogicRadionButtonChecked(true);
        } else if (tableCheck.length > 0
                && tableCheckedCount == tableCheck.length) {
            selectLogicRadionButtonChecked(false);
        }
        table.revalidate();
        table.repaint();
        fireChanged = true;
    }

    public void changeCheckBoxStata(int... stata) {
      
    }

    public void clearAndChangeCheckBoxStata(int... stata) {
        clearSelect();
        changeCheckBoxStata(stata);
    }

    public void clearSelect() {
        selectAllTable(false);
        getHeaderCheckBox().setSelected(false);
        getHeaderCheckBox().setEnabled(true);
        table.revalidate();
        table.repaint();
        updateStata();
    }

    public void setSelectedCheckIndexs(List<Integer> selectedInx) {
        selectedIndexMap = new HashMap<Integer, Object>();
        for (int i = 0; i < selectedInx.size(); i++) {
            selectedIndexMap.put(selectedInx.get(i), null);
        }
    }

    public TableCellEditor getCheckBoxsCellEditor(boolean addListener) {
        TableCellEditor tce = new CheckBoxsCellEditor();
        if (addListener)
            tce.addCellEditorListener(new CheckBoxCellEditorListener());
        return tce;
    }

    public TableCellRenderer getCheckBoxsCellRenderer() {
        return new CheckBoxsRenderer();
    }

    class CheckBoxsCellEditor extends DefaultCellEditor {

        /**
         * 
         */
        private static final long serialVersionUID = -1875319868682535006L;

        public CheckBoxsCellEditor() {
            super(new JTextField());
        }

        public Component getTableCellEditorComponent(JTable table,
                Object value, boolean isSelected, int row, int column) {
            return editorCheckBox;
        }
    }

    protected class CheckBoxsRenderer implements TableCellRenderer {

        public CheckBoxsRenderer() {
        }

        public Component getTableCellRendererComponent(JTable table,
                Object value, boolean isSelected, boolean hasFocus, int row,
                int column) {
            if (row < tableCheck.length) {
                return (Component) templetRadioButton[tableCheck[row]];
            }
            return null;
        }
    }
    

    private class IndexJRadioButton extends JRadioButton {
        public IndexJRadioButton(String text, boolean selected) {
            super(text, selected);
        }

        public IndexJRadioButton() {
            super("", false);
        }

        /**
         * 
         */
        private static final long serialVersionUID = 1L;

    }
    

    
    public Set<Integer> getSelectedIndexsSet(){
    	return getSelectedIndexsSet(tablePanel.getTableModel());
    }
    
    @Deprecated
    public Set<Integer> getSelectedIndexsSet(VCIJTableModel<?> baseTableModel){
    	Set<Integer> set = new HashSet<Integer>();
            set = selectedIndexMap.keySet();       
    	return set;
    }
    
    public int[] getSelectedIndexs() {
    	return getSelectedIndexs(tablePanel.getTableModel());
    }
    @Deprecated
    public int[] getSelectedIndexs(VCIJTableModel<?> baseTableModel) {
    	Set<Integer> set = getSelectedIndexsSet(baseTableModel);
    	Integer[] ints = new Integer[set.size()];
        ints = set.toArray(ints);
        Arrays.sort(ints);
        int[] res = new int[ints.length];
        for (int i = 0; i < res.length; i++) {
			res[i] = ints[i].intValue();
		}
        return res;
    }

    class CheckBoxCellEditorListener implements CellEditorListener {
        int row;

        int col;

        public void editingStopped(ChangeEvent e) {
            table.revalidate();
            table.repaint();
        }

        public void editingCanceled(ChangeEvent e) {
            table.revalidate();
            table.repaint();
        }
    }

    public void removeAllSelectedIndex() {
        selectedIndexMap = new HashMap<Integer, Object>();
        tableCheckedCount = 0;
        updateStata();
    }

	@SuppressWarnings("rawtypes")
    public void removeAllSelectedIndexAndCheckBox(VCIJTableModel baseTableModel) {
        int[] indexs = getSelectedIndexs(baseTableModel);
        tableCheck = new byte[tableCheck.length - indexs.length];
    }

    public void removeAllSelectedIndexAndCheckBox(Integer[] indexs) {
        tableCheck = new byte[tableCheck.length - indexs.length];
        for (int i = indexs.length - 1; i >= 0; i--) {
            selectedIndexMap.remove(indexs[i]);
        }
        tableCheckedCount = selectedIndexMap.size();
        updateStata();
    }

    /**
     * maxWidth 
     * @return maxWidth
     */
    public int getMaxWidth() {
        return maxWidth;
    }

    /**
     * maxWidth 
     * @param maxWidth  maxWidth 
     */
    public void setMaxWidth(int maxWidth) {
        this.maxWidth = maxWidth;
    }

    /**
     * minWidth 
     * @return minWidth
     */
    public int getMinWidth() {
        return minWidth;
    }

    /**
     * minWidth 
     * @param minWidth  minWidth 
     */
    public void setMinWidth(int minWidth) {
        this.minWidth = minWidth;
    }

    /**
     * preferredWidth 
     * @return preferredWidth
     */
    public int getPreferredWidth() {
        return preferredWidth;
    }

    /**
     * preferredWidth 
     * @param preferredWidth  preferredWidth 
     */
    public void setPreferredWidth(int preferredWidth) {
        this.preferredWidth = preferredWidth;
    }

}