import javax.microedition.lcdui.*;
import java.util.*;

class RabbitCanvas extends Canvas{

    public static final int CELL_COUNT=8;

    public static final int WOLF_COUNT=4;

    public static final int BEFORE_INIT=0;
    public static final int AFTER_INIT=1;
    public static final int WOLF_SELECTED=2;
    public static final int WOLF_MOVES=3;
    public static final int RABBIT_LOST=4;
    public static final int RABBIT_WON=5;

    public static final int WOLF_DIRECTION_FIRST=0;
    public static final int WOLF_DIRECTION_UP_LEFT=0;
    public static final int WOLF_DIRECTION_UP_RIGHT=1;
    public static final int WOLF_DIRECTION_LAST=1;

    public static final int RABBIT_DIRECTION_FIRST=0;
    public static final int RABBIT_DIRECTION_UP_LEFT=0;
    public static final int RABBIT_DIRECTION_UP_RIGHT=1;
    public static final int RABBIT_DIRECTION_DOWN_RIGHT=2;
    public static final int RABBIT_DIRECTION_DOWN_LEFT=3;
    public static final int RABBIT_DIRECTION_LAST=3;

    int cellSize;
    int buttonSize;
    int xOffset;
    int yOffset;
    int gameState=BEFORE_INIT;
    int activeWolf=0;
    int oldActiveWolf=0;
    int wolfDirection=WOLF_DIRECTION_FIRST;
    int oldWolfDirection=WOLF_DIRECTION_FIRST;

    Random randomizer = new Random();

    Rabbit rabbit = new Rabbit(4,0);
    Wolf wolfs[]= {new Wolf(1,7), new Wolf(3,7), new Wolf(5,7), new Wolf(7,7)};

    // When the canvas is shown
    public void showNotify()
    {
    }

    // When the canvas is hidden
    public void hideNotify()
    {
    }

    private int getCellSize()
    {
        if (getWidth() > getHeight())
        {
            return getHeight() / CELL_COUNT;
        }
        else
        {
            return getWidth() / CELL_COUNT;
        }
    }

    private int getXOffset()
    {
        return (getWidth() - cellSize*CELL_COUNT) / 2;
    }

    private int getYOffset()
    {
        return (getHeight() - cellSize*CELL_COUNT) / 2;
    }

    private void initCoordinates()
    {
        cellSize = getCellSize();
        buttonSize = cellSize/3;
        xOffset = getXOffset();
        yOffset = getYOffset();
    }

    private void clearScreen(Graphics g)
    {
        g.setColor(255,255,255);
        g.fillRect(0,0,getWidth(),getHeight());
    }

    private int cellColor(int x, int y)
    {
        if (y%2 == 0)
        {
            if (x%2 == 0)
            {
                return Button.COLOR_BLACK;
            }
        }
        else
        {
            if (x%2 == 1)
            {
                return Button.COLOR_BLACK;
            }
        }
        return Button.COLOR_WHITE;
    }

    private int gridPosition(int pos, int offset)
    {
        return pos*cellSize+offset;
    }

    private void drawGrid(Graphics g)
    {
        g.setColor(0,0,0);
        int calculatedX;
        int calculatedY;

        for (int y=0; y<CELL_COUNT; y++)
        {
            calculatedY=gridPosition(y, yOffset);

            for (int x=0; x<CELL_COUNT; x++)
            {
                if (cellColor(x,y)==Button.COLOR_BLACK)
                {
                    calculatedX=gridPosition(x, xOffset);
                    g.fillRect(calculatedX, calculatedY, cellSize, cellSize);
                }
            }
        }

    }

    private void drawSelection(int x, int y, Graphics g)
    {
        int calculatedX=gridPosition(x, xOffset)+1;
        int calculatedY=gridPosition(y, yOffset)+1;

        g.drawRect(calculatedX, calculatedY, cellSize-3, cellSize-3);
    }

    private void showSelection(int x, int y, Graphics g)
    {
        g.setColor(255,255,255);
        drawSelection(x, y, g);
    }

    private void hideSelection(int x, int y, Graphics g)
    {
        g.setColor(0,0,0);
        drawSelection(x, y, g);
    }

    private void drawButton(Button button, Graphics g)
    {
        int calculatedX=gridPosition(button.getX(), xOffset)+buttonSize;
        int calculatedY=gridPosition(button.getY(), yOffset)+buttonSize;

        if (button.getColor()==cellColor(button.getX(), button.getY()))
        {
            g.drawRect(calculatedX, calculatedY, buttonSize, buttonSize);
        }
        else
        {
            g.fillRect(calculatedX, calculatedY, buttonSize, buttonSize);
        }
    }

