package O_oGuy;
 
import java.applet.*;
import java.awt.*;
import java.util.*;
import java.io.*;
import java.awt.event.*;
 
public class Main extends Applet implements ActionListener, KeyListener {
 
    int[][] playingField;
 
    private enum move {
 
        left,
        right,
        up,
        down,
        none,
    }
 
    public enum tile {
 
        clear(0),
        wall(1),
        box(2),
        boulder(3),
        hole(4),
        player(5),
        exit(6),
        lasergun(7),
        laserbeam(8),
        buttonswitch(9),
        butterswitchoff(10),
        vanushingblock(11),
        fluff(12);
        private int value;
 
        tile(int set) {
            value = set;
        }
 
        public int tile() {
            return value;
        }
    }
    ArrayList<Point> myLasers = new ArrayList<Point>();
    private boolean boulderMovingState = false; //Converse, player movement must be allowed
    int playerX = 0;
    int playerY = 0;
    int boulderX = -1;
    int boulderY = -1;
    move boulderDirection = move.none;
    int currentLevel = 0;
    private Image img;
    private javax.swing.Timer t = new javax.swing.Timer(125, this);
    private Image backBuffer;
    private Graphics backG;
 
    private void restartLevel() {
        currentLevel--;
        nextLevel();
 
    }
 
    private void nextLevel() {
 
        //File myFile = new File("");
 
        try {
            //if (myFile.exists()) {
            if (true) {
                //Read the map!
                currentLevel++;
 
                //BufferedReader myReader = new BufferedReader(new FileReader(myFile));
 
                InputStream is = getClass().getResourceAsStream(currentLevel + ".map");
                InputStreamReader isr = new InputStreamReader(is);
                BufferedReader myReader = new BufferedReader(isr);
 
                int sizex = Integer.parseInt(myReader.readLine());
                int sizey = Integer.parseInt(myReader.readLine());
 
                playingField = new int[sizey][sizex];
 
                myLasers.clear();
 
                //char[] sep = { ',' };
 
                for (int y = 0; y < sizey; y++) {
 
                    String[] myLine = myReader.readLine().split(",");
 
                    for (int x = 0; x < sizex; x++) {
                        int value = Integer.parseInt(myLine[x].toString().trim());
 
                        if (value == tile.player.value) {
                            playerX = x;
                            playerY = y;
                            System.out.println("PLAYER SET");
                        }
 
                        if (value == tile.lasergun.value) {
                            myLasers.add(new Point(x, y));
                        }
 
                        if (value == -1) {
                            value = 0;
 
                        }
 
                        playingField[y][x] = value;
 
                    }
 
                }
                myReader.close();
 
                //this.Window.Title = "Noodles map # " + currentLevel;
                this.showStatus("O_o Guy map # " + currentLevel);
 
            }
 
 
        } catch (IOException e) {
            //IOException. This should NOT happen
            currentLevel--;
            System.err.println(e);
        }
 
    }
 
    private void movePlayer(int x, int y) {
        playingField[playerY + y][playerX + x] = 5;
        playingField[playerY][playerX] = 0;
        playerX = playerX + x;
        playerY = playerY + y;
    }
 
    private void movePlayer(move myMove) {
 
        int x = 0;
        int y = 0;
 
        //We're moving in some direction!
        if (myMove == move.left) {
            x = -1;
        } else if (myMove == move.right) {
            x = 1;
        } else if (myMove == move.up) {
            y = -1;
        } else if (myMove == move.down) {
            y = 1;
        }
 
        try {
            if (playingField[playerY + y][playerX + x] == tile.clear.value) {
                //Nothing there
                movePlayer(x, y);
            } else if (playingField[playerY + y][playerX + x] == tile.box.value) {
                //Box is there
 
                if ((playingField[playerY + 2 * y][playerX + 2 * x] == tile.clear.value) || //Nothing
                        (playingField[playerY + 2 * y][playerX + 2 * x] == tile.laserbeam.value) //Laser Beam
                        ) {
                    //Space behind it is clear
                    playingField[playerY + 2 * y][playerX + 2 * x] = tile.box.value;
                    movePlayer(x, y);
                }
            } else if (playingField[playerY + y][playerX + x] == tile.boulder.value) {
                // It's a boulder!
 
                if ((playingField[playerY + 2 * y][playerX + 2 * x] == tile.clear.value) || //Nothing 
                        (playingField[playerY + 2 * y][playerX + 2 * x] == tile.hole.value) || //Hole
                        (playingField[playerY + 2 * y][playerX + 2 * x] == tile.laserbeam.value) //Laser Beam 
                        ) {
                    //That we need to move!
 
                    boulderMovingState = true;
                    boulderX = playerX + x;
                    boulderY = playerY + y;
                    boulderDirection = myMove;
 
                    //The boulder moves one square. Then it keeps moving until it hits something.
                    moveBoulder();
 
                    //This needs to be done AFTER we move the boulder
                    movePlayer(x, y);
 
                }
            } else if (playingField[playerY + y][playerX + x] == tile.exit.value) {
                //NEXT LEVEL
                nextLevel();
            } else if (playingField[playerY + y][playerX + x] == tile.laserbeam.value) {
                //It's a laser! YOU DIE
                restartLevel();
 
            } else if (playingField[playerY + y][playerX + x] == tile.buttonswitch.value) {
                //It's the switch!
                clearVanishing();
            } else if (playingField[playerY + y][playerX + x] == tile.fluff.value) {
                //It's a piece of fluff
                movePlayer(x, y);
            }
 
        } catch (Exception e) {
            //DO NOTHING 
            //boulderMovingState = false;
        }
 
 
    }
 
