/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
 */

package com.oracle.solaris.vp.util.swing.tree;

import java.awt.*;
import java.awt.event.MouseEvent;
import java.util.*;
import java.util.List;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.*;
import com.oracle.solaris.vp.util.swing.ExtTable;

@SuppressWarnings({"serial"})
public class TreeTable extends ExtTable {
    //
    // Instance data
    //

    protected class RenderPanel extends JPanel {
	//
	// Instance data
	//

	private TreeLines lines;

	//
	// Constructors
	//

	public RenderPanel(TreeLines lines) {
	    super(new BorderLayout());
	    this.lines = lines;
	    setBackground(UIManager.getColor("Table.selectionBackground"));
	    setOpaque(false);
	}

	//
	// Component methods
	//

	@Override
	public boolean isEnabled() {
	    try {
		return getComponent(1).isEnabled();
	    } catch (IndexOutOfBoundsException e) {
		return false;
	    }
	}

	@Override
	public void setEnabled(boolean enabled) {
	    try {
		getComponent(1).setEnabled(enabled);
	    } catch (IndexOutOfBoundsException ignore) {
	    }
	}

	//
	// RenderPanel methods
	//

	public TreeLines getTreeLines() {
	    return lines;
	}

	public void setComponent(Component c) {
	    removeAll();
	    add(lines, BorderLayout.WEST);
	    add(c, BorderLayout.CENTER);
	}
    }

    //
    // Static data
    //

    private RowFilter<TreeTableModelAdapter, Integer> ROOT_VISIBLE_FILTER =
	new RowFilter<TreeTableModelAdapter, Integer>() {
	    @Override
	    public boolean include(RowFilter.Entry<
		? extends TreeTableModelAdapter, ? extends Integer> entry) {

		if (isRootVisible()) {
		    return true;
		}

		int index = entry.getIdentifier();
		ModelRowData row = entry.getModel().getRow(index);

		return row.getLevel() != 0;
	    }
	};

    private RowFilter<TreeTableModelAdapter, Integer>
	ANCESTOR_COLLAPSED_FILTER =
	new RowFilter<TreeTableModelAdapter, Integer>() {
	    @Override
	    public boolean include(RowFilter.Entry<
		? extends TreeTableModelAdapter, ? extends Integer> entry) {

		TreeTableModelAdapter adapter = entry.getModel();
		int index = entry.getIdentifier();
		ModelRowData row = adapter.getRow(index);

		ModelRowData parent = adapter.getParent(row);
		while (parent != null) {
		    if (!parent.isExpanded()) {
			return false;
		    }
		    parent = adapter.getParent(parent);
		}

		return true;
	    }
	};

    //
    // Instance data
    //

    private List<ViewRowData> rowData = new ArrayList<ViewRowData>();

    private TreeLines renderTreeLines = new TreeLines(this);
    private RenderPanel renderPanel = new RenderPanel(renderTreeLines);

    private TreeLines editorTreeLines = new TreeLines(this);
    private RenderPanel editPanel = new RenderPanel(editorTreeLines);

    private boolean rootVisible = true;
    private boolean turnerPressed;

    private List<RowFilter<TreeTableModelAdapter, Integer>> filters =
	new ArrayList<RowFilter<TreeTableModelAdapter, Integer>>();

    //
    // Constructors
    //

