import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Level {

	protected ArrayList movingObjects = new ArrayList(); //En Arraylist innehållande alla våra rörliga objekt
	protected ArrayList stillObjects = new ArrayList(); //En Arraylist innehållande alla våra stillastående objekt
	protected ArrayList playerObjects = new ArrayList(); //En Arraylist innehålladne spelarobjekten
	protected TheBaron baronObject;
	protected Image background;
	protected boolean gameover = false;
	protected boolean restartGame = false;
	protected boolean inGoal = false;
	public TheBaron baron;
	
	
	public void setBaron(TheBaron baron) {
		baronObject = baron;
	}
	
	public void backgroundDraw(Graphics g) {
		g.drawImage(background, 0, 0, null);
	}
	
	public void draw(Graphics g) {
		
		backgroundDraw(g);
		
		// Ritar ut baronen om den inte är död
		if (baronObject.doesExists()) {
			baronObject.draw(g);
		}
		
		ListIterator i1 = stillObjects.listIterator();
		while (i1.hasNext()) { //Itererar över stillastående objekt och ritar dessa
			StillObject object = (StillObject) i1.next();
			object.draw(g);
		}
		
		ListIterator i2 = movingObjects.listIterator();
		while (i2.hasNext()) { //Iterarar över rörliga objekt och ritar dessa
			MovingObject object = (MovingObject) i2.next();
			object.draw(g);
		}
		
		ListIterator i3 = playerObjects.listIterator();
		while (i3.hasNext()) { //Iterarar över rörliga objekt och ritar dessa
			PlayerObject object = (PlayerObject) i3.next();
			object.draw(g);
		}
		
	}
	
	
	public void clockTick() {

		// #########################################
		// KLOCKTICK
		ListIterator i6 = stillObjects.listIterator();
		while (i6.hasNext()) { //Iterarar över stillastående objekt
			StillObject object = (StillObject) i6.next();
			object.clockTick();
		}
		
		// Iterera över rörliga objekt och utför klocktick
		ListIterator i5 = movingObjects.listIterator();
		while (i5.hasNext()) { //Iterarar över rörliga objekt
			MovingObject object = (MovingObject) i5.next();
			object.clockTick();
		}
		
		// Tickar baronen
		baronObject.clockTick();
		
		// ###########################################
		// KOLLISIONSHANTERING
		
		if (baronObject.doesExists()) {
			// Kollisions-checkar-Baronen
			checkColissionTwo(baronObject, playerObjects);
			checkColissionTwo(baronObject, movingObjects);
			checkColissionTwo(baronObject, stillObjects);
		}
		
		if (!baronObject.doesExists()) {
			//GAME OVER
			//System.out.println("GAME OVER...");
			this.gameover = true;
		}
		
		if (baronObject.isInGoal()) {
			inGoal = true;
		}
		
		//Vi itererar över playerObjects och kör metoden clockTick(); för varje objekt
		//Vi utför även en kollissionskontroll för samtliga rörliga,stillastående
		//och playerObjects
		
		ListIterator i4 = playerObjects.listIterator();
		while (i4.hasNext()) { //Iterarar över spelar-objekt
			GameObject object = (GameObject) i4.next();
			object.clockTick();
			
			//checkColissionTwo(object, playerObjects);
			//checkColissionTwo(object, movingObjects);
			//checkColissionTwo(object, stillObjects);
			
			//if (!object.doesExists()) {
				//i4.remove();
			//}
			
		}
		
		

	}
	
	public void checkColissionTwo(GameObject object1, ArrayList list) {
		// Loopa genom arraylisten och kontrollera
		// om object1 kolliderar med några av objekten i list
		// objects1 = det objekt vi checkar
		ListIterator i1 = list.listIterator();
		while (i1.hasNext()) {
			GameObject object2 = (GameObject) i1.next();
			
			if (polyIntersects(object1.getPolygon(), object2.getPolygon()) && !(object1 == object2)) {
				System.out.println("Kolission: ");
				System.out.println(object1);
				System.out.println(object2);
				
				
				if (object2.isEnemy()) {
					//Object1 ett ska "dö" kanske eller nåt ?
					//  Vi säger till objektet att det gör en kollision med fiende
					object1.enemyCollission();
					System.out.println("EnemyCollission");
					System.out.println(" ");

				}
				else if (object2.isGoal()) {
					object1.goalCollission();
					System.out.println("GoalCollission");
				}
				else {
					//I detta fall, kanske objektet ska förbjudas att röra sig ?
					// Vi säger till objektet att det gör en vänlig kollision
					object1.friendlyCollission();
					System.out.println("friendlyCollission");
					System.out.println(" ");
				}
			}
		}
	}
	
	/**
	 * Tar två polynom och kontrollerar om dessa "krockar" med varandra
	 * @param poly1 poly2
	 */
	// #####################################################################
	// MODIFIERAD 061005 17:50 av Mackan //
	public boolean polyIntersects (Polygon poly1, Polygon poly2) {
		// Kort inblick:
		// Steg1: Här kollar vi så att inga punkter av polygon1, ligger i det polygon2
		// Steg2: Samma sak fast det andra poly2 i poly1
		// Steg3: Kontrollerar vi så att ytorna inte skär varandra över huvudet taget
		
		// ### STEG 1 ### \\	
		// Loopa igenom alla punkter i Poly1, kolla om de finns i poly2
//		System.out.println("Poly1:s punkter i Polynom 2...");
		for (int i=0; (i < poly1.npoints); i++ ) {
			Point p = new Point(poly1.xpoints[i], poly1.ypoints[i]); // Punkt i polygon 1
//			System.out.print("P1(" + i + "):" + poly1.xpoints[i] + "," + poly1.ypoints[i] + " | ");
			
			if (poly2.contains(p)) { // om punkten finns i poly2
//				System.out.println("JA! Någon av Poly1:s punkter ligger i poly2");
				return true;
			}
		}
//		System.out.print(poly1);
//		System.out.println("");
		
		// ### STEG 2 ### \\
		// Loopa igenom alla punkter i Poly2, kolla om de intersectar med poly1
		// OBS! detta är ytterst nödvändigt då man annars kan missa att poly1 intersektar med poly2
		for (int i=0; (i < poly2.npoints); i++ ) {
			Point p = new Point(poly2.xpoints[i], poly2.ypoints[i]); // Punkt i polygon 2
//			System.out.print("P2(" + i + "):" + poly2.xpoints[i] + "," + poly2.ypoints[i] + " | ");
			if (poly1.contains(p)) { // om punkten finns i poly2
//				System.out.println("JA! Någon av Poly2:s punkter ligger i poly1");
				return true;
			}
		}
//		System.out.print(poly2);
//		System.out.println("");
		
		// ### STEG 3 ### \\
		
		// Kontrollerar om en rektangel av polynom1, intersectar med rektangel av polynom2.. och vice versa!
		// detta måste göras så man annars kan missa de fall, där inga punkter är i varandras polygon,
		// men ändå är över varandra
		
		// Detta funkar inte då våra väggar blir stora block!
		/*
		Rectangle p1Rect = poly1.getBounds();  // Polygon 1:s rektangel
		Rectangle p2Rect = poly2.getBounds();  // Polygon 2:s rektangel
		
//		System.out.println("Rect1 i Rect2:" + p2Rect.intersects(p1Rect));
//		System.out.println("Rect2 i Rect1:" + p2Rect.intersects(p1Rect));
		if ( (p2Rect.intersects(p1Rect)) || p1Rect.intersects(p2Rect)) {
			return true;
		}
		*/
		
		// om vi inte hittat några punkter som matchar, och inga ytor som intersectar
		// så returnerar vi falskt!
		return false;
		}	
	
	public void checkColission(GameObject object) {
		
	}
	
	public void keyPressed(KeyEvent e) {
	}
	
	public void keyReleased(KeyEvent e) {
		
	}
	
}