package net.sourceforge.basher.impl;
   
   import java.util.*;
   
   import net.sourceforge.basher.Task;
   
   /**
    * @author Johan Lindquist
    */
  public class TaskTree
  {
      private TaskNode _root = new TaskNode("ROOT",Collections.<TaskNode>emptyList());
      private String _includes;
      private String _excludes;
  
      public TaskTree(final List<TaskContribution> availableTasksWorkingList)
      {
          for (TaskContribution taskContribution : availableTasksWorkingList)
          {
              addTask(taskContribution);
          }
      }
  
      public TaskTree()
      {
      }
  
      public void setExcludes(final String excludes)
      {
          _excludes = excludes;
      }
  
      public void setIncludes(final String includes)
      {
          _includes = includes;
      }
  
  
      private class TaskNode
      {
          private String _identifier;
          private List<TaskContribution> _taskContributions;
          private List<TaskNode> _branches;
          private List<TaskNode> _parents;
  
          private TaskNode(final String identifier, final List<TaskNode> parents)
          {
              _identifier = identifier;
              _parents = parents;
          }
  
          public TaskNode getBranch(final String name)
          {
              if (_branches == null)
              {
                  return null;
              }
  
              for (TaskNode branch : _branches)
              {
                  if (branch._identifier.equals(name))
                  {
                      return branch;
                  }
              }
              return null;
          }
  
          public List<TaskContribution> getTaskContributions()
          {
              if (_taskContributions == null)
              {
                  return Collections.emptyList();
              }
              return _taskContributions;
          }
  
          public List<TaskContribution> getAllTasks()
          {
              List<TaskContribution> allTasks = new ArrayList<TaskContribution>((_taskContributions == null ? Collections.<TaskContribution>emptyList() : _taskContributions));
              if (_branches == null)
              {
                  return allTasks;
              }
              for (TaskNode branch : _branches)
              {
                  allTasks.addAll(branch.getAllTasks());
              }
              return allTasks;
          }
  
          public void addBranch(final TaskNode taskNode)
          {
              if (_branches == null)
              {
                  _branches = new ArrayList<TaskNode>();
              }
  
              // Check if the branch exists already
             for (TaskNode branch : _branches)
             {
                 if (branch._identifier.equals(taskNode._identifier))
                 {
                     return;
                 }
             }
             _branches.add(taskNode);
         }
 
         public void addTask(final TaskContribution taskContribution)
         {
             if (_taskContributions == null)
             {
                 _taskContributions = new ArrayList<TaskContribution>();
             }
             _taskContributions.add(taskContribution);
         }
     }
 
     /**
      * Retrieves tasks based on the globally set include/exclude patterns.
      *
      * @return The filtered tasks
      */
     public List<TaskContribution> getTasks()
     {
         final Set<TaskContribution> includeTasks = new HashSet<TaskContribution>();
 
         if (_includes == null)
         {
             includeTasks.addAll(getTasks("*"));
         }
         else
         {
             String[] includePatterns = _includes.split(",");
             if (includePatterns == null || includePatterns.length == 0)
             {
                 includeTasks.addAll(getTasks("*"));
             }
             else
             {
                 for (String includePattern : includePatterns)
                 {
                     includeTasks.addAll(getTasks(includePattern));
                 }
             }
         }
 
         final List<TaskContribution> excludeTasks = new ArrayList<TaskContribution>();
         if (_excludes != null)
         {
             String[] excludePatterns = _excludes.split(",");
             if (excludePatterns != null && excludePatterns.length > 0)
             {
                 for (String excludePattern : excludePatterns)
                 {
                     excludeTasks.addAll(getTasks(excludePattern));
                 }
             }
         }
         includeTasks.removeAll(excludeTasks);
 
         return new ArrayList<TaskContribution>(includeTasks);
     }
 
     public List<TaskContribution> getTasks(final String pattern)
     {
         // Pattern is something like
         // net.sourceforge.basher.**.*
         //                        ^  ^
         //                        |  '- Wildcard for a set of tasks within the package
         //                        |
         //                        '- Wildcard for a set of packages
 
         String[] splitBranches = pattern.split("\\.");
 
         final String lastPartTaskName = splitBranches[splitBranches.length-1];
 
         TaskNode taskNode = _root;
         for (int i = 0; i < splitBranches.length - 1; i++)
         {
             String branch = splitBranches[i];
 
             // If pattern == wildcard (**) this should evaluate all
             // branches at this level
             if (branch.equals("**"))
             {
                 // hmmm
             }
 
 
             final TaskNode nextTaskNode = taskNode.getBranch(branch);
             if (nextTaskNode == null)
             {
                 // No more splitBranches - return tasks in this node
                 return filterTasks(lastPartTaskName, taskNode.getTaskContributions());
             }
             else
             {
                 taskNode = nextTaskNode;
             }
 
         }
         return taskNode.getAllTasks();
 
 
     }
 
     private List<TaskContribution> filterTasks(final String lastPartTaskName, final List<TaskContribution> tasks)
     {
        /* List<Task> filteredTasks = new ArrayList<Task>();
         for (Task task : tasks)
         {
             final String[] strings = task.getName().split(".");
             final String lastPart = strings[strings.length-1];
 
             final Pattern pattern = Pattern.compile(lastPartTaskName);
             if (pattern.matcher(lastPart).matches())
             {
                 filteredTasks.add(task);
             }
 
         }
 
         return filteredTasks;*/
         return tasks;
     }
 
     public void addTask(TaskContribution taskContribution)
     {
         String taskName = taskContribution.getTaskName();
         String[] branches = taskName.split("\\.");
 
         TaskNode taskNode = _root;
 
         List<TaskNode> parents = new ArrayList<TaskNode>();
         parents.add(_root);
         for (int i = 0; i < branches.length - 1; i++)
         {
             String branch = branches[i];
             TaskNode node = taskNode.getBranch(branch);
             if (node == null)
             {
                 final TaskNode newNode = new TaskNode(branch, new ArrayList<TaskNode>(parents));
                 taskNode.addBranch(newNode);
                 node = newNode;
             }
             parents.add(0,node);
             taskNode = node;
         }
         
         taskNode.addTask(taskContribution);
 
     }
 
 }