import java.util.concurrent.*;  
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.lang.InterruptedException;

import java.awt.geom.Line2D.Float;
import java.util.ArrayList;

/**
 * A simulation of an airspace containing aircraft, runways, and queues of aircraft. 
 * 
 * @author James M. Clarke  
 * @version 12/03/2007
 */
    public class Simulation implements Runnable
    {
        // The lists of all the aircraft, runways, and queues in the simulation
        private java.util.List<Aircraft> aircrafts = java.util.Collections.synchronizedList(new ArrayList<Aircraft>());
        private java.util.List<Runway> runways = new ArrayList<Runway>();
        private java.util.List<Queue> queues = new ArrayList<Queue>();
        
        // ConcurrentQueues to communicate through
        // List of events that have happened to planes
        private java.util.Queue<AircraftEvent> aircraftEvents = new ConcurrentLinkedQueue<AircraftEvent>();
        // Aircraft to get the GUI to add to the JList
        private java.util.Queue<Aircraft> toAdd = new ConcurrentLinkedQueue<Aircraft>();
        // Aircraft to get the GUI to remove from the JList
        private java.util.Queue<Aircraft> toRemove = new ConcurrentLinkedQueue<Aircraft>();
        
        // The frequency at which planes appear. A plane will appear every "frequency" units of time.
        private float frequency = 1;
        private int numberOfAircraft;
        private int aircraftRemaining;
        private int collisions;
        private boolean isComplete;
        private int timeTaken;
        
        private Level myLevel;
        
        /**
         * Constructor for Simulation objects. Creates the initial runways and queues.
         */         
        public Simulation(Level inLevel)
        {
            super();
            //Add the default runway and queue to the simulation
            int airspacesize = 500;
            int spacing = airspacesize / (inLevel.getRunways() + 1);
            
            for (int i = 0; i<inLevel.getRunways(); i++) 
            {
                runways.add(new Runway(new Position(265, spacing*(i+1)), (float) Math.PI/2, "Runway " + (i+1))); 
            }
            
            queues.add(new Queue(new Position(400, 250), (float) Math.PI/2)); 
            //convert from seconds to 10ms intervals
            frequency = inLevel.getFrequency()*100F;
            numberOfAircraft = inLevel.getNumberOfAircraft();
            myLevel = inLevel;
        }

        public boolean isFinished()
        {
            return isComplete;
        }
        
        public int getCollisions()
        {
            return collisions;   
        }
        
                public int getTimeTaken()
        {
            return timeTaken;   
        }
        
        /**
         * Accessor method for the list of aircraft being simulated
         * 
         * @return     a list of aircraft being simulated
        */         
        public java.util.List<Aircraft> getAircraft()
        {
            synchronized(aircrafts) 
            {
                java.util.List<Aircraft> temp = new ArrayList<Aircraft>();
                for (Aircraft a : aircrafts)
                {
                    temp.add(a);
                }
                return temp;
            }
        }   
       

        /**
         * Accessor method for the list of runways being simulated
         * 
         * @return     a list of runways being simulated
        */         
        public java.util.List<Runway> getRunways()
        {
                return runways;
        }   
        

        /**
         * Accessor method for the list of queues of aircraft being simulated
         * 
         * @return     a list of queues of aircraft being simulated
        */         
        public java.util.List<Queue> getQueues()
        {
                return queues;
        }
        

        /**
         * Accessor method for the queue of requests from the GUI to change the state of aircraft
         * 
         * @return     a queue of requests to change the state of aircraft
        */         
        public java.util.Queue<AircraftEvent> getAircraftEvents()
        {
                return aircraftEvents;
        }


        /**
         * Accessor method for the queue of aircraft the GUI should add to its list of aircraft.
         * This method is provided so that GUIs which keep a list of aircraft in the simulation only need to add new aircraft, rather than refreshing the entire list.
         * 
         * @return     a queue of aircraft which the GUI should add to its list of aircraft
        */         
        public java.util.Queue<Aircraft> getToAdd()
        {
                return toAdd;
        }
        

        /**
         * Accessor method for the queue of aircraft the GUI should remove from its list of aircraft
         * This method is provided so that GUIs which keep a list of aircraft in the simulation only need to remove aircraft that have been removed, rather than refreshing the entire list.
         * 
         * @return     a queue of aircraft which the GUI should remove from its list of aircraft
        */         
        public java.util.Queue<Aircraft> getToRemove()
        {
                return toRemove;
        }

        /**
         * Adds an aircraft to the simulation. Aircraft are generated in a random position at the edge of the simulation.
        */   
        // Add an aircraft to the simulation
        public void add()
        {
            aircraftEvents.add( new AircraftEvent(null, 999, null) );      
        }      

        /**
         * Returns a random number, where the random numbers have a Poisson distribution with mean "mean".
         * This algorithm is taken from Knuth, "The Art of Computer Programming" volume 2. 
         * @param   mean    the mean of the distribution
         * @return     a random number
        */        
        public static int randomPoisson(int mean)
        {   
            float l = (float) Math.exp(-mean);
            int k = 0;
            float u;
            float p = 1;
            java.util.Random r = new java.util.Random();
        
            while(p>=l)
            {
                k = k+1;
                u = r.nextFloat();
                p = p * u;
            }
            
            return k-1;   
        }        
        
        /**
         * Run the simulation. Every 10 milliseconds, the simulation will move on by one unit of time. 
         * @see java.lang.Runnable
        */  
        // The main loop
        public void run()
        {
            // keep track of how much time has passed
            int elapsed = 0;
            int timeTillNext = 0;
            aircraftRemaining = numberOfAircraft;
            
            try
            {
                while (!isComplete)
                {  
                    
                    // Randomly add planes to the simulation
                    if ((timeTillNext == 0) && (aircraftRemaining > 0)) { add(); aircraftRemaining--; timeTillNext = randomPoisson((int) (frequency/10))*10;}
                    elapsed++;
                    timeTillNext--;
                    
                    // Clear out the pending events queue
                    while (!aircraftEvents.isEmpty())
                    {
                        AircraftEvent e = aircraftEvents.poll();
                        switch (e.getState()) {

                            case AircraftEvent.ADD: Aircraft a = new Aircraft(runways.get(0), queues.get(0)); 
                            synchronized(aircrafts) 
                            {
                                aircrafts.add(a);
                            }
                            toAdd.add(a);
                            break; 

                            case AircraftEvent.LAND:  
                                if (e.getRunway() == null)
                                {
                                    e.getAircraft().land();
                                }
                                else
                                {
                                    e.getAircraft().land(e.getRunway());
                                }
                                
                                break;
                            case AircraftEvent.TURNLEFT:  e.getAircraft().turnLeft(); break;
                            case AircraftEvent.TURNRIGHT:  e.getAircraft().turnRight(); break;
                            case AircraftEvent.GOTOQUEUE:  e.getAircraft().goToQueue(); break;
                            case AircraftEvent.LEAVE:  e.getAircraft().leave(); break;
                        }
                    }
                    

                    // Remove the landed aircraft
                    ArrayList<Aircraft> toKill = new ArrayList<Aircraft>();
                    
                    //Keep track of whether the simulation is finished or not
                    boolean aPlaneNotFinished = false;
                    
                    //Loop through all the aurcraft checking whether we need to do anything with them and whether some are in the simulation
                    synchronized(aircrafts) 
                    {
                        for (Aircraft b : aircrafts)
                        {
                            if (!(b.getState()==7)) {aPlaneNotFinished = true;}
                            if (!(b.getState() == 5) &&!(b.getState()==7))
                            {
                                //check if is landing and is at start of runway
                                if ((b.getState() == 0) && b.isLanded())
                                {
                                    b.touchDown();
                                }
                                
                                //check if is leaving level and is at edge of map
                                if ((b.getState() == 6) && (Position.distance(new Position(250, 250), b.where())>250))
                                {
                                    //add it the list of things to remove
                                    toKill.add(b);
                                    toRemove.add(b);
                                }
                                
                                //check if has reached entry point for the queue
                                if (b.getState() == 3)
                                {
                                    if (b.isAtQueue()) {b.queue();}
                                } 
                                
                                // Animate the planes
                                b.findAngle();
                                b.move();   
                            }
                        }
                        // End the level if everything is finished
                        if (!aPlaneNotFinished) { timeTaken = elapsed; isComplete = true; ATCSystem.getCurrentUser().addResult(new Result(myLevel, timeTaken, collisions));} 
                        
                        // Collision detection - check if the planes have become too close together
                        // For each aircraft 
                        for (Aircraft b : aircrafts)
                        {
                            //which is in the air and have not been destroyed
                            if (!(b.getState()==5)&&!(b.getState()==7))
                            {
                                // check the other aircraft
                                for (Aircraft c : aircrafts)
                                {
                                    //which are in the air
                                    if (!b.equals(c))
                                    {
                                        //which are in the air and have not been destroyed
                                        if (!(c.getState()==5)&&!(c.getState()==7))
                                        {
                                            //to see how far apart they are
                                            if ( (Position.distance(b.where(),c.where())) < 20) 
                                            {
                                                //If the planes have become too close together, destroy both of them
                                                b.destroy();
                                                c.destroy();
                                                collisions++;
                                            }
                                        
                                    
                                        }
                                    }
                                }    
                            }
                        }
                        
                        // remove everything we want to remove
                        aircrafts.removeAll(toKill);
                        
                    }

                    



                
                // wait for 10ms
                Thread.sleep(10);
                }
            }
            
            //If anything goes wrong, we are fucked
            catch (InterruptedException e)
            {
            }       
            
        }
    }