#!/usr/bin/python

from __future__ import generators
from SimPy.Simulation import *
from random import expovariate, normalvariate
from copy import copy

# Constants

NUM_GATE = 5   # number of gate
NUM_RUNWAY = 2  # number of runway

T_RUNWAY = 10  # runway occupation
T_GATES = 45   # gate occupation

T_LATE_WAIT_MAX = 15
T_PLANE_CLEANUP = 15

PG_INT = 25.0  # average new plane comes

pcnt = 10

#

class PlaneGenerator(Process):
    def __init__(self, name, airports):
        Process.__init__(self,name)
        self.cnt = 0
        self.airports = airports
        self.planes = []
        self.random = random.Random()

    def generate(self):
        while True:
            length = len(self.airports)
            aid = self.random.randint(0, length-1)

            airport = self.airports[aid]

            p = Plane('Plane #' + str(self.cnt), airport)
            self.planes.append(p)

            activate(p, p.execute())

            yield hold,self,r.expovariate(1/PG_INT)
            self.cnt += 1

class Plane(Process):
    def __init__(self, name, airport):
        Process.__init__(self,name)
        self.airport = airport
        self.trace = []

        self.random = random.Random()

    def execute(self):
        while True:
            self.trace.append(self.airport)
            self.airport.add_plane(self)
    
            # runway (landing)
            s = now()
            yield request, self, self.airport.runway
            f = now()
            yield hold, self, T_RUNWAY
            yield release, self, self.airport.runway
            self.airport.mon_landing.observe(f-s)
            bs = now()
            self.airport.mon_airport.add()
    
            # gate (passanger out)
            s = now()
            yield request, self, self.airport.gate
            f = now()
            self.airport.mon_airport.sub()
            yield hold, self, T_GATES
            yield release, self, self.airport.gate
            self.airport.mon_gate_in.observe(f-s)
            self.airport.mon_airport.add()
    
            # clean up (change staff, clean the cabin, etc)
            yield hold, self, T_PLANE_CLEANUP
            yield hold, self, self.get_wait_schedule()
    
            # gate (passanger in)
            s = now()
            yield request, self, self.airport.gate
            f = now()
            self.airport.mon_airport.sub()
            yield hold, self, T_GATES
            yield hold, self, self.get_wait_late()
            yield release, self, self.airport.gate
            self.airport.mon_gate_out.observe(f-s)
            self.airport.mon_airport.add()
    
            bf = now();
    
            # take off
            s = now()
            yield request, self, self.airport.runway
            f = now()
            self.airport.mon_airport.sub()
            yield hold, self, T_RUNWAY
            yield release, self, self.airport.runway
            self.airport.mon_takeoff.observe(f-s)
    
            self.airport.mon_board.observe(bf-bs)

            # next destination
            next = copy(self.airport.next)
            next.append(-1)

            length = len(next)

            id = self.random.randint(0, length-1)

            if next[id] == -1:
                break
            else:
                self.airport = next[id]
                
    def get_wait_late(self):
        # TODO
        return 0

    def get_wait_schedule(self):
        # TODO
        return 0

class AirportMonitor:
    def __init__(self):
        self.cnt = 0
        self.max = 0

    def add(self):
        self.cnt += 1
        if (self.cnt > self.max):
            self.max = self.cnt

    def sub(self):
        self.cnt -= 1

class Airport:

    def __init__(self, name, runway=NUM_RUNWAY, gate=NUM_GATE):
        self.name = name
        self.num_runway = runway
        self.num_gate = gate

        self.runway = Resource(self.num_runway)
        self.gate = Resource(self.num_gate, monitored=True)
        self.mon_airport = AirportMonitor()
        self.mon_landing = Monitor("landing-" + name)
        self.mon_takeoff = Monitor("takeoff-" + name)
        self.mon_gate_in = Monitor("gatein-" + name)
        self.mon_gate_out = Monitor("gateout-" + name)
        self.mon_board = Monitor("board-" + name);

        self.next = []
        self.planes = []

    def add_next_airport(self, aiport):
        self.next.append(airport)
    
    def add_plane(self, plane):
        self.planes.append(plane)

initialize()

r = random.Random()

airport_cengkareng = Airport("Cengkareng")
airports = [ airport_cengkareng ]

pg = PlaneGenerator('Source', airports)
activate(pg, pg.generate(), 0.0)

simulate(until=24*60)

print "total planes generated: " + str(pg.cnt)
for airport in airports:
    print "# " + airport.name
    print "  - average waiting time for runway (landing): " + str(airport.mon_landing.mean())
    print "  - average waiting time for runway (takeoff): " + str(airport.mon_takeoff.mean())
    print "  - average waiting time for gate (in): " + str(airport.mon_gate_in.mean())
    print "  - average waiting time for gate (out): " + str(airport.mon_gate_out.mean())
    print "  - average boarding time: " + str(airport.mon_board.mean())
    print "  - max planes waiting for gate/runway: " + str(airport.mon_airport.max)

# vim: ts=4 sts=4 expandtab