    public TreeTable(TreeTableModel model) {
	super(new TreeTableModelAdapter(model));

	// Set up sorting
	setAutoCreateRowSorter(false);

	final TableRowSorter<TreeTableModelAdapter> sorter =
	    new TableRowSorter<TreeTableModelAdapter>(getModel());

	// By default, sorting is disabled
	for (int i = 0, n = model.getColumnCount(); i < n; i++) {
	    sorter.setSortable(i, false);
	}

	getColumnModel().addColumnModelListener(
	    new TableColumnModelListener() {
		@Override
		public void columnAdded(TableColumnModelEvent e) {
		    sorter.setSortable(e.getToIndex(), false);
		}

		@Override
		public void columnMarginChanged(ChangeEvent e) {
		}

		@Override
		public void columnMoved(TableColumnModelEvent e) {
		}

		@Override
		public void columnRemoved(TableColumnModelEvent e) {
		}

		@Override
		public void columnSelectionChanged(ListSelectionEvent e) {
		}
	    });

	sorter.setRowFilter(
	    new RowFilter<TreeTableModelAdapter, Integer>() {
		@Override
		public boolean include(
		    RowFilter.Entry<? extends TreeTableModelAdapter,
		    ? extends Integer> entry) {

		    synchronized (filters) {
			for (RowFilter<TreeTableModelAdapter, Integer> filter :
			    filters) {

			    if (!filter.include(entry)) {
				return false;
			    }
			}
			return true;
		    }
		}
	    });
	addRowFilter(ROOT_VISIBLE_FILTER);
	addRowFilter(ANCESTOR_COLLAPSED_FILTER);

	setRowSorter(sorter);
    }

    //
    // Component methods
    //

    @Override
    protected void processMouseEvent(MouseEvent e) {
	if (e.getButton() == 1) {
	    switch (e.getID()) {
		case MouseEvent.MOUSE_PRESSED:
		    Point p = e.getPoint();
		    int vRow = rowAtPoint(p);
		    if (vRow != -1) {
			int vCol = columnAtPoint(p);
			int mCol = convertColumnIndexToModel(vCol);
			TreeTableModelAdapter adapter = getModel();
			if (adapter.getTreeTableModel().isTreeColumn(mCol)) {

			    Rectangle cellRect = getCellRect(vRow, vCol, false);
			    Point relPoint = new Point(
				p.x - cellRect.x, p.y - cellRect.y);

			    ViewRowData data = getRowData(vRow);
			    renderTreeLines.setRowData(data);

			    if (renderTreeLines.isOverTurner(relPoint)) {
//				TableCellEditor editor =
//				    getTable().getCellEditor();
//				if (editor != null) {
//				    editor.stopCellEditing();
//				}

				ModelRowData row = data.getModelRow();
				row.setExpanded(!row.isExpanded());
				((TableRowSorter)getRowSorter()).sort();
				turnerPressed = true;
				e.consume();
				return;
			    }
			}
		    }
		    break;

		case MouseEvent.MOUSE_RELEASED:
		    turnerPressed = false;
		    break;
	    }
	}

	super.processMouseEvent(e);
    }

    @Override
    protected void processMouseMotionEvent(MouseEvent e) {
	switch (e.getID()) {
	    case MouseEvent.MOUSE_DRAGGED:
		if (turnerPressed) {
		    e.consume();
		    return;
		}
		break;
	}

	super.processMouseMotionEvent(e);
    }

    //
    // JComponent methods
    //

    @Override
    protected void paintComponent(Graphics g) {
	// This recalculation really should only be done when 1) a sort occurs,
	// 2) the model changes, or 3) the visible rows change.  Lacking hooks
	// into the latter, do it every time.
	synchronized (rowData) {
	    Rectangle clip = getVisibleRect();
	    int rHeight = getRowHeight();
	    int fVRow = clip.y / rHeight;
	    int lVRow = (clip.y + clip.height) / rHeight;
	    lVRow = Math.min(lVRow, getRowCount() - 1);

	    int nVRows = lVRow - fVRow + 1;

	    rowData.clear();

	    TreeTableModelAdapter adapter = getModel();
	    List<Boolean> showLines = null;

	    ViewRowData data = null;
	    for (int vRow = lVRow; vRow >= fVRow; vRow--) {
		data = createRowData(adapter, vRow,
		    data == null ? null : data.getShowLines());

		rowData.add(data);
	    }

	    Collections.reverse(rowData);
	}

	super.paintComponent(g);
    }

