#include <iostream>

#include <fstream>
#include <string>
#include <vector>
#include <iomanip>
#include "Constant.h"
#include <random>
#include <unordered_map>
#include<algorithm>
using namespace std;

class ChargingStation
{
public:
int cityId;
string cityName;
int distanceToLastCity;
int numberOfChargers;
int queueLength;

public:
ChargingStation(int id, string name, int chargers)
: cityId(id), cityName(name), numberOfChargers(chargers), queueLength(0) {}

int distanceToSydney(int cityId)

{
int distance = 0;
for (int i = 0; i < cityId; i++)
{
distance += distanceMap[i + 1];
}
return distance;
}

void displayInfo()
{
cout << left << setw(4) << cityId;
cout << left << setw(25) << cityName;
cout << left << setw(25) << distanceToSydney(cityId);
cout << left << setw(20) << numberOfChargers;
cout << left << setw(15) << queueLength;
cout << left << setw(40) << fixed << setprecision(2) << (queueLength > 0 ?
(0.5 * static_cast<double>(queueLength) / numberOfChargers) : 0.0) << " hours" <<
endl;
}
};

class Vehicle
{
public:
int vehicleId; // can be any integer
int currentCityId; // initialised with 0 for Sydney
int destinationId; // any city other than Sydney
int capacityRange; // in kilometers
int remainRange; // in kilometers
vector<int> rechargeCities; // Vector to store recharge cities
int secondRecharge; // Variable to store the second recharge city if needed

public:
 Vehicle(int id, int dest, int capacity, int remain)
: vehicleId(id), destinationId(dest), capacityRange(capacity),
remainRange(remain), currentCityId(0), secondRecharge(-1) {}

void calculateRechargeCities()
{
int remain = remainRange;
int distance = 0;
bool firstRechargeFound = false;

for (int i = currentCityId; i < destinationId; i++)

{
distance = distanceMap[i];
remain -= distance;

if (remain < 0)
{
if (!firstRechargeFound)
{
rechargeCities.push_back(i);
firstRechargeFound = true;
}
else if (secondRecharge == -1)
{
secondRecharge = i;
}

remain = capacityRange;
}
}
}

void displayInfo() const

{
string originName = nameMap[currentCityId];
string destinationName = nameMap[destinationId];
string firstRechargeName = (rechargeCities.size() >= 1) ?
nameMap[rechargeCities[0]] : "----";
string secondRechargeName = (secondRecharge != -1) ?
nameMap[secondRecharge] : "----";

cout << left << setw(4) << vehicleId;

cout << left << setw(20) << originName;
cout << left << setw(20) << destinationName;
cout << left << setw(20) << capacityRange;
cout << left << setw(15) << remainRange;
cout << left << setw(15) << firstRechargeName;
cout << left << setw(20) << secondRechargeName << endl;
}
};

class DemandGenerator
{
public:
void generateDemandsToFile(const std::string &fileName, int numDemands)
{
std::ofstream file(fileName);
if (!file.is_open())
{
 std::cerr << "File creation failed!" << std::endl;
return;
}

std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<int> destDistribution(1, NUM_CITIES - 1); //
Destination ID range (1 to NUM_CITIES - 1)
std::uniform_int_distribution<int> capacityDistribution(MIN_CAPACITY,
MAX_CAPACITY);
std::uniform_int_distribution<int> remainDistribution(0, MAX_CAPACITY);

int vehicleId = 200;

for (int i = 0; i < numDemands; ++i)
{
vehicleId++;
int destinationId = destDistribution(gen);
int capacityRange = capacityDistribution(gen);
int remainRange = std::min(capacityRange, remainDistribution(gen));

file << "[" << vehicleId << "," << destinationId << "," <<
capacityRange << "," << remainRange << "]\n";
}

file.close();
}
};

