package de.jos.game.objects;
   
   import java.awt.AlphaComposite;
   import java.awt.Composite;
   import java.awt.Graphics2D;
   
   import com.golden.gamedev.object.AnimatedSprite;
   import com.golden.gamedev.object.Sprite;
   import com.golden.gamedev.object.Timer;
  import com.golden.gamedev.object.sprite.AdvanceSprite;
  
  import de.jos.game.logic.CombinationUtils;
  import de.jos.game.logic.AbstractGameLogic.Direction;
  
  public class Bullet extends SimplifiedBullet {
  
    private static final long serialVersionUID = -4465053527340777730L;
  
    // coordinate on the board, not the absolute coordinate on the board
    private int boardX;
    private int boardY;
  
    private int targetAbsoluteX;
    private int targetAbsoluteY;
  
    private int xdiff = 0;
    private int ydiff = 0;
  
    private Direction moveDirection = null;
  
    public enum State {
      WAITING, MOVING, DISSOLVING, FADEIN, FINISHED
    };
  
    private State actionState;
  
    // sprite for rotation and hovering
    private AnimatedSprite spriteHover = null;
    private AdvanceSprite spriteRotate = null;
    private Sprite spriteSmall = null;
  
    private Sprite currentSprite = null;
  
    private float transparency;
  
    private ResourceContainer resourceContainer = null;
  
    private final Timer timer = new Timer(65);
  
    private static final int[] DIRECTION_LEFT_UP = new int[] { 5, 4, 3, 2, 1, 0 };
    private static final int[] DIRECTION_RIGHT_DOWN = new int[] { 0, 1, 2, 3, 4, 5 };
  
    public Bullet(Integer color, BulletSize status) {
      super(color, status);
    }
  
    public Bullet() {
      setStatus(BulletSize.BIG);
    }
  
    public void init() {
      spriteRotate = new AdvanceSprite(getResourceContainer().getBulletSpriteRotate(getColor().intValue()));
      spriteRotate.setAnimate(true);
      spriteRotate.setLoopAnim(true);
      spriteRotate.setAnimationTimer(timer);
  
      spriteSmall = getResourceContainer().createAnimatedSpriteSmall(getColor());
  
      spriteHover = getResourceContainer().createAnimatedSprite(getColor());
  
      // set the current sprite (which will be rendered)
      if (isStatusBig()) {
        setCurrentSprite(spriteHover);
      } else if (isStatusSmall()) {
        setCurrentSprite(spriteSmall);
      }
  
      actionState = State.WAITING;
  
      // update and thus set the sprite coordinates
      updateSpriteCoordinates();
    }
  
    public void updateSpriteCoordinates() {
      // set the coordinates of the sprites
      setSpriteAbsolute(X_OFFSET + boardX * SPRITE_WIDTH, Y_OFFSET + boardY * SPRITE_HEIGHT);
    }
  
    public void render(Graphics2D graphics) {
      if (isDissolving() == true) {
        Composite oldComposite = graphics.getComposite();
  
        Composite cursorComposite = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, getTransparency());
        graphics.setComposite(cursorComposite);
        getCurrentSprite().render(graphics);
  
        graphics.setComposite(oldComposite);
      } else {
        getCurrentSprite().render(graphics);
     }
   }
 
   private void moveSprites(double deltax, double deltay) {
     spriteHover.move(deltax, deltay);
     spriteRotate.move(deltax, deltay);
     spriteSmall.move(deltax, deltay);
   }
 
   private void setSpriteAbsolute(int x, int y) {
     spriteHover.setX(x);
     spriteHover.setY(y);
     spriteRotate.setX(x);
     spriteRotate.setY(y);
     spriteSmall.setX(x);
     spriteSmall.setY(y);
   }
 
   public int getSpriteAbsoluteX() {
     return (int) getCurrentSprite().getX();
   }
 
   public int getSpriteAbsoluteY() {
     return (int) getCurrentSprite().getY();
   }
 
   public void update(long elapsedTime) {
 
     // Transparenz fuers DISSOLVING berechnen
     if (actionState == State.DISSOLVING) {
       transparency += TRANSPARENCY_INCREMENT;
       if (transparency < 0.0f) {
         transparency = 0.0f;
         setActionState(State.FINISHED);
       }
     }
 
     // Transparenz fuers FADEIN berechnen
     if (actionState == State.FADEIN) {
       System.out.println("fade");
       transparency -= TRANSPARENCY_INCREMENT;
       if (transparency > 1.0f) {
         transparency = 1.0f;
         setActionState(State.WAITING);
       }
     }
 
     if (actionState == State.MOVING) {
       moveSprites(xdiff * MOVING_FACTOR, ydiff * MOVING_FACTOR);
 
       // has the bullet reached the target coordinates ?
       if (getTargetAbsoluteX() == getSpriteAbsoluteX() && getTargetAbsoluteY() == getSpriteAbsoluteY()) {
 
         // if the last position was on the board -> shrink the bullet, else set
         // the hover sprite again
         if (CombinationUtils.isOnBoard(getBoardX(), getBoardY())) {
           setStatus(BulletSize.SMALL);
           setCurrentSprite(spriteSmall);
         } else {
           setCurrentSprite(spriteHover);
         }
 
         setBoardX((getTargetAbsoluteX() - X_OFFSET) / SPRITE_WIDTH);
         setBoardY((getTargetAbsoluteY() - Y_OFFSET) / SPRITE_HEIGHT);
         // reset targetX and targetY and isMoving
         targetAbsoluteX = -1;
         targetAbsoluteY = -1;
         actionState = State.WAITING;
       }
     }
 
     currentSprite.update(elapsedTime);
   }
 
   public boolean isMoving() {
     return actionState == State.MOVING;
   }
 
   public boolean isDissolving() {
     return actionState == State.DISSOLVING;
   }
 
   public float getTransparency() {
     return transparency;
   }
 
   public void setTransparency(float transparency) {
     this.transparency = transparency;
   }
 
   public ResourceContainer getResourceContainer() {
     return resourceContainer;
   }
 
   public void setResourceContainer(ResourceContainer resourceContainer) {
     this.resourceContainer = resourceContainer;
   }
 
   public boolean isFinished() {
     return actionState == State.FINISHED;
   }
 
   public Direction getMoveDirection() {
     return moveDirection;
   }
 
   public void setMoveDirection(Direction moveDirection) {
     this.moveDirection = moveDirection;
   }
 
   public void prepareMove() {
     if (moveDirection == Direction.LEFT || moveDirection == Direction.UP) {
       spriteRotate.setAnimationFrame(DIRECTION_LEFT_UP);
     } else {
       spriteRotate.setAnimationFrame(DIRECTION_RIGHT_DOWN);
     }
 
     xdiff = 0;
     ydiff = 0;
     if (moveDirection == Direction.DOWN) {
       ydiff = 1;
     } else if (moveDirection == Direction.UP) {
       ydiff = -1;
     } else if (moveDirection == Direction.LEFT) {
       xdiff = -1;
     } else if (moveDirection == Direction.RIGHT) {
       xdiff = 1;
     }
 
     setCurrentSprite(spriteRotate);
     actionState = State.MOVING;
   }
 
   private Sprite getCurrentSprite() {
     return currentSprite;
   }
 
   private void setCurrentSprite(Sprite currentSprite) {
     this.currentSprite = currentSprite;
   }
 
   public int getTargetAbsoluteX() {
     return targetAbsoluteX;
   }
 
   public void setTargetAbsoluteX(int targetAbsoluteX) {
     this.targetAbsoluteX = targetAbsoluteX;
   }
 
   public int getTargetAbsoluteY() {
     return targetAbsoluteY;
   }
 
   public void setTargetAbsoluteY(int targetAbsoluteY) {
     this.targetAbsoluteY = targetAbsoluteY;
   }
 
   public void resetHoverAnimation() {
     spriteHover.setAnimate(false);
     spriteHover.setFrame(0);
   }
 
   public void startHoverAnimation() {
     spriteHover.setAnimate(true);
     spriteHover.setLoopAnim(true);
   }
 
   public int getBoardX() {
     return boardX;
   }
 
   public void setBoardX(int boardX) {
     this.boardX = boardX;
   }
 
   public int getBoardY() {
     return boardY;
   }
 
   public void setBoardY(int boardY) {
     this.boardY = boardY;
   }
 
   public State getActionState() {
     return actionState;
   }
 
   public void setActionState(State actionState) {
     this.actionState = actionState;
   }
 
 }