    //
    // JTable methods
    //

    @Override
    public TreeTableModelAdapter getModel() {
	return (TreeTableModelAdapter)super.getModel();
    }

    @Override
    public Component prepareEditor(TableCellEditor editor, int vRow, int vCol) {
	Component comp = super.prepareEditor(editor, vRow, vCol);
	return prepare(editPanel, comp, vRow, vCol);
    }

    @Override
    public Component prepareRenderer(TableCellRenderer renderer, int vRow,
	int vCol) {

	Component comp = super.prepareRenderer(renderer, vRow, vCol);
	return prepare(renderPanel, comp, vRow, vCol);
    }

    //
    // TreeTable methods
    //

    public void addRowFilter(RowFilter<TreeTableModelAdapter, Integer> filter) {
	synchronized (filters) {
	    filters.add(filter);
	}
    }

    public TreeLines getEditorTreeLines() {
	return editorTreeLines;
    }

    public TreeLines getRenderTreeLines() {
	return renderTreeLines;
    }

    public boolean isRootVisible() {
	return rootVisible;
    }

    public void removeRowFilter(
	RowFilter<TreeTableModelAdapter, Integer> filter) {

	synchronized (filters) {
	    filters.remove(filter);
	}
    }

    public void setRootVisible(boolean rootVisible) {
	this.rootVisible = rootVisible;
	((TableRowSorter)getRowSorter()).sort();
	repaint();
    }

    //
    // Private methods
    //

    private ViewRowData createRowData(TreeTableModelAdapter adapter, int vRow,
	List<Boolean> templateShowLines) {

	int mRow = convertRowIndexToModel(vRow);
	ModelRowData row = adapter.getRow(mRow);
	int level = row.getLevel();

	// Ensure sufficient size
	List<Boolean> showLines = new ArrayList<Boolean>();
	for (int i = 0; i < level; i++) {
	    Boolean value = null;
	    try {
		value = templateShowLines.get(i);
	    } catch (IndexOutOfBoundsException ignore) {
	    } catch (NullPointerException ignore) {
	    }
	    showLines.add(value);
	}
	showLines.add(null);

	ViewRowData data = new ViewRowData(vRow, row, showLines);

	int nRows = getRowCount();
	for (vRow++; level >= 0 && showLines.get(level) == null; vRow++) {
	    int curLevel = -1;
	    if (vRow < nRows) {
		mRow = convertRowIndexToModel(vRow);
		row = adapter.getRow(mRow);
		curLevel = row.getLevel();
	    }

	    if (curLevel == level) {
		showLines.set(level, true);
		level--;
	    } else

	    if (curLevel < level) {
		for (int i = level; i > curLevel; i--) {
		    showLines.set(level, false);
		    level--;
		}

		if (level != -1) {
		    showLines.set(level, true);
		    level--;
		}
	    }
	}

	return data;
    }

    private ViewRowData getRowData(int vRow) throws IndexOutOfBoundsException {
	synchronized (rowData) {
	    int offset = rowData.get(0).getRow();
	    return rowData.get(vRow - offset);
	}
    }

    private Component prepare(RenderPanel panel, Component comp, int vRow,
	int vCol) {

	TreeTableModelAdapter model = getModel();
	int mCol = convertColumnIndexToModel(vCol);

	if (model.getTreeTableModel().isTreeColumn(mCol)) {
	    try {
		ViewRowData data = getRowData(vRow);
		panel.getTreeLines().setRowData(data);
		panel.setComponent(comp);

		if (isCellSelected(vRow, vCol)) {
		    panel.setOpaque(true);
		    panel.getTreeLines().setForeground(
			UIManager.getColor("Table.selectionForeground"));
		} else {
		    panel.setOpaque(false);
		    panel.getTreeLines().setForeground(null);
		}

		comp = panel;
	    } catch (IndexOutOfBoundsException ignore) {
	    }
	}

	return comp;
    }
}