    private void moveBoulder() {
        int x = 0;
        int y = 0;
 
        //We're moving in some direction!
        if (boulderDirection == move.left) {
            x = -1;
        }
        if (boulderDirection == move.right) {
            x = 1;
        }
        if (boulderDirection == move.up) {
            y = -1;
        }
        if (boulderDirection == move.down) {
            y = 1;
        }
 
 
        try {
            if ((playingField[boulderY + y][boulderX + x] == tile.clear.value) || //Nothing
                    (playingField[boulderY + y][boulderX + x] == tile.laserbeam.value) //Laser Beam
                    ) {
                playingField[boulderY + y][boulderX + x] = tile.boulder.value;
                playingField[boulderY][boulderX] = tile.clear.value;
                boulderX = boulderX + x;
                boulderY = boulderY + y;
 
            } else {
 
                boulderMovingState = false;
 
            }
 
            if (playingField[boulderY + y][boulderX + x] == tile.hole.value) //Hole
            {
                playingField[boulderY + y][boulderX + x] = tile.clear.value;
                playingField[boulderY][boulderX] = tile.clear.value;
                boulderMovingState = false;
 
            }
 
 
        } catch (Exception e) {
            //DO NOTHING
            boulderMovingState = false;
        }
 
 
    }
 
    protected void clearVanishing() {
        //Clear all boxes
        for (int x = 0; x < playingField.length; x++) {
            for (int y = 0; y < playingField[0].length; y++) {
                if (playingField[x][y] == tile.vanushingblock.value) {
                    playingField[x][y] = tile.clear.value;
                } else if (playingField[x][y] == tile.buttonswitch.value) {
                    playingField[x][y] = tile.butterswitchoff.value;
                }
 
            }
        }
    }
 
    protected void RenderLasers() {
 
        //Clear all the laser beams
        for (int x = 0; x < playingField.length; x++) {
            for (int y = 0; y < playingField[0].length; y++) {
                if (playingField[x][y] == tile.laserbeam.value) {
                    playingField[x][y] = tile.clear.value;
                }
 
            }
        }
 
        for (int i = 0; i < myLasers.size(); i++) {
            Point myLaserPoint = myLasers.get(i);
            drawOneLaser(myLaserPoint.x, myLaserPoint.y);
        }
 
    }
 
    protected void drawOneLaser(int x, int y) {
 
        int myLaserPointX = x;
        int myLaserPointY = y;
 
        //While next square is empty
        for (int i = x + 1; i < playingField[0].length; i++) {
            //The player is what is blocking the beam!
            if (playingField[myLaserPointY][myLaserPointX + i] == tile.player.value) {
                restartLevel();
            }
 
            if (playingField[myLaserPointY][myLaserPointX + i] == tile.clear.value) {
                playingField[myLaserPointY][myLaserPointX + i] = tile.laserbeam.value;
            } else {
                break;
            }
        }
    }
 
    @Override
    public void init() {
 
        addKeyListener(this);
 
        try {
            //img = getImage(new URL("noodles.png"));
 
            //img = getImage(new URL("http://sarah.plt1.com/upload/noodles.png"));
            //System.out.println(this.getCodeBase().getPath());
 
            img = getImage(this.getClass().getResource("art.png"));
 
        } catch (Exception e) {
            System.err.println(e);
        }
        nextLevel();
        backBuffer = createImage(800, 600);
        backG = backBuffer.getGraphics();
        backG.setColor(Color.BLACK);
 
        t.start(); //To make stuff work.
 
    }
 
    @Override
    public void update(Graphics g) {
        g.drawImage(backBuffer, 0, 0, this);
    }
 
    @Override
    public void paint(Graphics g) {
        update(g);
    }
 
    public void oldPaint(Graphics g) {
        if (playingField != null) {
 
            g.drawImage(img, 0, 0, playingField[0].length * 48, playingField.length * 48, 0, 0, 48, 48, null);
 
            RenderLasers();
 
            for (int x = 0; x < playingField.length; x++) {
                for (int y = 0; y < playingField[0].length; y++) {
                    //48 pixels!!!!
                    int step = playingField[x][y];
                    g.drawImage(img, y * 48, x * 48, y * 48 + 48, x * 48 + 48, step * 48, 0, step * 48 + 48, 48, null);
                }
            }
        }
    }
 
    public void actionPerformed(ActionEvent e) {
 
        if (boulderMovingState == true) {
            moveBoulder();
        }
 
        oldPaint(backG);
        repaint();
    }
 
    @SuppressWarnings("static-access")
    public void keyPressed(KeyEvent e) {
        if (!boulderMovingState) {
            if (e.getKeyCode() == e.VK_LEFT) {
                movePlayer(move.left);
            }
            if (e.getKeyCode() == e.VK_RIGHT) {
                movePlayer(move.right);
            }
 
            if (e.getKeyCode() == e.VK_UP) {
                movePlayer(move.up);
            }
            if (e.getKeyCode() == e.VK_DOWN) {
                movePlayer(move.down);
            }
            if (e.getKeyCode() == e.VK_R) {
                restartLevel();
            }
            if (e.getKeyCode() == e.VK_SCROLL_LOCK) {
                nextLevel();
            }
        }
 
    }
 
    public void keyReleased(KeyEvent e) {
    }
 
    public void keyTyped(KeyEvent e) {
    }
}