/*
 *                 Sun Public License Notice
 * 
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 * 
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2003 Sun
 * Microsystems, Inc. All Rights Reserved.
 */

package org.netbeans.modules.tasklist.compiler.tasktreetable;

import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.beans.PropertyVetoException;
import java.util.ArrayList;
import java.util.Comparator;
import javax.swing.Action;
import javax.swing.JPopupMenu;
import javax.swing.ListSelectionModel;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import org.netbeans.modules.tasklist.compiler.CompileErrorNode;
import org.netbeans.modules.tasklist.compiler.CompileErrorsSettings;
import org.netbeans.modules.tasklist.core.ColumnProperty;
import org.netbeans.modules.tasklist.core.columns.ColumnsConfiguration;
import org.netbeans.modules.tasklist.compiler.nodestreetable.NodesTreeTable;
import org.netbeans.modules.tasklist.compiler.nodestreetable.NodesTreeTableModel;
import org.netbeans.modules.tasklist.compiler.treetable.SortableTableHeader;
import org.netbeans.modules.tasklist.compiler.treetable.SortingHeaderRenderer;
import org.netbeans.modules.tasklist.compiler.treetable.TreeTable;
import org.netbeans.modules.tasklist.compiler.treetable.TreeTableModel;
import org.openide.ErrorManager;
import org.openide.awt.MouseUtils;
import org.openide.explorer.ExplorerManager;
import org.openide.nodes.Node;
import org.openide.util.Utilities;

/**
 * TreeTable for build errors
 *
 * @author Tim Lebedkov
 */
public class ErrorsTreeTable extends NodesTreeTable {

    private static final long serialVersionUID = 1;

    /**
     * Creates a new TreeTable
     * 
     * @param em an ExplorerManager. 
     * @param model a model for the TreeTable. todo comme
     */
    public ErrorsTreeTable(ExplorerManager explorerManager, ColumnProperty[] properties, Node root) {
        super(explorerManager, properties, root);
        
        setTableHeader(createDefaultTableHeader());
        //getTableHeader().setDefaultRenderer(new SortingHeaderRenderer());
        //getTree().setRootVisible(false);
        getTree().setShowsRootHandles(true);
        getTree().putClientProperty("JTree.lineStyle", "Horizontal"); // NOI18N
        getTree().setCellRenderer(new SummaryTreeCellRenderer());
        setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        this.setShowHorizontalLines(true);
        this.setShowVerticalLines(true);
        setAutoResizeMode(AUTO_RESIZE_OFF);
    }
    
    /**
     * Configures columns in this tree table
     *
     * @param cc columns configuration
     */
    public void configure(ColumnsConfiguration cc) {
        assert cc != null : "cc == null"; // NOI18N
        
        this.createDefaultColumnsFromModel();

        ArrayList newc = new ArrayList();
        TableColumnModel tcm = getColumnModel();
        assert tcm != null : "tcm == null"; // NOI18N

        ColumnProperty[] props = 
            ((NodesTreeTableModel) getTreeTableModel()).getProperties();
        
        String[] p = cc.getProperties();
        String sc = cc.getSortingColumn();
        boolean so = cc.getSortingOrder();
        int[] w = cc.getWidths();
        
        for (int i = 0; i < p.length; i++) {
            for (int j = 0; j < tcm.getColumnCount(); j++) {
                String s = props[tcm.getColumn(j).getModelIndex()].getName();
                if (s.equals(p[i])) {
                    TableColumn c = tcm.getColumn(j);
                    newc.add(c);
                    tcm.removeColumn(c);
                    c.setPreferredWidth(w[i]);
                    break;
                }
            }
        }
        while (tcm.getColumnCount() > 0) {
            tcm.removeColumn(tcm.getColumn(0));
        }
        for (int i = 0; i < newc.size(); i ++) {
            TableColumn c = (TableColumn) newc.get(i);
            tcm.addColumn(c);
        }
    }

