package org.netbeans.modules.tasklist.usertasks;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import org.netbeans.modules.tasklist.client.SuggestionPriority;

import org.netbeans.modules.tasklist.core.TLUtils;
import org.netbeans.modules.tasklist.core.filter.Filter;
import org.netbeans.modules.tasklist.usertasks.treetable.AdvancedTreeTableNode;
import org.netbeans.modules.tasklist.usertasks.treetable.BooleanComparator;
import org.netbeans.modules.tasklist.usertasks.treetable.DefaultMutableTreeTableNode;
import org.netbeans.modules.tasklist.usertasks.treetable.DefaultTreeTableModel;
import org.netbeans.modules.tasklist.usertasks.treetable.FilterIntf;
import org.netbeans.modules.tasklist.usertasks.treetable.NotComparator;
import org.netbeans.modules.tasklist.usertasks.treetable.SortingModel;
import org.netbeans.modules.tasklist.usertasks.treetable.StringIgnoreCaseComparator;
import org.netbeans.modules.tasklist.usertasks.treetable.TreeTableNode;
import org.openide.text.Line;

/**
 * TT model for user tasks
 */
public class UserTasksTreeTableModel extends DefaultTreeTableModel {
    /**
     * Compares lines of 2 errors
     */
    public static class LinesComparator implements Comparator {
        public int compare(Object o1, Object o2) {
            Line f1 = (Line) o1;
            Line f2 = (Line) o2;
            if (f1 == null && f2 == null)
                return 0;
            if (f1 == null)
                return -1;
            if (f2 == null)
                return 1;
            return f1.getLineNumber() - f2.getLineNumber();
        }
    }
    
    public static final String[] COLUMN_PROPERTIES = {
        "summary", // NOI18N
        "priority", // NOI18N
        "done", // NOI18N
        "percentComplete", // NOI18N
        "effort", // NOI18N
        "remainingEffort", // NOI18N
        "spentTime", // NOI18N
        "details", // NOI18N
        "file", // NOI18N
        "line", // NOI18N
        "category", // NOI18N
        "created", // NOI18N
        "edited", // NOI18N
        "due" // NOI18N
    };
    
    private static final Comparator[] COMPARATORS = {
        new StringIgnoreCaseComparator(),
        new SuggestionPriorityComparator(),
        new BooleanComparator(), 
        SortingModel.DEFAULT_COMPARATOR, 
        SortingModel.DEFAULT_COMPARATOR, 
        SortingModel.DEFAULT_COMPARATOR, 
        SortingModel.DEFAULT_COMPARATOR, 
        SortingModel.DEFAULT_COMPARATOR, 
        SortingModel.DEFAULT_COMPARATOR, 
        SortingModel.DEFAULT_COMPARATOR, 
        SortingModel.DEFAULT_COMPARATOR, 
        SortingModel.DEFAULT_COMPARATOR, 
        SortingModel.DEFAULT_COMPARATOR, 
        SortingModel.DEFAULT_COMPARATOR
    };
    
    private static final Class[] COLUMN_CLASS = {
        null, 
        SuggestionPriority.class,
        Boolean.class,
        Integer.class,
        Integer.class,
        Integer.class,
        Integer.class,
        String.class,
        String.class,
        Integer.class,
        String.class,
        String.class,
        Long.class,
        Long.class,
        Long.class
    };
    
    private static final String[] COLUMNS = {
        "Summary", 
        "Priority", 
        "Done", 
        "Percent Complete",
        "Effort", 
        "Rem. Effort", 
        "Spent Time", 
        "Details", 
        "File", 
        "Line",
        "Category", 
        "Created", 
        "Edited", 
        "Due"
    }; // TODO i18n
            
    private SortingModel sm;
    private UserTaskList utl;
    
    /**
     * Creates a new instance of UserTasksTreeTableModel
     *
     * @param root root node
     * @param sm a sorting model
     * @param filter a filter
     */
    public UserTasksTreeTableModel(UserTaskList utl, SortingModel sm, 
    final Filter filter) {
        super(null, COLUMNS);
        this.utl = utl;
        this.sm = sm;
        this.sm.addChangeListener(new ChangeListener() {
            public void stateChanged(ChangeEvent e) {
                sort();
            }
        });
        for (int i = 0; i < COMPARATORS.length; i++) {
            sm.setColumnComparator(i, COMPARATORS[i]);
        }
        
        FilterIntf fi = null;
        if (filter != null) {
            fi = new FilterIntf() {
                public boolean accept(Object obj) {
                    if (obj instanceof UserTask) {
                        return filter.accept((UserTask) obj);
                    } else {
                        return true;
                    }                
                }
            };
        }
        this.root = new UserTaskListTreeTableNode(fi, this, utl, null);
    }
    
