#include "simulator.h"
#include <stdlib.h>

#include <iostream>
#include <limits>


#include <stdint.h>

#define meanarriveTime 1.0000
#define meanServiceTime 4.5
#define tellerNumber 5
#define MAX 9999999
#define MIN -9999999

double randomGenerator(double rn){
    double u = (rand() / (double) (RAND_MAX + 1) );
    double lnU = log(1-u);
    return (lnU * (-rn));
}

void jockey(int tellerSerial,Simulator *sim){
    int i,jumper,ni,nj,otherTeller,minDistance,distance;
    jumper = 0;
    minDistance = 1000;
    ni = sim->teller[tellerSerial].queueCustomer.size();

    for (otherTeller=0;otherTeller<sim->noOfTeller;otherTeller++){
        nj = sim->teller[otherTeller].queueCustomer.size();
        distance = abs(tellerSerial - otherTeller);
        if ( otherTeller!=tellerSerial && nj > ni+1 && distance < minDistance){
            jumper = otherTeller;
            minDistance = distance;
		}
	}
    if (jumper > 0 ){
        Customer customer = sim->teller[jumper].queueCustomer.back();
        sim->teller[jumper].queueCustomer.pop_back();
        //sim->teller[tellerSerial].queueCustomer.push_back(c);

        nj=sim->teller[tellerSerial].queueCustomer.size();

        if (nj==0){
            customer.serviceStartTime = sim->now();
            sim->teller[tellerSerial].queueCustomer.push_front(customer);
            sim->scheduleEvent(new DepartureEvent((sim->now() + randomGenerator(meanServiceTime)),tellerSerial));
		}

        else if (nj>0){
            sim->teller[tellerSerial].queueCustomer.push_back(customer);
		}

	}

}

Simulator::Simulator() {
    eventQueue =  new priority_queue<Event*, vector<Event*>, CompareEvent>();

    noOfCustomer=0;
    lock = 0;
    noOfTeller = tellerNumber;
    teller = new Teller[noOfTeller];
}


t_simtime Simulator::now() {
    return this->simclock;
}


void Simulator::scheduleEvent(Event *event) {
    this->eventQueue->push(event);
}

void Simulator::run() {


    while (eventQueue->empty() == false) {
        Event *event = this->eventQueue->top();
        this->eventQueue->pop();

        this->simclock = event->getEventTime();
        event->processEvent(this);
        delete event;
	}
}

void Simulator::setSimulationEndTime(t_simtime endTime) {
    Event *endEvent = new EndEvent(endTime);
    this->scheduleEvent(endEvent);
}

Simulator::~Simulator() {
    if (eventQueue) {
        while (!eventQueue->empty()) {
            Event *event = eventQueue->top();
            eventQueue->pop();
            delete event;
		}
        delete eventQueue;
	}

}

// Event classes

EndEvent::EndEvent(t_simtime time, EventType type, string name): Event (time, type, name) { }
EndEvent::EndEvent(t_simtime time): Event (time, EXIT, string("EXIT")) { }
void EndEvent::processEvent(Simulator *sim) {
    sim->lock = 1;
}


DepartureEvent::DepartureEvent(t_simtime time, EventType type, string name,int serial): Event (time, type, name) {
    tellerSerial = serial;
}
DepartureEvent::DepartureEvent(t_simtime time,int serial): Event (time, DEPARTURE, string("DEPARTURE")){
    tellerSerial = serial;
}

void DepartureEvent::processEvent(Simulator *sim) {

    if (sim->teller[tellerSerial].queueCustomer.size()>0){
        Customer customer = sim->teller[tellerSerial].queueCustomer.front();
        sim->teller[tellerSerial].queueCustomer.pop_front();

        if (sim->teller[tellerSerial].queueCustomer.size()>0){
            sim->teller[tellerSerial].queueCustomer.front().serviceStartTime = sim->now();
            sim->scheduleEvent(new DepartureEvent((sim->now() + randomGenerator(meanServiceTime)),tellerSerial));
		}

        customer.exitTime = sim->now();
        CustomerDq.push_back(customer);

        jockey(tellerSerial,sim);
	}
	if(sim->teller[tellerSerial].queueCustomer.size() == 0){
        sim->teller[tellerSerial].idle = 1;
        jockey(tellerSerial,sim);
	}

}


