package de.jos.game.actions;
   
   import java.awt.Graphics2D;
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.Iterator;
   import java.util.List;
   
   import com.golden.gamedev.GameObject;
  
  import de.jos.game.actions.permanent.ActionCanister;
  import de.jos.game.actions.permanent.ActionCountdown;
  import de.jos.game.actions.permanent.ActionMoveStatistics;
  import de.jos.game.actions.permanent.ActionPuzzleSolvedCheck;
  import de.jos.game.actions.permanent.ActionStatistics;
  import de.jos.game.actions.permanent.SpecialEventPermanent;
  import de.jos.game.logic.AbstractGameBoard;
  import de.jos.game.objects.ResourceContainer;
  
  public class ActionContainer {
  
    // is the action blocking the selection of the bullets
    private boolean blocking = false;
    private static final ActionComparator ACTION_COMPARATOR = new ActionComparator();
  
    // list that contains all the special actions
    private List<SpecialActionEvent> specialActionList = new ArrayList<SpecialActionEvent>();
  
    private List<SpecialEventPermanent> permanentActionList = new ArrayList<SpecialEventPermanent>();
  
    private ActionCanister actionCanister = null;
    private ActionStatistics actionStatistics = null;
    private ActionCountdown actionCountdown = null;
    private ActionPuzzleSolvedCheck actionPuzzleSolved = null;
    private ActionMoveStatistics actionMoveStatistics = null;
  
    public ActionContainer(ResourceContainer resourceContainer, AbstractGameBoard gameBoard, boolean puzzleMode) {
      if (puzzleMode == false) {
        // the permanent actions are only required for the infinite game mode
        actionCanister = new ActionCanister(gameBoard);
        actionCanister.setResourceContainer(resourceContainer);
        actionCanister.init();
        permanentActionList.add(actionCanister);
  
        actionStatistics = new ActionStatistics();
        actionStatistics.setResourceContainer(resourceContainer);
        actionStatistics.init();
        permanentActionList.add(actionStatistics);
  
        actionCountdown = new ActionCountdown(gameBoard);
        actionCountdown.setResourceContainer(resourceContainer);
        actionCountdown.init();
        permanentActionList.add(actionCountdown);
      } else {
        actionPuzzleSolved = new ActionPuzzleSolvedCheck(gameBoard);
        actionPuzzleSolved.setResourceContainer(resourceContainer);
        actionPuzzleSolved.init();
        permanentActionList.add(actionPuzzleSolved);
        
        actionMoveStatistics = new ActionMoveStatistics();
        actionMoveStatistics.setResourceContainer(resourceContainer);
        actionMoveStatistics.init();
        permanentActionList.add(actionMoveStatistics);
      }
    }
  
    public void render(Graphics2D graphics, GameObject gameObject) {
      // list of new special events
      List<SpecialActionEvent> newSpecialActionEvents = new ArrayList<SpecialActionEvent>();
      // render all the special actions
      Iterator<SpecialActionEvent> iter = getSpecialActionList().iterator();
      while (iter.hasNext()) {
        SpecialActionEvent tmpActionEvent = iter.next();
        tmpActionEvent.render(graphics, gameObject);
        // if the action is finished, remove the actionEvent
        if (tmpActionEvent.isFinished() == true) {
          // perform the final cleanup action
          tmpActionEvent.cleanup();
          iter.remove();
          System.out.println("removing event ; " + tmpActionEvent.getName());
          // get the new special event and add them to a list
          List<SpecialActionEvent> tmpList = tmpActionEvent.getNewSpecialEventList();
          if (tmpList != null) {
            newSpecialActionEvents.addAll(tmpList);
          }
        }
      }
  
      for (SpecialActionEvent tmpAction : getPermanentActionList()) {
        tmpAction.render(graphics, gameObject);
        if (tmpAction.isBlocking() == true) {
          blocking = true;
        }
      }
  
      // add the new special events
      addActions(newSpecialActionEvents);
      // getSpecialActionList().addAll(newSpecialActionEvents);
    }
 
   public void update(long elapsedTime, GameObject gameObject) {
     boolean specialActionListEmpty = getSpecialActionList().isEmpty();
     blocking = false;
 
     for (SpecialActionEvent tmpAction : getSpecialActionList()) {
       tmpAction.update(elapsedTime, gameObject);
       if (tmpAction.isBlocking() == true) {
         blocking = true;
       }
     }
 
     // special event list der permanenten actions hier besonders behandeln,
     // da es hier kein finish gibt
     for (SpecialEventPermanent tmpAction : getPermanentActionList()) {
       tmpAction.update(elapsedTime, gameObject, specialActionListEmpty);
       if (tmpAction.isBlocking() == true) {
         blocking = true;
       }
 
       // queue der special events loeschen, da diese sonst pro update
       // hinzugefuegt werden
       addActions(tmpAction.getNewSpecialEventList());
       tmpAction.getNewSpecialEventList().clear();
     }
   }
 
   public void addAction(SpecialActionEvent actionEvent) {
     if (actionEvent != null) {
       getSpecialActionList().add(actionEvent);
       actionEvent.init();
       Collections.sort(getSpecialActionList(), ACTION_COMPARATOR);
     }
   }
 
   public void addActions(List<SpecialActionEvent> newActions) {
     if (newActions.isEmpty() == false) {
       for (SpecialActionEvent tmpAction : newActions) {
         if (tmpAction != null) {
           System.out.println("adding actionEvent : " + tmpAction.getName());
           addAction(tmpAction);
         }
       }
     }
   }
 
   public boolean isBlocking() {
     return blocking;
   }
 
   public void setBlocking(boolean blocking) {
     this.blocking = blocking;
   }
 
   private List<SpecialActionEvent> getSpecialActionList() {
     return specialActionList;
   }
 
   private List<SpecialEventPermanent> getPermanentActionList() {
     return permanentActionList;
   }
 
   public ActionCanister getActionCanister() {
     return actionCanister;
   }
 
   public ActionStatistics getActionStatistics() {
     return actionStatistics;
   }
 
   public ActionCountdown getActionCountdown() {
     return actionCountdown;
   }
 
   public ActionMoveStatistics getActionMoveStatistics() {
     return actionMoveStatistics;
   }
   
 }