package de.jos.game.logic;
   
   import java.awt.Graphics2D;
   import java.awt.event.MouseEvent;
   
   import org.apache.commons.lang.StringUtils;
   import org.apache.commons.logging.Log;
   import org.apache.commons.logging.LogFactory;
   
  import com.golden.gamedev.GameObject;
  import com.golden.gamedev.engine.BaseInput;
  import com.golden.gamedev.object.AnimatedSprite;
  
  import de.jos.game.Constants;
  import de.jos.game.actions.SpecialActionEvent;
  import de.jos.game.objects.Bullet;
  import de.jos.game.objects.ResourceContainer;
  import de.jos.game.objects.SimplifiedBullet;
  import de.jos.game.xml.Level;
  
  public abstract class AbstractGameLogic implements Constants {
  
    private static Log log = LogFactory.getLog(AbstractGameLogic.class);
  
    private ResourceContainer resourceContainer = null;
    private Level level = null;
  
    private AbstractGameBoard board = null;
  
    private int mouseState = MOUSE_STATE_NOT_PRESSED;
  
    private Integer xDownPressed = null;
    private Integer yDownPressed = null;
  
    private Integer xDownReleased = null;
    private Integer yDownReleased = null;
  
    private boolean gameFinished = false;
    private boolean gameSolved = false;
  
    // possible move directions
    public enum Direction {
      UP, RIGHT, DOWN, LEFT
    };
  
    /***
     * Rendert das Spielfeld mit allen Grafiken
     * 
     * @param graphics
     *          Das Grahpics2D Objekt.
     * @param gameObject
     *          Das Engine Game Objekt.
     */
    public void render(Graphics2D graphics, GameObject gameObject) {
  
      // Hintergrund rendern
      renderBackground(graphics);
  
      // Bullets rendern
      for (Bullet tmpBullet : board.getBulletList()) {
        tmpBullet.render(graphics);
      }
  
      // actionContainer rendern
      getBoard().getActionContainer().render(graphics, gameObject);
    }
  
    /***
     * Methode rendert zusaetzlich modusspezifische Backgrounds.
     * 
     * @param graphics
     *          Der Graphics Context
     */
    public abstract void renderBackground(Graphics2D graphics);
  
    public void update(long elapsedTime, GameObject gameObject) {
  
      // actionContainer updaten
      getBoard().getActionContainer().update(elapsedTime, gameObject);
  
      // werden im container blockierende actions ausgefuehrt
      if (getBoard().getActionContainer().isBlocking() == true) {
        // System.out.println("blocking action");
        return;
      }
  
      // update the bullets
      for (Bullet tmpBullet : board.getBulletList()) {
        tmpBullet.update(elapsedTime);
      }
  
      // animation nur zuruecksetzen und/oder neue animation starten
      // wenn keine taste gedrueckt ist
      if (!(mouseState == MOUSE_STATE_PRESSED && gameObject.bsInput.isMouseDown(MouseEvent.BUTTON1))) {
        int mouseX = gameObject.getMouseX();
        int mouseY = gameObject.getMouseY();
        int x = ((mouseX - Bullet.X_OFFSET) / Bullet.SPRITE_WIDTH);
        int y = ((mouseY - Bullet.Y_OFFSET) / Bullet.SPRITE_HEIGHT);
  
       // TODO keine animation fuer rand bloecke
       board.resetGlowAnimation(x, y);
 
       if (BoardUtils.isWithinSelectableBounds(x, y)) {
         Bullet tmpBullet = board.getBullet(x, y);
         if (tmpBullet != null && !tmpBullet.getStatus().equals(SimplifiedBullet.BulletSize.SMALL)) {
           tmpBullet.startHoverAnimation();
         }
       }
 
     }
 
     if (gameObject.bsInput.getMousePressed() != BaseInput.NO_BUTTON
         && gameObject.bsInput.isMouseDown(MouseEvent.BUTTON1) == true) {
       System.out.println("bla");
       xDownPressed = gameObject.getMouseX();
       yDownPressed = gameObject.getMouseY();
       mouseState = MOUSE_STATE_PRESSED;
     }
 
     // if (mouseState == MOUSE_STATE_PRESSED &&
     // gameObject.bsInput.isMouseDown(MouseEvent.BUTTON1)) {
     // System.out.println("gedrückt");
     // }
 
     if (mouseState == MOUSE_STATE_PRESSED && gameObject.bsInput.isMouseDown(MouseEvent.BUTTON1) == false) {
 
       xDownReleased = gameObject.getMouseX();
       yDownReleased = gameObject.getMouseY();
       mouseState = MOUSE_STATE_NOT_PRESSED;
 
       // direction ermitteln !!
       int xDiff = (xDownPressed - xDownReleased);
       int yDiff = (yDownPressed - yDownReleased);
 
       // wird diff ueberhaupt beruecksichtigt ??
       xDiff = (Math.abs(xDiff) > MOVE_DIFF) ? xDiff : 0;
       yDiff = (Math.abs(yDiff) > MOVE_DIFF) ? yDiff : 0;
 
       // nur groesseres diff beruecksichtigen
       Direction direction = null;
       if (Math.abs(xDiff) > Math.abs(yDiff)) {
         direction = (xDiff > 0 ? Direction.LEFT : Direction.RIGHT);
       } else {
         direction = (yDiff > 0 ? Direction.UP : Direction.DOWN);
       }
 
       System.out.println("direction : " + direction);
       int x = ((xDownPressed - Bullet.X_OFFSET) / Bullet.SPRITE_WIDTH);
       int y = ((yDownPressed - Bullet.Y_OFFSET) / Bullet.SPRITE_HEIGHT);
       // System.out.println("x : " + x);
       // System.out.println("y : " + y);
       if (BoardUtils.isWithinSelectableBounds(x, y)) {
         // System.out.println("within bounds !!");
         Bullet tmpBullet = board.getBullet(x, y);
         if (tmpBullet != null && direction != null) {
           Object[] o = board.isMovePossible(direction, tmpBullet);
           if (((Boolean) o[0]).equals(Boolean.TRUE)) {
 
             // set the direction in which we are moving
             tmpBullet.setMoveDirection(direction);
 
             tmpBullet.setTargetAbsoluteX(Bullet.X_OFFSET + ((Integer) o[1]) * Bullet.SPRITE_WIDTH);
             tmpBullet.setTargetAbsoluteY(Bullet.Y_OFFSET + ((Integer) o[2]) * Bullet.SPRITE_HEIGHT);
 
             tmpBullet.prepareMove();
 
             // TODO create by factory
             SpecialActionEvent bulletMovingAction = getSpecificBulletMovingAction(tmpBullet);
 
             // add the moving action to the actionContainer
             getBoard().getActionContainer().addAction(bulletMovingAction);
 
             // increment the number of moves if in puzzle mode
             if (Constants.MODE_PUZZLE.equals(getLevel().getMode())) {
               getBoard().getActionContainer().getActionMoveStatistics().updateMoves(1);
 
               // update the board history so we can perform an undo
               ((PuzzleGameBoard) getBoard()).updateBoardHistory();
             }
 
             getBoard().removeBullet(x, y);
           }
         }
       } else {
         log.debug("NOT within bounds !");
       }
 
     }
 
   }
 
   protected abstract SpecialActionEvent getSpecificBulletMovingAction(Bullet bullet);
 
   public void finish(GameObject gameObject) {
     gameObject.finish();
   }
 
   protected String getString(String key) {
     return StringUtils.upperCase(getResourceContainer().getLabelResources().getString(key));
   }
 
   protected String getString(String key, String appendString) {
     return getString(key) + appendString;
   }
 
   public ResourceContainer getResourceContainer() {
     return resourceContainer;
   }
 
   public void setResourceContainer(ResourceContainer resourceContainer) {
     this.resourceContainer = resourceContainer;
   }
 
   public AbstractGameBoard getBoard() {
     return board;
   }
 
   public void setBoard(AbstractGameBoard board) {
     this.board = board;
   }
 
   public Level getLevel() {
     return level;
   }
 
   public void setLevel(Level level) {
     this.level = level;
   }
 
   public boolean isGameFinished() {
     return gameFinished;
   }
 
   public void setGameFinished(boolean gameFinished, boolean solved) {
     this.gameFinished = gameFinished;
     this.gameSolved = solved;
   }
 
   public abstract void init();
 
   protected static final class RenderedButton {
 
     private AnimatedSprite sprite = null;
     private int nextGameId = -1;
 
     public AnimatedSprite getSprite() {
       return sprite;
     }
 
     public void setSprite(AnimatedSprite sprite) {
       this.sprite = sprite;
     }
 
     private int getNextGameId() {
       return nextGameId;
     }
 
     public void setNextGameId(int nextGameId) {
       this.nextGameId = nextGameId;
     }
 
     public void update(long elapsedTime, GameObject gameObject) {
       sprite.update(elapsedTime);
       // workaround: auf frame 0 setzen da es sonst zu einem
       // flicker effekt kommt
       sprite.setFrame(0);
       if (gameObject.checkPosMouse(sprite, true)) {
         sprite.setFrame(1);
         if (gameObject.bsInput.isMouseDown(MouseEvent.BUTTON1)) {
           gameObject.parent.nextGameID = getNextGameId();
           gameObject.finish();
         }
       } else {
         sprite.setFrame(0);
       }
     }
 
     public void render(Graphics2D graphics) {
       sprite.render(graphics);
     }
   }
 
   public boolean isGameSolved() {
     return gameSolved;
   }
 
 }