#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
#include <signal.h>

#include <sched.h>

#include "litmus.h"
#include "common.h"

const char *usage_msg =
	"Usage: resctrl OPTIONS [INTERVAL-START,INTERVAL-END]*\n"
	"    -n ID             create new reservation with id ID\n"
	"    -a PID            attach already-running process PID to reservation\n"
	"    -r ID             specify which reservation to attach to (not needed with -n)\n"
	"    -t TYPE           type of reservation (polling-periodic, polling-sporadic, table-driven)\n"
	"    -c CPU            physical partition or cluster to assign to\n"
	"    -b BUDGET         polling reservation budget (in ms, default: 10ms)\n"
	"    -p PERIOD         polling reservation period (in ms, default: 100ms)\n"
	"    -d DEADLINE       relative deadline, implicit by default (in ms)\n"
	"    -o OFFSET         offset (also known as phase), zero by default (in ms)\n"
	"    -q PRIORITY       priority to use (EDF by default, highest priority = 1)\n"
	"    -m MAJOR-CYCLE    major cycle length (in ms, for table-driven reservations) \n"
	"\n";

void usage(char *error) {
	fprintf(stderr, "%s\n%s", error, usage_msg);
	exit(1);
}


static void attach_task(int attach_pid, struct reservation_config *config)
{
	int ret;
	struct rt_task param;
	struct sched_param linux_param;

	ret = be_migrate_thread_to_cpu(attach_pid, config->cpu);
	if (ret < 0) {
		fprintf(stderr, "failed to migrate task %d to CPU %d\n",
			attach_pid, config->cpu);
		exit(4);
	}

	init_rt_task_param(&param);
	/* dummy values */
	param.exec_cost = ms2ns(100);
	param.period    = ms2ns(100);
	/* specify reservation as "virtual" CPU */
	param.cpu       = config->id;

	ret = set_rt_task_param(attach_pid, &param);
	if (ret < 0) {
		fprintf(stderr, "failed to set RT task parameters for task %d (%m)\n",
			attach_pid);
		exit(2);
	}

	linux_param.sched_priority = 0;
	ret = sched_setscheduler(attach_pid, SCHED_LITMUS, &linux_param);
	if (ret < 0) {
		fprintf(stderr, "failed to transition task %d to LITMUS^RT class (%m)\n",
			attach_pid);
		exit(3);
	}
}

static struct lt_interval* parse_td_intervals(int argc, char** argv,
	unsigned int *num_intervals, lt_t major_cycle)
{
	int i, matched;
	struct lt_interval *slots = malloc(sizeof(slots[0]) * argc);
	double start, end;

	*num_intervals = 0;
	for (i = 0; i < argc; i++) {
		matched = sscanf(argv[i], "[%lf,%lf]", &start, &end);
		if (matched != 2) {
			fprintf(stderr, "could not parse '%s' as interval\n", argv[i]);
			exit(5);
		}
		if (start < 0) {
			fprintf(stderr, "interval %s: must not start before zero\n", argv[i]);
			exit(5);
		}
		if (end <= start) {
			fprintf(stderr, "interval %s: end before start\n", argv[i]);
			exit(5);
		}

		slots[i].start = ms2ns(start);
		slots[i].end   = ms2ns(end);

		if (i > 0 && slots[i - 1].end >= slots[i].start) {
			fprintf(stderr, "interval %s: overlaps with previous interval\n", argv[i]);
			exit(5);
		}

		if (slots[i].end >= major_cycle) {
			fprintf(stderr, "interval %s: exceeds major cycle length\n", argv[i]);
			exit(5);
		}

		(*num_intervals)++;
	}

	return slots;
}

#define OPTSTR "n:a:r:t:c:b:p:d:o:q:m:h"

int main(int argc, char** argv)
{
	int ret, opt;
	double budget_ms, period_ms, offset_ms, deadline_ms, major_cycle_ms;
	int create_new = 0;
	int attach_pid = 0;
	int res_type = SPORADIC_POLLING;

	struct reservation_config config;

	/* Reasonable defaults */
	offset_ms      =    0;
	deadline_ms    =    0;
	budget_ms      =   10;
	period_ms      =  100;
	major_cycle_ms = 1000;

	config.id = 0;
	config.priority = LITMUS_NO_PRIORITY; /* use EDF by default */
	config.cpu = 0;

	while ((opt = getopt(argc, argv, OPTSTR)) != -1) {
		switch (opt) {
		case 'b':
			budget_ms = atof(optarg);
			break;
		case 'p':
			period_ms = atof(optarg);
			break;
		case 'd':
			deadline_ms = atof(optarg);
			if (deadline_ms <= 0) {
				usage("The relative deadline must be a positive"
					" number.");
			}
			break;
		case 'o':
			offset_ms = atof(optarg);
			break;
		case 'm':
			major_cycle_ms = atof(optarg);
			break;

		case 'q':
			config.priority = atoi(optarg);
			if (!config.priority)
				usage("-q: invalid priority");
			break;
		case 'c':
			config.cpu = atoi(optarg);
			break;

		case 'n':
			create_new = 1;
			config.id  = atoi(optarg);
			break;
		case 'a':
			attach_pid = atoi(optarg);
			if (!attach_pid)
				usage("-a: invalid PID");
			break;

		case 'r':
			config.id  = atoi(optarg);
			break;

		case 't':
			if (strcmp(optarg, "polling-periodic") == 0) {
				res_type = PERIODIC_POLLING;
			} else if (strcmp(optarg, "polling-sporadic") == 0) {
				res_type = SPORADIC_POLLING;
			}  else if (strcmp(optarg, "table-driven") == 0) {
				res_type = TABLE_DRIVEN;
				/* Default for table-driven reservations to
				 * maximum priority. EDF has not meaning for
				 * table-driven reservations. */
				if (config.priority == LITMUS_NO_PRIORITY)
					config.priority = LITMUS_HIGHEST_PRIORITY;
			} else {
				usage("Unknown reservation type.");
			}
			break;

		case 'h':
			usage("");
			break;
		case ':':
			usage("Argument missing.");
			break;
		case '?':
		default:
			usage("Bad argument.");
			break;
		}
	}

	if (res_type != TABLE_DRIVEN) {
		config.polling_params.budget = ms2ns(budget_ms);
		config.polling_params.period = ms2ns(period_ms);
		config.polling_params.offset = ms2ns(offset_ms);
		config.polling_params.relative_deadline = ms2ns(deadline_ms);
		if (config.polling_params.budget > config.polling_params.period) {
			usage("The budget must not exceed the period.");
		}
	} else {
		config.table_driven_params.major_cycle_length = ms2ns(major_cycle_ms);
		argc -= optind;
		argv += optind;
		config.table_driven_params.intervals = parse_td_intervals(
			argc, argv, &config.table_driven_params.num_intervals,
			config.table_driven_params.major_cycle_length);
		if (!config.table_driven_params.num_intervals)
			usage("Table-driven reservations require at least one interval to be specified.");
	}

	if (create_new) {
		ret = reservation_create(res_type, &config);
		if (ret < 0) {
			fprintf(stderr, "failed to create reservation %u (%m)\n",
				config.id);
			exit(1);
		}
	}

	if (attach_pid)
		attach_task(attach_pid, &config);

	return 0;
}