#include "Read.h"
#include <iostream>
#include <sstream>
#include <string>
#include <fstream>
#include <algorithm>

namespace validator {

	// Due to const members, overloading istream operator is not possible
	Instance Read::readInstanceFile(std::string instancePath) {
		std::istringstream	iss;
		std::string			line, var;

		std::ifstream inputFile(instancePath, std::ifstream::in);

		if (!inputFile) {
			std::cerr << "Could not open Instance file " << instancePath << std::endl;
			exit(-1);
		}

		std::string name;
		unsigned int no_customers, no_items, no_types, v_max;
		bool tw;
		std::vector<Customer> customers;
		std::vector<ItemType> itemtypes;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Name")					iss >> name;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Number_of_Customers")	iss >> no_customers;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Number_of_Items")		iss >> no_items;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Number_of_ItemTypes")	iss >> no_types;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Number_of_Vehicles")	iss >> v_max;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "TimeWindows")			iss >> tw;

		getline(inputFile, line);
		getline(inputFile, line);

		Vehicle vehicle = readVehicle(inputFile);

		getline(inputFile, line);

		if (line != "CUSTOMERS") {
			std::cerr << "Wrong Line. Should be Header CUSTOMERS, current: " + line << std::endl;
		}
		getline(inputFile, line);

		// Read Customers
		for (unsigned int i = 0; i <= no_customers; ++i) {
			Customer customer = readCustomer(inputFile);
			customers.emplace_back(customer);
		}

		getline(inputFile, line);
		getline(inputFile, line);
		getline(inputFile, line);
		getline(inputFile, line);

		// Read ItemTypes
		itemtypes.emplace_back(ItemType());
		for (unsigned int i = 0; i < no_types; ++i) {
			ItemType type = readItemType(inputFile);
			itemtypes.emplace_back(type);
		}

		getline(inputFile, line);
		getline(inputFile, line);
		getline(inputFile, line);

		// Read Demands
		for (unsigned int i = 1; i <= no_customers; ++i) {
			unsigned int id;
			Customer& customer = customers.at(i);
			const unsigned int totalDemand = customers.at(i).demand;
			inputFile >> id;
			if (customer.id != id) {
				std::cerr << "Wrong Line. Expected: " << customer.id << ", read: " << id << std::endl;
			}
			for (unsigned int j = 0; j < totalDemand;) {
				std::pair<unsigned int, unsigned int> demand = readDemand(inputFile);
				customer.demands.emplace_back(demand);
				j += demand.second;
			}
		}
		Instance instance(name, vehicle, itemtypes, customers, v_max, tw);
		instance.items.resize(no_items + 1);
		return instance;
	}


	Vehicle  Read::readVehicle(std::ifstream& inputFile) {
		std::istringstream	iss;
		std::string			line, var;

		unsigned int l = 0, w = 0, h = 0, wheelbase = 0, l_f = 0, l_tractor_RA = 0;
		double		 D = 0, lim_frontAxle = 0, lim_rearAxle = 0, mass_tractor = 0;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Mass_Capacity")			iss >> D;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "CargoSpace_Length")		iss >> l;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "CargoSpace_Width")		iss >> w;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "CargoSpace_Height")		iss >> h;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Wheelbase")				iss >> wheelbase;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Max_Mass_FrontAxle")	iss >> lim_frontAxle;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Max_Mass_RearAxle")		iss >> lim_rearAxle;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Distance_FrontAxle_CargoSpace") {
			iss >> l_f;
			const unsigned int volume = l * w * h;

			getline(inputFile, line);
			if (line.empty())							return Vehicle(l, w, h, D, volume, wheelbase, lim_frontAxle, lim_rearAxle, l_f);

			if (var == "Distance_Mass_Truck_RearAxle")	iss >> l_tractor_RA;

			getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
			if (var == "Mass_Truck")					iss >> mass_tractor;

			return Vehicle(l, w, h, D, volume, wheelbase, lim_frontAxle, lim_rearAxle, l_f, l_tractor_RA, mass_tractor);

		}
		else {
			double lim_trailer = 0, mass_trailer = 0;
			unsigned int l_kingpin_RA = 0, l_kingpin_TA = 0, l_cargo_TA = 0, l_trailer_TA;

			if (var == "Max_Mass_TrailerAxle")				iss >> lim_trailer;

			getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
			if (var == "Distance_Kingpin_RearAxle")			iss >> l_kingpin_RA;

			getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
			if (var == "Distance_Kingpin_TrailerAxle")		iss >> l_kingpin_TA;

			getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
			if (var == "Distance_CargoSpace_TrailerAxle")	iss >> l_cargo_TA;

			getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
			if (var == "Distance_Mass_Tractor_RearAxle")	iss >> l_tractor_RA;

			getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
			if (var == "Distance_Mass_Trailer_TrailerAxle")	iss >> l_trailer_TA;

			getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
			if (var == "Mass_Tractor")						iss >> mass_tractor;

			getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
			if (var == "Mass_Trailer")						iss >> mass_trailer;

			getline(inputFile, line);

			const unsigned int volume = l * w * h;
			return Vehicle(l, w, h, D, volume, wheelbase, lim_frontAxle, lim_rearAxle, lim_trailer, l_kingpin_RA, l_kingpin_TA,
				l_cargo_TA, l_tractor_RA, l_trailer_TA, mass_tractor, mass_trailer);
		}
	}


	Customer  Read::readCustomer(std::ifstream& inputFile) {
		float x, y;
		double demandedMass, demandedVolume;
		unsigned int id, demand, readyTime, dueDate, serviceTime;
		inputFile >> id >> x >> y >> demand >> readyTime >> dueDate >> serviceTime >> demandedMass >> demandedVolume;
		return Customer(id, x, y, demand, readyTime, dueDate, serviceTime, demandedMass, demandedVolume);
	}


	ItemType Read::readItemType(std::ifstream& inputFile) {
		std::istringstream	iss;
		std::string			line;

		unsigned int l, w, h;
		float mass;
		bool fragility;
		double lbs;

		// Get ItemType Id
		getline(inputFile, line);
		iss.clear(); iss.str(line); iss >> line;
		std::string no = line.substr(2);
		unsigned int id = stoi(no);

		// Get other members
		iss >> l >> w >> h >> mass >> fragility >> lbs;

		return ItemType(id, l, w, h, mass, fragility, lbs);
	}


	std::pair<unsigned int, unsigned int>  Read::readDemand(std::ifstream& inputFile) {
		std::string str;
		unsigned int qt;
		inputFile >> str >> qt;
		std::string no = str.substr(2);
		unsigned int id = stoi(no);
		return std::pair<unsigned int, unsigned int>(id, qt);
	}


	ConstraintSet Read::readConstraintFile(std::string constraintPath) {
		std::ifstream inputFile(constraintPath, std::ifstream::in);
		std::istringstream	iss;
		std::string			line, var;

		if (!inputFile) {
			std::cerr << "Could not open ConstraintSet file " << constraintPath << std::endl;
			exit(-1);
		}

		bool rotation, load_capacity, reachability, axle_weights, balanced_loading;
		unsigned int uSequence, vStability, stacking, lambda;
		float alpha, balanced_part;

		getline(inputFile, line); // Skip first Line

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "alpha")					iss >> alpha;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "lambda")				iss >> lambda;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "balanced_part")			iss >> balanced_part;

		getline(inputFile, line);
		getline(inputFile, line);

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "rotation")				iss >> rotation;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "capacity")				iss >> load_capacity;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "unloading_sequence")	iss >> uSequence;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "vertical_stability")	iss >> vStability;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "stacking")				iss >> stacking;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "reachability")			iss >> reachability;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "axle_weights")			iss >> axle_weights;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "balancing")				iss >> balanced_loading;

		return ConstraintSet(rotation, load_capacity, static_cast<UnloadingSequence>(uSequence), static_cast<VerticalStability>(vStability),
			static_cast<Stacking>(stacking), reachability, axle_weights, balanced_loading, alpha, lambda, balanced_part);
	}

	Solution Read::readSolutionFile(const std::string solutionPath, Instance& instance) {
		std::ifstream inputFile(solutionPath, std::ifstream::in);
		std::istringstream	iss;
		std::string			line, var, name, problem, totalTravelDistance, calculationTime, iterations, cSet;

		if (!inputFile) {
			std::cerr << "Could not open Packplan file " << solutionPath << std::endl;
			exit(-1);
		}

		unsigned int vUsed;
		std::vector<Tour> tours;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Name:")							iss >> name;

		if (name != instance.name) {
			std::cerr << "Wrong Packing Plan found. Expected: " << instance.name << ", read: " << line;
			exit(-1);
		}

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Problem:")						iss >> problem;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Number_of_used_Vehicles:")		iss >> vUsed;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Total_Travel_Distance:")		iss >> totalTravelDistance;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Calculation_Time:")				iss >> calculationTime;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "Total_Iterations:")				iss >> iterations;

		getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
		if (var == "ConstraintSet:")				iss >> cSet;

		getline(inputFile, line);

		// Read Routes
		for (size_t r = 1; r <= vUsed; ++r) {
			unsigned int id, noItems, noCustomers, customerId;
			std::vector<unsigned int> customerIds;

			do {
				getline(inputFile, line);
			} while (!inputFile.eof() && line.find("Tour_Id") == std::string::npos);

			iss.clear(); iss.str(line); iss >> var; iss >> id;
			if (r != id) {
				std::cerr << "Wrong TourId found. Expected: " << r << ", read: " << id << std::endl;
				exit(-1);
			}

			getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
			if (var == "No_of_Customers:")		iss >> noCustomers;


			getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
			if (var == "No_of_Items:")			iss >> noItems;

			getline(inputFile, line); iss.clear(); iss.str(line); iss >> var;
			if (var == "Customer_Sequence:") {
				for (size_t i = 0; i < noCustomers; ++i) {
					iss >> customerId;
					customerIds.emplace_back(customerId);
				}
			}

			// One Customer per Tour is always feasible
			if (noCustomers > 1) {

				getline(inputFile, line);
				getline(inputFile, line);

				// Read Items
				std::vector<unsigned int> itemIds;
				for (size_t i = 0; i < noItems; ++i) {
					getline(inputFile, line);
					Item item = readItem(line, instance);
					instance.items[item.id] = item;
					auto& customer = instance.customers.at(item.customer_id);
					itemIds.emplace_back(item.id);
					customer.item_ids.emplace_back(item.id);
				}
				tours.emplace_back(Tour(r, customerIds, itemIds));
				getline(inputFile, line);
				getline(inputFile, line);
			}
			else {
				instance.customers.at(customerId).demands.clear();
				tours.emplace_back(Tour(r, customerIds, {}));
			}
		}

		Solution solution(tours);
		solution.calculation_time = stod(calculationTime);
		solution.total_iterations = stoi(iterations);
		solution.feasible = true;
		solution.total_travel_distance = stod(totalTravelDistance);
		return solution;
	}

	Item  Read::readItem(const std::string line, Instance& instance) {
		std::istringstream	iss;

		unsigned int id, type_id, customer_id, rotation;

		unsigned int x, y, z;

		iss.clear(); iss.str(line);
		iss >> customer_id >> id >> type_id >> rotation >> x >> y >> z;

		const ItemType& itemtype = instance.itemTypes.at(type_id);

		Item item(id, customer_id, rotation, itemtype);
		item.setPosition(Point(x, y, z));

		return item;
	}

}