class ChargingAllocation
{
public:
void allocateChargingStations(const vector<Vehicle> &vehicles,
vector<ChargingStation> &stations)
{
// Initialize queue lengths for each charging station to 0
vector<int> queueLengths(NUM_CITIES, 0);

// Calculate queue lengths and waiting times for each vehicle

for (const Vehicle &vehicle : vehicles)
{
int remainingRange = vehicle.remainRange;
int currentCity = vehicle.currentCityId;

for (int i = 0; i < vehicle.rechargeCities.size(); i++)

{
int rechargeCity = vehicle.rechargeCities[i];
int queueLength = queueLengths[rechargeCity];

queueLength++;
queueLengths[rechargeCity] = queueLength;
}
}

// Display charging station information and waiting times

cout << left << setw(4) << "Location ID";
cout << left << setw(20) << "Location Name";
cout << left << setw(20) << "Distance to Sydney";
cout << left << setw(20) << "Number of Chargers";
cout << left << setw(15) << "Queue Length";
 cout << left << setw(15) << "Waiting Hours" << endl;

double totalWaitingHours = 0.0;

for (int i = 0; i < NUM_CITIES; i++)

{
stations[i].queueLength = queueLengths[i];
stations[i].displayInfo();
totalWaitingHours += (0.5 * static_cast<double>(queueLengths[i]) /
stations[i].numberOfChargers);
}

cout << "Overall average waiting time per vehicle = " << fixed <<
setprecision(2) << (totalWaitingHours / vehicles.size()) << " hours" << endl;
}

void chargingAllocationLogic(const vector<Vehicle> &vehicles,

vector<ChargingStation> &stations)
{
// Sort stations based on queue length in ascending order
sort(stations.begin(), stations.end(), [](const ChargingStation &a, const
ChargingStation &b) {
return a.queueLength < b.queueLength;
});

// Iterate through vehicles and allocate them to stations with the shortest
queues
for (const Vehicle &vehicle : vehicles)
{
int minQueueLength = INT_MAX;
int selectedStationIndex = -1;

// Find the station with the shortest queue

for (int i = 0; i < stations.size(); i++)
{
if (stations[i].queueLength < minQueueLength)
{
minQueueLength = stations[i].queueLength;
selectedStationIndex = i;
}
}

// Allocate the vehicle to the selected station

stations[selectedStationIndex].queueLength++;
}
}

void balanceWaitingQueues(const vector<Vehicle> &vehicles,

vector<ChargingStation> &stations)
{
const int numSimulations = 5000;
double bestOverallAvgWaitTime = numeric_limits<double>::max();

for (int simulation = 1; simulation <= 8; simulation++)

{
// Make a copy of the original station queue lengths
vector<int> originalQueueLengths(NUM_CITIES);
for (int i = 0; i < NUM_CITIES; i++)
{
 originalQueueLengths[i] = stations[i].queueLength;
}

// Randomly shuffle the vehicles

vector<Vehicle> shuffledVehicles = vehicles;
random_shuffle(shuffledVehicles.begin(), shuffledVehicles.end());

// Allocate vehicles using the charging allocation logic

chargingAllocationLogic(shuffledVehicles, stations);

// Calculate the overall average waiting time

double totalWaitingHours = 0.0;

for (int i = 0; i < NUM_CITIES; i++)

{
totalWaitingHours += (0.5 *
static_cast<double>(stations[i].queueLength) / stations[i].numberOfChargers);
}

double overallAvgWaitTime = totalWaitingHours / vehicles.size();

// If the current allocation is better, update the best allocation

if (overallAvgWaitTime < bestOverallAvgWaitTime)
{
bestOverallAvgWaitTime = overallAvgWaitTime;
}
else
{
// Revert to the original queue lengths if the current allocation
is not better
for (int i = 0; i < NUM_CITIES; i++)
{
stations[i].queueLength = originalQueueLengths[i];
}
}

cout << "Improved overall average waiting time = " << fixed <<
setprecision(2) << bestOverallAvgWaitTime << " hours at simulation " << simulation
<< endl;
}

cout << "\nCharging allocation after balancing:" << endl;

cout << left << setw(4) << "Vehicle ID";
cout << left << setw(20) << "Destination";
cout << left << setw(20) << "Capacity Range";
cout << left << setw(20) << "Remaining Range";
cout << left << setw(20) << "First Recharge";
cout << left << setw(20) << "Second Recharge" << endl;

for (const Vehicle &vehicle : vehicles)

{
vehicle.displayInfo();
}
}
};

int main()
{
// Load charging station data
 vector<ChargingStation> stations;

for (int i = 0; i < NUM_CITIES; i++)

{
ChargingStation station(i, nameMap[i], chargersMap[i]);
stations.push_back(station);
}

// Generate charging demands and write to a file

DemandGenerator demandGenerator;
const std::string fileName = "ChargingDemands.txt";
const int numDemands = 150 + (std::rand() % 51); // Random number of demands
between 150 and 200

demandGenerator.generateDemandsToFile(fileName, numDemands);

// Read vehicle data from the file

ifstream file(fileName);
if (!file.is_open())
{
cout << "File not found!" << endl;
return 0;
}

vector<Vehicle> vehicles;

string line;
while (getline(file, line))
{
int id, dest, capacity, remain;
if (sscanf(line.c_str(), "[%d,%d,%d,%d]", &id, &dest, &capacity, &remain)
== 4)
{
Vehicle vehicle(id, dest, capacity, remain);
vehicle.calculateRechargeCities();
vehicles.push_back(vehicle);
}
}

file.close();

// Display vehicle information

cout << "Vehicle Information:" << endl;
cout << left << setw(4) << "Vehicle ID";
cout << left << setw(20) << "Origin";
cout << left << setw(20) << "Destination";
cout << left << setw(20) << "Capacity Range";
cout << left << setw(20) << "Remaining Range" << endl;

for (const Vehicle &vehicle : vehicles)

{
vehicle.displayInfo();
}

// Display initial charging allocation

cout << "\nInitial Charging Allocation:" << endl;
cout << left << setw(4) << "Vehicle ID";
cout << left << setw(20) << "Destination";
cout << left << setw(20) << "Capacity Range";
 cout << left << setw(20) << "Remaining Range";
cout << left << setw(20) << "First Recharge";
cout << left << setw(20) << "Second Recharge" << endl;

for (const Vehicle &vehicle : vehicles)

{
vehicle.displayInfo();
}

ChargingAllocation chargingAllocation;
chargingAllocation.allocateChargingStations(vehicles, stations);
const int numSimulations=8;
// Balance waiting queues with Monte-Carlo simulations
cout << "\nBalancing waiting queues with Monte-Carlo simulations." << endl;
cout << "Number of simulations = " << numSimulations << endl;
chargingAllocation.balanceWaitingQueues(vehicles, stations);

return 0;
}