/**
 * World.java
 *
 * @author Zuo Yan
 * @version 1.2
 */

package world;

import java.util.ArrayList;
import java.util.Iterator;

import java.awt.Graphics2D;
import java.awt.Shape;
import java.awt.Dimension;
import java.awt.geom.AffineTransform;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.KeyListener;
import java.awt.event.KeyEvent;
import javax.swing.JPanel;
import javax.swing.Timer;

import background.*;
import vehicle.*;

/**
 * The World class contains all the world management code.<p>
 * 
 * It handles the events that occur when buttons are clicked or
 * keys are pressed.<p>
 * 
 * It governs the speed of the simulation and calls necessary methods
 * of objects in the world.
 */
public class World implements ActionListener, KeyListener {
    private WinEnv environment; // Our windows and buttons
    private Timer timer; // Frame timer
    public static final int FPS = 20; // Frames per second

    private ArrayList characters; //list of dynamic/moving world objects
    private ArrayList background; //list of static/non-moving world objects

    private boolean[] keysPressed; //list of keys monitored
    // Key codes to be used by the getKeyPressed() method
    public static final int KEY_LEFT = 0;
    public static final int KEY_UP = 1;
    public static final int KEY_RIGHT = 2;
    public static final int KEY_DOWN = 3;
    public static final int KEY_A = 4;
    public static final int KEY_S = 5;
    public static final int KEY_D = 6;
    public static final int KEY_W = 7;
    public static final int KEY_SPACE = 8;
    
    public static final int NUM_KEYS = 9; // total number of keys being monitored
    
    /**
     * Creates our World, empty.
     */
    public World() {
        characters = new ArrayList();
        background = new ArrayList();

        environment = new WinEnv(this);

        keysPressed = new boolean[NUM_KEYS];
        for (int i=0; i<NUM_KEYS; ++i) {
            keysPressed[i] = false; // explicitly init to false
        }
        
        timer = new Timer(1000/FPS, this); // timer for our simulation
    }

    /**
     * Handles stop button
     */
    public synchronized void stop() {
        if (timer.isRunning()) {
            timer.stop();
        }
    }
    
    /**
     * Handles start button
     */
    public synchronized void start() {
        if (!timer.isRunning()) {
            timer.start();
        }
    }

    /**
     * Called by timer when it's running.
     * It goes through all our objects in the world and asks for updates.
     * Then it asks the window to repaint itself.
     * 
     * @param e the timer action that we are handling
     */
    public synchronized void actionPerformed(ActionEvent e) {
        //update background animation
        Iterator iter = background.iterator();
        while (iter.hasNext()) {
            Background bg = (Background)iter.next();
            bg.update(timer.getDelay());
        }

        //update every moving object
        Iterator it = characters.iterator();
        while (it.hasNext()) {
            AbstractVehicle av = (AbstractVehicle)it.next();
            av.update();
        }
        
        //check for single collisions using bb (not exact)
        for (int i=0; i<characters.size(); ++i) {
            AbstractVehicle av = (AbstractVehicle)characters.get(i);
            Shape avContainer = av.getTracker().getCurrentContainer();
            for (int j=0; j<characters.size(); ++j) {
                if (i != j) {
                    AbstractVehicle otherAv = (AbstractVehicle)characters.get(j);
                    Shape otherContainer = otherAv.getTracker().getCurrentContainer();
                    if (avContainer.intersects(otherContainer.getBounds2D())) { // a collision occurred
                        av.handleCollision(otherAv);
                    }
                }
            }
        }
        
        //redraw after updates
        environment.redraw();
    }