    /**
     * Saves columns data
     *
     * @param cc columns configuration
     */
    public void save(ColumnsConfiguration cc) {
        assert cc != null : "cc == null"; // NOI18N
        
        TableColumnModel ctm = getColumnModel();
        assert ctm != null : "ctm == null"; // NOI18N
        
        ColumnProperty[] props =
            ((NodesTreeTableModel) getTreeTableModel()).getProperties();
        
        int[] w = new int[ctm.getColumnCount()];
        String[] p = new String[ctm.getColumnCount()];
        for (int i = 0; i < ctm.getColumnCount(); i++) {
            TableColumn c = ctm.getColumn(i);
            w[i] = c.getWidth();
            p[i] = props[c.getModelIndex()].getName();
        }
        
        cc.setValues(p, w, null, false);
    }
    
    protected JTableHeader createDefaultTableHeader() {
        return new SortableTableHeader(columnModel);
    }

    /**
     * Compares summaries of 2 errors
     */
    public static class SummaryComparator implements Comparator {
        public int compare(Object o1, Object o2) {
            /*ErrorTTNode node1 = (ErrorTTNode) o1;
            ErrorTTNode node2 = (ErrorTTNode) o2;
            CompileError error1 = node1.getTask();
            CompileError error2 = node2.getTask();
            return error1.getSummary().compareTo(error2.getSummary()); todo */
            return 0;
        }
    }
    
    /**
     * Compares details of 2 errors
     */
    public static class DetailsComparator implements Comparator {
        public int compare(Object o1, Object o2) {
            /*  todo ErrorTTNode node1 = (ErrorTTNode) o1;
            ErrorTTNode node2 = (ErrorTTNode) o2;
            CompileError error1 = node1.getTask();
            CompileError error2 = node2.getTask();
            return error1.getDetails().compareTo(error2.getDetails());*/
            
            return 0;
        }
    }
    
    /**
     * Compares folders of 2 errors
     */
    public static class FoldersComparator implements Comparator {
        public int compare(Object o1, Object o2) {
            /*ErrorTTNode node1 = (ErrorTTNode) o1;
            ErrorTTNode node2 = (ErrorTTNode) o2;
            CompileError error1 = node1.getTask();
            CompileError error2 = node2.getTask();
            FileObject f1 = error1.getFolder();
            FileObject f2 = error2.getFolder();
            if (f1 == null && f2 == null)
                return 0;
            if (f1 == null)
                return -1;
            if (f2 == null)
                return 1;
            String n1 = f1.getPath();
            String n2 = f2.getPath();
            return n1.compareTo(n2); todo*/
            return 0;
        }
    }
    
    /**
     * Compares files of 2 errors
     */
    public static class FilesComparator implements Comparator {
        public int compare(Object o1, Object o2) {
            /* todo ErrorTTNode node1 = (ErrorTTNode) o1;
            ErrorTTNode node2 = (ErrorTTNode) o2;
            CompileError error1 = node1.getTask();
            CompileError error2 = node2.getTask();
            FileObject f1 = error1.getFile();
            FileObject f2 = error2.getFile();
            if (f1 == null && f2 == null)
                return 0;
            if (f1 == null)
                return -1;
            if (f2 == null)
                return 1;
            String n1 = f1.getNameExt();
            String n2 = f2.getNameExt();
            return n1.compareTo(n2); todo */
            return 0;
        }
    }
    
    /**
     * Compares lines of 2 errors
     */
    public static class LinesComparator implements Comparator {
        public int compare(Object o1, Object o2) {
            /* todo ErrorTTNode node1 = (ErrorTTNode) o1;
            ErrorTTNode node2 = (ErrorTTNode) o2;
            CompileError error1 = node1.getTask();
            CompileError error2 = node2.getTask();
            Line f1 = error1.getLine();
            Line f2 = error2.getLine();
            if (f1 == null && f2 == null)
                return 0;
            if (f1 == null)
                return -1;
            if (f2 == null)
                return 1;
            return f1.getLineNumber() - f2.getLineNumber();*/
            return 0;
        }
    }
    
    /**
     * Compares severities of 2 errors
     */
    public static class SeveritiesComparator implements Comparator {
        public int compare(Object o1, Object o2) {
            /* todo Node node1 = (Node) o1;
            Node node2 = (Node) o2;
            CompileError error1 = node1.getTask();
            CompileError error2 = node2.getTask();
            return error2.getSeverity() - error1.getSeverity();*/
            return 0;
        }
    }
}