    private void showButtons(Graphics g)
    {
        g.setColor(255,255,255);

        drawButton(rabbit, g);
        for (int i=0; i<WOLF_COUNT; i++)
        {
            drawButton(wolfs[i], g);
        }
    }

    private void hideButtons(Graphics g)
    {
        g.setColor(0,0,0);

        drawButton(rabbit, g);
        for (int i=0; i<WOLF_COUNT; i++)
        {
            drawButton(wolfs[i], g);
        }
    }

    private void autoMoveRabbit()
    {
        int rnd=Math.abs(randomizer.nextInt()%(RABBIT_DIRECTION_LAST+1));
        int rabbitDirection=nextRabbitDirection(rnd);

        if (rabbitDirection==-1)
        {
            // rabbit has lost the game...
            gameState=RABBIT_LOST;
            return;
        }

        rabbit.setCoordinates(getRabbitDirectionX(rabbitDirection), getRabbitDirectionY(rabbitDirection));

        // find the wolf Y coordinate, closest to their start
        int maxWolfY=0;
        for (int i=0; i<WOLF_COUNT; i++)
        {
            if (maxWolfY<wolfs[i].getY())
            {
                maxWolfY=wolfs[i].getY();
            }
        }

        if (rabbit.getY()>=maxWolfY)
        {
            // rabbit has won the game...
            gameState=RABBIT_WON;
        }

    }

    protected void paint(Graphics g)
    {
        //System.out.println("gameState: "+gameState);
        if (gameState==BEFORE_INIT)
        {
            initCoordinates();
            clearScreen(g);
            drawGrid(g);
            showButtons(g);
            gameState=AFTER_INIT;

            showSelection(wolfs[activeWolf].getX(), wolfs[activeWolf].getY(), g);
        }
        else if (gameState==AFTER_INIT)
        {
            showButtons(g);
            hideSelection(wolfs[oldActiveWolf].getX(), wolfs[oldActiveWolf].getY(), g);
            showSelection(wolfs[activeWolf].getX(), wolfs[activeWolf].getY(), g);
        }
        else if (gameState==WOLF_SELECTED)
        {
            hideSelection(getWolfDirectionX(oldWolfDirection), getWolfDirectionY(oldWolfDirection), g);
            showSelection(getWolfDirectionX(wolfDirection), getWolfDirectionY(wolfDirection), g);
        }
        else if (gameState==WOLF_MOVES)
        {
            hideButtons(g);
            hideSelection(wolfs[activeWolf].getX(), wolfs[activeWolf].getY(), g);
            hideSelection(getWolfDirectionX(wolfDirection), getWolfDirectionY(wolfDirection), g);

            // move wolf
            wolfs[activeWolf].setCoordinates(getWolfDirectionX(wolfDirection), getWolfDirectionY(wolfDirection));

            // move rabbit
            autoMoveRabbit(); // now, the game state may change inside this function... bad bad programming practices...

            showButtons(g);
            hideSelection(wolfs[oldActiveWolf].getX(), wolfs[oldActiveWolf].getY(), g);
            showSelection(wolfs[activeWolf].getX(), wolfs[activeWolf].getY(), g);

            if (gameState==RABBIT_LOST)
            {
                g.setColor(255,255,255);
                g.fillRect(0,0,getWidth(),getHeight());
                g.setColor(0,0,0);
                g.drawString("You Won!", getWidth()/2, getHeight()/2, Graphics.TOP|Graphics.HCENTER);
            }
            else if (gameState==RABBIT_WON)
            {
                g.setColor(0,0,0);
                g.fillRect(0,0,getWidth(),getHeight());
                g.setColor(255,255,255);
                g.drawString("Game Over!", getWidth()/2, getHeight()/2, Graphics.TOP|Graphics.HCENTER);
            }
            else
            {
                gameState=AFTER_INIT;
            }
        }
    }

    private boolean isFreePosition(int x, int y)
    {
        if (x<0 || y<0 || x>=CELL_COUNT || y>=CELL_COUNT)
        {
            return false;
        }

        if (rabbit.getX()==x && rabbit.getY()==y)
        {
            return false;
        }

        for (int i=0; i<WOLF_COUNT; i++)
        {
            if (wolfs[i].getX()==x && wolfs[i].getY()==y)
            {
                return false;
            }
        }
        
        return true;
    }

    private int getWolfDirectionX(int direction)
    {
        if (direction==WOLF_DIRECTION_UP_LEFT)
        {
            return wolfs[activeWolf].getX()-1;
        }
        else
        {
            return wolfs[activeWolf].getX()+1;
        }
    }

    private int getWolfDirectionY(int direction)
    {
        return wolfs[activeWolf].getY()-1;
    }

