package com.vci.client.ui.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.JCheckBox;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.SwingConstants;
import javax.swing.UIManager;
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;

public class TableCheckboxManager {

    public static final int SELECT_PART = 0;

    public static final int SELECT_ALL = 1;

    public static final int SELECT_NONE = 2;

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

    private IndexJCheckBox[] templetBox = new IndexJCheckBox[] {
            new IndexJCheckBox((String) null, false),
            new IndexJCheckBox((String) null, true) };

    private JTable table;

    private JCheckBox headerCheckBox;

    private int checkStata = -1;

    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 IndexJCheckBox editorCheckBox = new IndexJCheckBox();

    private MouseListener nowMouseListen = null;

    private ActionListener actionChange = new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            clickCheckBox(table.getEditingRow());
            checkedChanged2(table.getEditingRow());
        }
    };

    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 boolean[0]; //  @jve:decl-index=0:

        table = null;

        headerCheckBox = null;

        checkStata = -1;

        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]] = true;
            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 = TableCheckboxManager.this.table
                            .getSelectedRow();
                    if (selectRow > -1) {
                        int col = TableCheckboxManager.this.table
                                .columnAtPoint(e.getPoint());
                        if (col != -1 && col == checkBoxColumn) {
                            clickCheckBox(selectRow);
                            checkedChanged(selectRow);
                            table.revalidate();
                            table.repaint();
                        }
                    }
                }
            }

            /**
             * Invoked when the mouse exits a component.
             */
            public void mouseExited(MouseEvent e) {
            }
        };
        table.addMouseListener(nowMouseListen);
    }

    public TableCheckboxManager() {
    }
    
    public TableCheckboxManager(JTable table) {
        this.table = table;
        addTableMouseListener();
        setColumnAttributes();
        setTableModelFireTableDataChanged();
    }
    
    public TableCheckboxManager(List<JCheckBox> checkBoxs) {
        saveCheckBoxListStata(checkBoxs);
    }
    
    public TableCheckboxManager(JTable table, List<JCheckBox> checkBoxs) {
        this(table);
        saveCheckBoxListStata(checkBoxs);
    }
    
    private void saveCheckBoxListStata(List<JCheckBox> checkBoxs) {
        tableCheck = new boolean[checkBoxs.size()];
        for (int i = 0; i < checkBoxs.size(); i++) {
            tableCheck[i] = checkBoxs.get(i).isSelected();
        }
    }

    public void setTable(JTable table) {
        clear();
        boolean addMouseLisen = false;
        if (this.table != table) {
            addMouseLisen = true;
        }
        if (addMouseLisen) {
            this.table = table;
            addTableMouseListener();
            setColumnAttributes();
        }
    }

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

    public JCheckBox getCheckBox(int i) {
        return templetBox[tableCheck[i] ? 1 : 0];
    }

    public boolean isSelected(int i) {
        return tableCheck[i];
    }

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

    public void clearCheckBoxList() {
        createCheckBoxList();
    }

    public void createCheckBoxList() {
        tableCheck = new boolean[0];
        selectedIndexMap = new HashMap<Integer, Object>();
        tableCheckedCount = 0;
        checkStata = -1;
        selectLogicCheckBoxChecked(true);
    }

    public void resetCheckBox(int size) {
        createCheckBoxList();
        addCheckBoxs(size);
        checkStata--;
        selectLogicCheckBoxChecked(true);
    }

    //    public List<JCheckBox> getCheckBoxList() {
    //        return tableCheck;
    //    }

    //    public void setCheckBoxList(List<JCheckBox> checkBoxList) {
    //        tableCheck = checkBoxList;
    //    }

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

    {
        initCheckBox();
    }

    public void initCheckBox() {
        for (int i = 0; i < templetBox.length; i++) {
            //            templetBox[i].addChangeListener(checkChange);
            templetBox[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()]);
                }
            }
        });
    }

    public void addCheckBoxs(int size) {
        tableCheck = new boolean[size];
        //        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) {
                        selectLogicCheckBoxChecked(true);
                        jh.repaint();
                    }
                }
            }
        });
    }

    private void selectLogicCheckBoxChecked(boolean seleteSaveTable) {
        checkStata++;
        if (checkStata == 3) {
            checkStata = 0;
        }
        switch (checkStata) {
        case SELECT_PART:
            getHeaderCheckBox().setSelected(true);
            getHeaderCheckBox().setEnabled(false);
            if (seleteSaveTable) {
                seletedCheckBoxCheck();
            }
            break;
        case SELECT_ALL:
            getHeaderCheckBox().setSelected(true);
            getHeaderCheckBox().setEnabled(true);
            if (seleteSaveTable) {
                selectAllTable(true);
            }
            break;
        case SELECT_NONE:
            getHeaderCheckBox().setSelected(false);
            getHeaderCheckBox().setEnabled(true);
            if (seleteSaveTable) {
                selectAllTable(false);
            }
            break;
        }
        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 (checkStata == SELECT_NONE) {
            selectedIndexMap = new HashMap<Integer, Object>();
        }

        if (checkStata == SELECT_ALL) {
            selectedIndexMap = new HashMap<Integer, Object>();
            for (int i = 0; i < tableCheck.length; i++) {
                selectedIndexMap.put(i, null);
            }
        }

        if (tableCheck[index]) {
            tableCheckedCount++;
            selectedIndexMap.put(index, null);
        } else {
            tableCheckedCount--;
            selectedIndexMap.remove(index);
        }

        updateStata();
    }

    private void updateStata() {
        int changedStata = 0;
        if (tableCheckedCount != 0) {
            if (tableCheckedCount == tableCheck.length) {
                changedStata = SELECT_ALL;
            } else {
                changedStata = SELECT_PART;
            }
        } else {
            changedStata = SELECT_NONE;
        }

        if (changedStata != checkStata) {
            changedStata--;
            checkStata = changedStata;
            selectLogicCheckBoxChecked(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] = check;
        }
        if (check) {
            tableCheckedCount = tableCheck.length;
        } else {
            tableCheckedCount = 0;
        }
        table.revalidate();
        table.repaint();
        fireChanged = true;
    }

    private JCheckBox getHeaderCheckBox() {
        if (headerCheckBox == null) {
            headerCheckBox = new JCheckBox();
            headerCheckBox.setBorderPainted(true);
        }
        return headerCheckBox;
    }

    private void clickCheckBox(int i) {
        if (tableCheck != null) {
            tableCheck[i] = !tableCheck[i];
        }
    }

    protected class TableHeaderRenderer implements TableCellRenderer {
        private JCheckBox renderCheckBoxs;

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

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

        	renderCheckBoxs.setBorderPainted(true);
        	renderCheckBoxs.setBorder(UIManager.getBorder("TableHeader.cellBorder"));        	

            return renderCheckBoxs;
        }
    }

    private void seletedCheckBoxCheck() {
        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] = true;
                tableCheckedCount++;
            }
        }

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

    public void changeCheckBoxStata(int... stata) {
        for (int i = 0; i < stata.length; i++) {
            checkStata = stata[i] - 1;
            selectLogicCheckBoxChecked(true);
            if (checkStata == stata[i]) {
                break;
            }
        }
    }

    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) templetBox[tableCheck[row] ? 1 : 0];
            }
            return null;
        }
    }

    private class IndexJCheckBox extends JCheckBox {
        public IndexJCheckBox(String text, boolean selected) {
            super(text, selected);
        }

        public IndexJCheckBox() {
            super();
        }

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

        private int index = 0;

        public int getIndex() {
            return index;
        }

        public void setIndex(int index) {
            this.index = index;
        }
    }
    
    public Set<Integer> getSelectedIndexSet(VCIBaseTableModel baseTableModel) {
        switch (checkStata) {
        case SELECT_PART:
            return selectedIndexMap.keySet();
        case SELECT_ALL:
            HashSet<Integer> allItem = new HashSet<Integer>();
            for (int i = 0; i < baseTableModel.list.size(); i++) {
                allItem.add(i);
            }
            return allItem;
        case SELECT_NONE:
            return new HashSet<Integer>();
        }
        return new HashSet<Integer>();
    }

    class CheckBoxCellEditorListener implements CellEditorListener {
        int row;

        int col;

        public void editingStopped(ChangeEvent e) {
            table.revalidate();
            table.repaint();
            //            editorCheckBox
            //                    .setSelected(tableCheck[table.getEditingRow()] == 0 ? false
            //                            : true);
            //            editorCheckBox.setIndex(table.getEditingRow());
        }

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

    }

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

    public Integer[] getSortedSelectedIndexs(VCIBaseTableModel baseTableModel) {
        Set<Integer> selectIndex = getSelectedIndexSet(baseTableModel);
        Integer[] indexs = new Integer[selectIndex.size()];
        indexs = selectIndex.toArray(indexs);
        Arrays.sort(indexs);
        return indexs;
    }

    public void removeAllSelectedIndexAndCheckBox(VCIBaseTableModel baseTableModel) {
        Integer[] indexs = getSortedSelectedIndexs(baseTableModel);
        tableCheck = new boolean[tableCheck.length - indexs.length];
    }

    public void removeAllSelectedIndexAndCheckBox(Integer[] indexs) {
        tableCheck = new boolean[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;
    }
}