#include <wfr/scheduling/SchedulerManager.h>
#include <wfr/scheduling/AbstractScheduler.h>
#include <wfr/common/exceptions/exceptions.h>
#include <iostream>
#include <boost/program_options.hpp>
#include <boost/format.hpp>
#include <wfr/prediction/PredictionManager.h>
#include <wfr/common/resource/ResourceManager.h>
#include <wfr/scheduling/scheduler/dummy/DummyScheduler.h>
#include <wfr/scheduling/scheduler/heft/HEFTScheduler.h>
#include <wfr/scheduling/scheduler/heft/HEFTScheduler.h>
#include <wfr/scheduling/scheduler/random/RandomScheduler.h>
#include <wfr/scheduling/scheduler/justintime/JustInTimeScheduler.h>
#include <wfr/scheduling/scheduler/justintime2/JustInTime2Scheduler.h>
#include <wfr/scheduling/scheduler/minmin/MinMinScheduler.h>
#include <wfr/scheduling/scheduler/maxmin/MaxMinScheduler.h>
#include <wfr/scheduling/scheduler/sufferage/SufferageScheduler.h>
#include <wfr/scheduling/scheduler/peft/PEFTScheduler.h>
#include <wfr/scheduling/scheduler/cpop/CPOPScheduler.h>
#include <wfr/scheduling/scheduler/lookahead/LookaheadScheduler.h>

namespace wfr {
namespace scheduling {


SchedulerManager* SchedulerManager::singleton = nullptr;


void SchedulerManager::init(int argc, char** argv) {
    std::string defaultScheduler = "dummy";

    boost::program_options::options_description opts("SchedulerFactory Options");
    opts.add_options()
    	    ("help", "Print help message.")
    	    ("list-schedulers", "List available schedulers.")
    		("default-scheduler", boost::program_options::value<std::string>(), "Set the default scheduler.");
    boost::program_options::variables_map vm;
    auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run();
    boost::program_options::store(parsed, vm);
    boost::program_options::notify(vm);
    if (vm.count("help")) {
    	std::cerr << opts << std::endl;
    	return;
    }
    if (vm.count("default-scheduler")) {
    	defaultScheduler = vm["default-scheduler"].as<std::string>();
    	std::cerr << "Default scheduler is set to \""<< defaultScheduler << "\"." << std::endl;
    }

	singleton = new SchedulerManager(defaultScheduler);

	if (vm.count("list-schedulers")) {
		std::cerr << "Available schedulers:" << std::endl;
		for (auto item : singleton->schedulerFactories) {
			std::cerr << "\t" << item.first << std::endl;
		}
		exit(0);
	}
}

void SchedulerManager::finish() {
	if (singleton != nullptr) {
		delete singleton;
		singleton = nullptr;
	}
}

SchedulerManager& SchedulerManager::getInstance() {
	if (singleton == nullptr) {
		throw wfr::exception::wfr_missing_instance("ResourceManager instance not found.");
	}
	return *singleton;
}


SchedulerManager::SchedulerManager(std::string defaultScheduler) : defaultScheduler(defaultScheduler) {
    schedulerFactories.insert(factoryMap_t::value_type("dummy", []()->AbstractScheduler* {
    	return new DummyScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance());
    }));
    schedulerFactories.insert(factoryMap_t::value_type("heft", []()->AbstractScheduler* {
    	return new HEFTScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance());
    }));
    schedulerFactories.insert(factoryMap_t::value_type("cpop", []()->AbstractScheduler* {
    	return new CPOPScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance());
    }));
    schedulerFactories.insert(factoryMap_t::value_type("lookahead", []()->AbstractScheduler* {
    	return new LookaheadScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance());
    }));
    schedulerFactories.insert(factoryMap_t::value_type("random", []()->AbstractScheduler* {
    	return new RandomScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance());
    }));
    schedulerFactories.insert(factoryMap_t::value_type("jit", []()->AbstractScheduler* {
    	return new JustInTimeScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance());
    }));
    schedulerFactories.insert(factoryMap_t::value_type("jit2", []()->AbstractScheduler* {
    	return new JustInTime2Scheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance());
    }));
    schedulerFactories.insert(factoryMap_t::value_type("minmin", []()->AbstractScheduler* {
    	return new MinMinScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance());
    }));
    schedulerFactories.insert(factoryMap_t::value_type("maxmin", []()->AbstractScheduler* {
    	return new MaxMinScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance());
    }));
    schedulerFactories.insert(factoryMap_t::value_type("sufferage", []()->AbstractScheduler* {
    	return new SufferageScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance());
    }));
    schedulerFactories.insert(factoryMap_t::value_type("peft", []()->AbstractScheduler* {
    	return new PEFTScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance());
    }));
    if (schedulerFactories.find(defaultScheduler) == schedulerFactories.end()) {
    	throw wfr::exception::wfr_fatal_error((boost::format("Default scheduler \"%1%\" does not exist.") % defaultScheduler).str());
    }
}

AbstractScheduler* SchedulerManager::getDefaultScheduler() {
	return getSchedulerByName(defaultScheduler);
}

AbstractScheduler* SchedulerManager::getSchedulerByName(std::string& name) {
	auto scheduler = schedulerFactories.find(name);
	if (scheduler != schedulerFactories.end()) {
		return scheduler->second();
	} else {
		throw wfr::exception::wfr_illegal_argument((boost::format("Could not find scheduler \"%1%\".") % name).str());
	}
}

void SchedulerManager::markSchedulerForDeletion(AbstractScheduler* scheduler) {
	delete scheduler;
}

} /* namespace scheduling */
} /* namespace wfr */