    private int getRabbitDirectionX(int direction)
    {
        if (direction==RABBIT_DIRECTION_UP_LEFT || direction==RABBIT_DIRECTION_DOWN_LEFT)
        {
            return rabbit.getX()-1;
        }
        else
        {
            return rabbit.getX()+1;
        }
    }

    private int getRabbitDirectionY(int direction)
    {
        if (direction==RABBIT_DIRECTION_UP_LEFT || direction==RABBIT_DIRECTION_UP_RIGHT)
        {
            return rabbit.getY()-1;
        }
        else
        {
            return rabbit.getY()+1;
        }
    }
    private int nextRabbitDirection(int direction)
    {
        direction++;
        if (direction>RABBIT_DIRECTION_LAST)
        {
            direction=RABBIT_DIRECTION_FIRST;
        }

        int count=0;
        while ( !isFreePosition(getRabbitDirectionX(direction), getRabbitDirectionY(direction)) )
        {
            direction++;
            if (direction>RABBIT_DIRECTION_LAST)
            {
                direction=RABBIT_DIRECTION_FIRST;
            }
            if (count>=RABBIT_DIRECTION_LAST)
            {
                return -1;
            }
            count++;
        }
        return direction;
    }

    private int previousRabbitDirection(int direction)
    {
        direction--;
        if (direction<RABBIT_DIRECTION_FIRST)
        {
            direction=RABBIT_DIRECTION_LAST;
        }

        int count=0;
        while ( !isFreePosition(getRabbitDirectionX(direction), getRabbitDirectionY(direction)) )
        {
            direction--;
            if (direction<RABBIT_DIRECTION_FIRST)
            {
                direction=RABBIT_DIRECTION_LAST;
            }
            if (count>=RABBIT_DIRECTION_LAST)
            {
                return -1;
            }
            count++;
        }
        return direction;
    }

    private int nextWolfDirection(int direction)
    {
        direction++;
        if (direction>WOLF_DIRECTION_LAST)
        {
            direction=WOLF_DIRECTION_FIRST;
        }

        while ( !isFreePosition(getWolfDirectionX(direction), getWolfDirectionY(direction)) )
        {
            direction++;
            if (direction>WOLF_DIRECTION_LAST)
            {
                direction=WOLF_DIRECTION_FIRST;
            }
        }
        return direction;
    }

    private int previousWolfDirection(int direction)
    {
        direction--;
        if (direction<WOLF_DIRECTION_FIRST)
        {
            direction=WOLF_DIRECTION_LAST;
        }

        while ( !isFreePosition(getWolfDirectionX(direction), getWolfDirectionY(direction)) )
        {
            direction--;
            if (direction<WOLF_DIRECTION_FIRST)
            {
                direction=WOLF_DIRECTION_LAST;
            }
        }
        return direction;
    }

    protected void keyPressed(int kood)
    {
        if(getGameAction(kood)==Canvas.LEFT)
        {
            if (gameState==WOLF_SELECTED)
            {
                oldWolfDirection=wolfDirection;
                wolfDirection=previousWolfDirection(wolfDirection);
            }
            else
            {
                oldActiveWolf=activeWolf;
                activeWolf--;
                if (activeWolf<0)
                {
                    activeWolf=WOLF_COUNT-1;
                }
            }
        }
        else if(getGameAction(kood)==Canvas.RIGHT)
        {
            if (gameState==WOLF_SELECTED)
            {
                oldWolfDirection=wolfDirection;
                wolfDirection=nextWolfDirection(wolfDirection);
            }
            else
            {
                oldActiveWolf=activeWolf;
                activeWolf++;
                if (activeWolf>=WOLF_COUNT)
                {
                    activeWolf=0;
                }
            }
        }
        else if(getGameAction(kood)==Canvas.UP)
        {
        }
        else if(getGameAction(kood)==Canvas.DOWN)
        {
        }
        else if(getGameAction(kood)==Canvas.FIRE)
        {
            if (gameState==WOLF_SELECTED)
            {
                gameState=WOLF_MOVES;
            }
            else
            {
                // if wolf has space to move
                boolean canMoveLeft=isFreePosition(getWolfDirectionX(WOLF_DIRECTION_UP_LEFT), 
                                                   getWolfDirectionY(WOLF_DIRECTION_UP_LEFT));
                boolean canMoveRight=isFreePosition(getWolfDirectionX(WOLF_DIRECTION_UP_RIGHT), 
                                                    getWolfDirectionY(WOLF_DIRECTION_UP_RIGHT));
                if (canMoveLeft || canMoveRight)
                {
                    gameState=WOLF_SELECTED;

                    oldWolfDirection=WOLF_DIRECTION_LAST;
                    oldWolfDirection=nextWolfDirection(oldWolfDirection);
    
                    wolfDirection=oldWolfDirection;
                }
            }
        }


        repaint();
    }

}