    /**
     *TODO
     */
    public void destroy() {
        ((AdvancedTreeTableNode) root).destroy();
    }
    
    /**
     * todo
     */
    public UserTaskList getUserTaskList() {
        return utl;
    }
    
    /**
     * Finds the path to the specified user task
     *
     * @param a user task from this model
     * @return path to the task or null
     */
    public TreePath findPathTo(UserTask ut) {
        List path = new ArrayList();
        while (ut != null) {
            path.add(0, ut);
            ut = (UserTask) ut.getParent();
        }
        List retp = new ArrayList();
        retp.add(getRoot());
        
        DefaultMutableTreeTableNode n = (DefaultMutableTreeTableNode) getRoot();
        for(int i = 0; i < path.size(); i++) {
            Object obj = path.get(i);
            boolean found = false;
            for (int j = 0; j < n.getChildCount(); j++) {
                if (((DefaultMutableTreeTableNode) n.getChildAt(j)).
                    getUserObject() == obj) {
                    found = true;
                    retp.add(n);
                    break;
                }
            }
            if (!found)
                return null;
        }
        
        return new TreePath(retp.toArray());
    }
    
    public Class getColumnClass(int column) {
        if (column == 0)
            return super.getColumnClass(0);
        return COLUMN_CLASS[column];
    }
    
    /**
     * Sorts the tree according to the specified sorting model
     */
    private void sort() {
        final int sortedColumn = sm.getSortedColumn();
        if (sortedColumn == -1)
            return;
        
        Comparator c = COMPARATORS[sortedColumn];
        if (c == null)
            return;
        
        final Comparator c2;
        if (!sm.isSortOrderDescending())
            c2 = new NotComparator(c);
        else
            c2 = c;
        
        Comparator comparator = new Comparator() {
            public int compare(Object obj1, Object obj2) {
                UserTaskTreeTableNode n1 = (UserTaskTreeTableNode) obj1;
                UserTaskTreeTableNode n2 = (UserTaskTreeTableNode) obj2;
                return c2.compare(
                    n1.getValueAt(sortedColumn), n2.getValueAt(sortedColumn));
            }
        };

        ((UserTaskListTreeTableNode) getRoot()).setComparator(comparator);
    }
    
    public boolean isCellEditable(Object node, int column) {
        if (node == root)
            return column == UserTaskTreeTableNode.SUMMARY;
        return column == UserTaskTreeTableNode.SUMMARY ||
            column == UserTaskTreeTableNode.DONE ||
            column == UserTaskTreeTableNode.CATEGORY ||
            column == UserTaskTreeTableNode.DETAILS ||
            column == UserTaskTreeTableNode.PRIORITY ||
            column == UserTaskTreeTableNode.PERCENT_COMPLETE;
    }
    
    public void fireTreeNodesChanged(Object source, Object[] path, 
    int[] childIndices, Object[] children) {
        UTUtils.LOGGER.fine("path=" + Arrays.asList(path).toString() + 
            "children=" + Arrays.asList(children).toString());
        super.fireTreeNodesChanged(source, path, childIndices, children);
    }
    
    public void fireTreeNodesInserted(Object source, Object[] path, 
    int[] childIndices, Object[] children) {
        UTUtils.LOGGER.fine("path=" + Arrays.asList(path).toString() + 
            "children=" + Arrays.asList(children).toString());
        super.fireTreeNodesInserted(source, path, childIndices, children);
    }
    
    public void fireTreeNodesRemoved(Object source, Object[] path, 
    int[] childIndices, Object[] children) {
        UTUtils.LOGGER.fine("path=" + Arrays.asList(path).toString() + 
            "children=" + Arrays.asList(children).toString());
        super.fireTreeNodesRemoved(source, path, childIndices, children);
    }
    
    public void fireTreeStructureChanged(Object source, Object[] path) {
        UTUtils.LOGGER.fine("path=" + Arrays.asList(path).toString());
        if (UTUtils.LOGGER.isLoggable(Level.FINER))
            Thread.dumpStack();
        super.fireTreeStructureChanged(source, path);
    }
    
    public void fireTreeStructureChanged(Object source, Object[] path, 
    int[] childIndices, Object[] children) {
        UTUtils.LOGGER.fine("path=" + Arrays.asList(path).toString() + 
            "children=" + Arrays.asList(children).toString());
        super.fireTreeStructureChanged(source, path, childIndices, children);
    }
    
}