    /**
     * Tells the graphics system what to draw on screen
     * by going through all the objects in the world and telling
     * them to draw themselves.
     * 
     * @param g the graphics system we can use to draw things on
     */
    public synchronized void draw(Graphics2D g) {
        
        // First draw the background objects
        Iterator it = background.iterator();
        while (it.hasNext()) {
            Background s = (Background)it.next();
            s.draw(g);
        }
        
        // Now draw the characters in the world
        it = characters.iterator();
        while (it.hasNext()) {
            AbstractVehicle av = (AbstractVehicle)it.next();

            // Push world matrix, get object matrix, set it, draw, pop
            AffineTransform at = g.getTransform();
            g.setTransform(av.getTracker().getTransform());
            av.draw(g);
            g.setTransform(at);
        }
    }

    /**
     * Registers a non-moving world object with the controller.
     * Duplicates are allowed.
     * 
     * @param o the object to be added
     */
    public synchronized void addWorldObject(Background o) {
        if (o != null)
            background.add(o);
    }

    /**
     * Registers a moving object with the controller
     * Duplicates are allowed.
     * 
     * @param av the object to be added
     */
    public synchronized void addVehicle(AbstractVehicle av) {
        if (av != null)
            characters.add(av);
    }

    /**
     * Return the list of moving objects currently registered with the controller
     * 
     * @return the arraylist of abstract vehicles
     */
    public ArrayList getVehicles() {
        return characters;
    }

    /**
     * Return the size of this world
     * 
     * @return Dimension with width and height of the world
     */
    public Dimension getSize() {
        return environment.getPanelSize();
    }

    /**
     * Return the animation panel of the world
     * 
     * @return animation panel
     */
    public JPanel getPanel() {
        return environment.getPanel();
    }
    
    /**
     * Tells whether a given button on the keyboard is pressed.
     * Only a subset of the keys are currently being monitored.
     * 
     * @param key the keycode of the button
     * @return <code>true</code> if the button is currently down and
     *         <code>false</code> if the buttone is up
     */
    public boolean getKeyPressed(int key) {
        assert key > -1 && key < NUM_KEYS;
        
        return keysPressed[key];
    }
    
    /** Handle the key typed event */
    public void keyTyped(KeyEvent e) {}

    /** Handle the key pressed event */
    public void keyPressed(KeyEvent e) {
        switch (e.getKeyCode()) {
            case KeyEvent.VK_LEFT:
                keysPressed[KEY_LEFT] = true;
                break;
            case KeyEvent.VK_RIGHT:
                keysPressed[KEY_RIGHT] = true;
                break;
            case KeyEvent.VK_UP:
                keysPressed[KEY_UP] = true;
                break;
            case KeyEvent.VK_DOWN:
                keysPressed[KEY_DOWN] = true;
                break;
            case KeyEvent.VK_A:
                keysPressed[KEY_A] = true;
                break;
            case KeyEvent.VK_S:
                keysPressed[KEY_S] = true;
                break;
            case KeyEvent.VK_D:
                keysPressed[KEY_D] = true;
                break;
            case KeyEvent.VK_W:
                keysPressed[KEY_W] = true;
                break;
            case KeyEvent.VK_SPACE:
                keysPressed[KEY_SPACE] = true;
                break;
        }
    }

    /** Handle the key released event */
    public void keyReleased(KeyEvent e) {
        switch (e.getKeyCode()) {
            case KeyEvent.VK_LEFT:
                keysPressed[KEY_LEFT] = false;
                break;
            case KeyEvent.VK_RIGHT:
                keysPressed[KEY_RIGHT] = false;
                break;
            case KeyEvent.VK_UP:
                keysPressed[KEY_UP] = false;
                break;
            case KeyEvent.VK_DOWN:
                keysPressed[KEY_DOWN] = false;
                break;
            case KeyEvent.VK_A:
                keysPressed[KEY_A] = false;
                break;
            case KeyEvent.VK_S:
                keysPressed[KEY_S] = false;
                break;
            case KeyEvent.VK_D:
                keysPressed[KEY_D] = false;
                break;
            case KeyEvent.VK_W:
                keysPressed[KEY_W] = false;
                break;
            case KeyEvent.VK_SPACE:
                keysPressed[KEY_SPACE] = false;
                break;
        }
    }

}