package org.netbeans.modules.tasklist.usertasks;

import org.netbeans.modules.tasklist.usertasks.treetable.FilterIntf;

import java.util.Iterator;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import javax.swing.tree.TreeNode;
import org.netbeans.modules.tasklist.client.SuggestionPriority;

import org.netbeans.modules.tasklist.core.Task;
import org.netbeans.modules.tasklist.core.TaskListener;
import org.netbeans.modules.tasklist.core.filter.Filter;
import org.netbeans.modules.tasklist.usertasks.treetable.AdvancedTreeTableNode;
import org.netbeans.modules.tasklist.usertasks.treetable.DefaultMutableTreeTableNode;
import org.netbeans.modules.tasklist.usertasks.treetable.TreeTableNode;

/**
 * Task node
 */
public class UserTaskTreeTableNode extends AdvancedTreeTableNode {
    public static final int SUMMARY = 0;
    public static final int PRIORITY = 1;
    public static final int DONE = 2;
    public static final int PERCENT_COMPLETE = 3;
    public static final int EFFORT = 4;
    public static final int REMAINING_EFFORT = 5;
    public static final int SPENT_TIME = 6;
    public static final int DETAILS = 7;
    public static final int FILE_BASE_NAME = 8;
    public static final int LINE_NUMBER = 9;
    public static final int CATEGORY = 10;
    public static final int CREATED = 11;
    public static final int LAST_EDITED = 12;
    public static final int DUE_DATE = 13;

    /**
     * Filters a task.
     *
     * @return true if the filter accepts ut or one of 
     * it's subtasks
     */
    public static boolean acceptsRecursively(UserTask ut, FilterIntf filter) {
        if (filter.accept(ut))
            return true;
        Iterator it = ut.subtasksIterator();
        while (it.hasNext()) {
            UserTask child = (UserTask) it.next();
            if (acceptsRecursively(child, filter))
                return true;
        }
        return false;
    }
    
    private boolean unmatched;
    private TaskListener tl;
    private PropertyChangeListener pcl;
    
    /** 
     * Creates a new instance of UserTaskTreeTableNode
     *  
     * @param filter filter to be used or null
     * @param ut a user task
     * @param m model for this node
     * @param comparator comparator to be used or null
     */
    public UserTaskTreeTableNode(
    TreeTableNode parent, FilterIntf filter, 
    UserTasksTreeTableModel m, UserTask ut, Comparator comparator) {
        super(m, parent, ut);
        
        this.filter = filter;
        this.comparator = comparator;
        pcl = new PropertyChangeListener() {
            public void propertyChange(PropertyChangeEvent evt) {
                fireObjectChanged();
            }
        };
        ut.addPropertyChangeListener(pcl);
        tl = new TaskListener() {
            public void selectedTask(Task t) {
            }
            public void warpedTask(Task t) {
            }
            public void addedTask(Task t) {
                Iterator it = getUserTask().subtasksIterator();
                int index = 0;
                while (it.hasNext()) {
                    if (it.next() == t)
                        break;
                    index++;
                }
                
                // TODO: fireNodesAdded(index, t);
                // TODO: compute the right index if a filter is used
                refreshChildren();
            }
            public void removedTask(Task pt, Task t, int index) {
                fireChildObjectRemoved(t);
            }
            public void structureChanged(Task t) {
                refreshChildren();
            }
        };
        ut.addTaskListener(tl);
    }
    
    /**
     * Returns true if the filter does not accept this node but accepts
     * some of the children
     *
     * @return true = unmatched
     */
    public boolean isUnmatched() {
        return unmatched;
    }
    
    /**
     * Sets the unmatched attribute
     *
     * @param unmatched true = the filter does not accept this node but 
     * some of it's subnodes
     */
    public void setUnmatched(boolean unmatched) {
        this.unmatched = unmatched;
    }
    
    /**
     * Returns user task associated with this node
     *
     * @return user task
     */
    public UserTask getUserTask() {
        return (UserTask) object;
    }
    
    public Object getValueAt(int column) {
        UserTask ut = getUserTask();
        switch (column) {
            case SUMMARY:
                return ut.getSummary();
            case PRIORITY:
                return ut.getPriority();
            case DONE:
                return Boolean.valueOf(ut.isDone());
            case PERCENT_COMPLETE:
                return new Integer(ut.getPercentComplete());
            case EFFORT:
                return new Integer(ut.getEffort());
            case REMAINING_EFFORT:
                return new Integer(ut.getRemainingEffort());
            case SPENT_TIME:
                return new Integer(ut.getSpentTime());
            case DETAILS: 
                return ut.getDetails();
            case FILE_BASE_NAME:
                return ut.getFileBaseName();
            case LINE_NUMBER:
                return new Integer(ut.getLineNumber());
            case CATEGORY:
                return ut.getCategory();
            case CREATED:
                return new Long(ut.getCreatedDate());
            case LAST_EDITED:
                return new Long(ut.getLastEditedDate());
            case DUE_DATE:
                if (ut.getDueDate() == null)
                    return null;
                else
                    return new Long(ut.getDueDate().getTime());
            default:
                return ""; // NOI18N
        }
    }    
    
    public void setValueAt(Object aValue, int column) {
        UserTask ut = getUserTask();
        switch (column) {
            case DONE:
                ut.setDone(((Boolean) aValue).booleanValue());
                break;
            case CATEGORY:
                ut.setCategory((String) aValue);
                break;
            case PRIORITY:
                ut.setPriority((SuggestionPriority) aValue);
                break;
            case PERCENT_COMPLETE:
                ut.setPercentComplete(((Integer) aValue).intValue());
                break;
        }
    }

    public boolean isLeaf() {
        return !getUserTask().hasSubtasks();
    }
    
    public String toString() {
        return super.toString() + 
            "[userTask=" + getUserTask().toString() + "]";
    }
    
    public void destroy() {
        super.destroy();
        getUserTask().removeTaskListener(tl);
        getUserTask().removePropertyChangeListener(pcl);
    }    
    
    public Iterator getChildrenObjectsIterator() {
        return getUserTask().subtasksIterator();
    }
    
    public AdvancedTreeTableNode createChildNode(Object child) {
        UserTaskTreeTableNode n = new UserTaskTreeTableNode(
            this, filter, (UserTasksTreeTableModel) model, 
            (UserTask) child, comparator);
        if (getFilter() != null && !getFilter().accept(child))
            n.unmatched = true;
        return n;
    }    
    
    public boolean accept(Object child) {
        if (getFilter() == null)
            return true;
        
        return acceptsRecursively((UserTask) child, getFilter());
    }
}