ArrivalEvent::ArrivalEvent(t_simtime time, EventType type, string name): Event (time, type, name) { }
ArrivalEvent::ArrivalEvent(t_simtime time): Event (time, ARRIVAL, string("ARRIVAL")) { }

void ArrivalEvent::processEvent(Simulator *sim) {
    int serial,minQSize,i;
    if (sim->lock == 0){
        sim->noOfCustomer++;
        Customer customer(sim->noOfCustomer,getEventTime(),0,0);

        serial = 0;
        minQSize = sim->teller[serial].queueCustomer.size();

        for (int i=1;i<sim->noOfTeller;i++){
            if (minQSize > sim->teller[i].queueCustomer.size()){
                minQSize = sim->teller[i].queueCustomer.size();
                serial = i;
			}
		}
        if (sim->teller[serial].queueCustomer.size()==0){
            sim->scheduleEvent(new DepartureEvent((sim->now()+randomGenerator(meanServiceTime)),serial));
            customer.serviceStartTime=customer.arriveTime;
            sim->teller[serial].idle = 0;
		}
        sim->teller[serial].queueCustomer.push_back(customer);
        sim->scheduleEvent(new ArrivalEvent(sim->now() + randomGenerator(meanarriveTime)));


	}
}


int main(int argc, char **argv) {


    ofstream report;
    report.open ("report.txt",ios::out);
    double countDelay[100];
    int countDelayserial=0;

    report<<"Number of Teller:\t"<<tellerNumber<<endl;
    report<<"Mean interarrival Time:\t"<<meanarriveTime<<endl;
    report<<"Mean Service Time:\t"<<meanServiceTime<<endl;
    report<<"Bank Closes after:\t 8.000 hours"<<endl;
    for (int i=0;i<100;i++){

		Simulator *sim = new Simulator();
		sim->scheduleEvent(new ArrivalEvent(randomGenerator(meanarriveTime)));
		sim->scheduleEvent(new EndEvent(480));
		sim->setSimulationEndTime(1000);
		sim->run();

		double delayMax = MIN;
		double delayMin = MAX;
		double qMax = MIN;
		double qMin =  MAX;

		int dqSize = CustomerDq.size();
		double sizeArray[dqSize];
		double qTimeArray[dqSize];
        int j=0;
		double avgQueue,avgDelay,delay,qTime;

		for (deque<Customer>::iterator it = CustomerDq.begin(); it!=CustomerDq.end(); ++it){
            delay = (*it).serviceStartTime - (*it).arriveTime;
			qTime = (*it).exitTime - (*it).arriveTime;
            sizeArray[j] = delay;
            qTimeArray[j] = qTime;
            j++;
            avgDelay+=delay;
			avgQueue+=qTime;
		}

		for(int k = 0 ; k<dqSize; k++){
            if(delayMax < sizeArray[k]){
                delayMax = sizeArray[k];
            }
            if(delayMin > sizeArray[k]){
                delayMin = sizeArray[k];
            }
            if(qMax < qTimeArray[k]){
                qMax = qTimeArray[k];
            }
            if(qMin > qTimeArray[k]){
                qMin = qTimeArray[k];
            }
		}


		avgDelay = avgDelay/dqSize;
		avgQueue = avgQueue/dqSize;


		countDelay[countDelayserial] = avgDelay;
		countDelayserial++;

		report<<"Simulation no. "<<i<<endl;
		report<<"With "<<sim->noOfTeller<<" tellers, average number in queue =\t "<<avgQueue<<endl;
		report<<"Delays in queues,in minutes:\n\n";
		report<<"Average\t    No. of customers\t     Maximum\t     Minimum"<<endl;
		report<<"\n";
		report<<avgDelay<<"           "<<dqSize<<"                "<<delayMax<<"             "<<delayMin<<endl;
		report<<"\n";

		delete sim;
		CustomerDq.clear();


	}

	double I,left,right,diff;
	double avgX=0;
	double square=0;
	for (int i=0;i<100;i++)
        avgX+=countDelay[i];
    avgX=avgX/100;
    for (int i=0;i<100;i++){


        diff = countDelay[i] - avgX;
        square += pow(diff,2);
    }

    square = square/99;
    I = 1.65*sqrt(square/100);
    left = avgX-I;
    right = avgX+I;


    report<<endl<<"Average\t        Left Boundary\t     Right Boundary"<<endl;
    report<<"\n";
    report<<avgX<<"                "<<left<<"             "<<right<<endl;
    report<<"\n";

    report.close();

    return 0;
}