package de.jos.game.logic;
   
   import java.util.ArrayList;
   import java.util.List;
   
   import de.jos.game.Constants;
   import de.jos.game.actions.ActionContainer;
   import de.jos.game.logic.AbstractGameLogic.Direction;
   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 AbstractGameBoard implements Constants {
  
    private Bullet[][] board = null;
    private Level level = null;
  
    private List<Bullet> bulletList = null;
  
    private ResourceContainer resourceContainer = null;
  
    private ActionContainer actionContainer = null;
  
    private AbstractGameLogic gameLogic = null;
  
    public AbstractGameBoard() {
      board = new Bullet[BOARD_WIDTH_X][BOARD_WIDTH_Y];
      bulletList = new ArrayList<Bullet>();
    }
  
    public void updateBoard() {
      for (int x = 0; x < BOARD_WIDTH_X; x++)
        for (int y = 0; y < BOARD_WIDTH_Y; y++) {
          board[x][y] = null;
        }
  
      for (Bullet tmpBullet : bulletList) {
        board[tmpBullet.getBoardX()][tmpBullet.getBoardY()] = tmpBullet;
      }
      
      /*
      Iterator<Bullet> iter = bulletList.iterator();
      while (iter.hasNext()) {
        Bullet tmpBullet = iter.next();
        board[tmpBullet.getBoardX()][tmpBullet.getBoardY()] = tmpBullet;
      }
      */
    }
  
    public void initLevel(Level level) {
      this.level = level;
      bulletList.clear();
      bulletList.addAll(level.getBullets());
    }
  
    public Bullet getBullet(int x, int y) {
      if ((x < BOARD_WIDTH_X && x >= 0) && (y < BOARD_WIDTH_Y && y >= 0)) {
        return board[x][y];
      }
      return null;
    }
  
    public void setBullet(int x, int y, Bullet bullet) {
      board[x][y] = bullet;
    }
  
    // TODO noch ueberarbeiten -> wo werden die bullets jetzt
    // gehalten ? in der liste, oder im array
    public void removeBullet(int x, int y) {
      board[x][y] = null;
    }
  
    public Object[] isMovePossible(Direction direction, Bullet bullet) {
  
      Object returnValues[] = new Object[5];
      returnValues[0] = Boolean.FALSE;
  
      if (SimplifiedBullet.BulletSize.SMALL.equals(bullet.getStatus())) {
        return returnValues;
      }
  
      int x = bullet.getBoardX();
      int y = bullet.getBoardY();
  
      int xOriginal = x;
      int yOriginal = y;
  
      int xdiff = 0;
      int ydiff = 0;
  
      if (direction == Direction.DOWN) {
        ydiff = 1;
      } else if (direction == Direction.UP) {
        ydiff = -1;
      } else if (direction == Direction.LEFT) {
        xdiff = -1;
      } else if (direction == Direction.RIGHT) {
        xdiff = 1;
     }
 
     boolean blockingBulletFound = false;
 
     // find the next bullet that will block the movement
     while (true) {
       x += xdiff;
       y += ydiff;
 
       if (x < 2 || x > BOARD_WIDTH_X - 2 || y < 2 || y > BOARD_WIDTH_Y - 2) {
         System.out.println("breaking");
         break;
       }
 
       if (board[x][y] != null) {
         blockingBulletFound = true;
         break;
       }
     }
 
     // if blocking bullet was found
     if (blockingBulletFound == true) {
       // check if the bullet was on the board
       if (x < 2 || x > 10 || y < 2 || y > 10) {
         blockingBulletFound = false;
       }
       // check if there is at least one empty space between the bullets
       if (Math.abs(x - xOriginal) <= 1 && Math.abs(y - yOriginal) <= 1) {
         blockingBulletFound = false;
       }
     }
 
     // returnValues array fuellen
     returnValues[0] = Boolean.valueOf(blockingBulletFound);
     returnValues[1] = Integer.valueOf(x - xdiff);
     returnValues[2] = Integer.valueOf(y - ydiff);
     returnValues[3] = Integer.valueOf(xdiff);
     returnValues[4] = Integer.valueOf(ydiff);
 
     return returnValues;
   }
 
   public void resetGlowAnimation(int ignoreX, int ignoreY) {
     for (int x = 0; x < BOARD_WIDTH_X; x++)
       for (int y = 0; y < BOARD_WIDTH_Y; y++) {
         if (board[x][y] != null && !(ignoreX == x && ignoreY == y)) {
           board[x][y].resetHoverAnimation();
         }
       }
   }
 
   public ResourceContainer getResourceContainer() {
     return resourceContainer;
   }
 
   public void setResourceContainer(ResourceContainer resourceContainer) {
     this.resourceContainer = resourceContainer;
   }
 
   public List<Bullet> getBulletList() {
     List<Bullet> bullets = new ArrayList<Bullet>();
     for (int x = 0; x < BOARD_WIDTH_X; x++) {
       for (int y = 0; y < BOARD_WIDTH_Y; y++) {
         if (board[x][y] != null) {
           bullets.add(board[x][y]);
         }
       }
     }
 
     return bullets;
   }
 
   public Bullet[][] getBoard() {
     return board;
   }
 
   public Level getLevel() {
     return level;
   }
 
   public ActionContainer getActionContainer() {
     return actionContainer;
   }
 
   public void setActionContainer(ActionContainer actionContainer) {
     this.actionContainer = actionContainer;
   }
 
   public AbstractGameLogic getGameLogic() {
     return gameLogic;
   }
 
   public void setGameLogic(AbstractGameLogic gameLogic) {
     this.gameLogic = gameLogic;
   }
 
 }