#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <getopt.h>
#include <unistd.h>
#include <sys/types.h>

#include "parse.h"
#include "analyze.h"
#include "pidlib.h"

void print_help_and_die(char *name)
{
	printf("Usage: %s options\n"
		"-p, --pid=PID		scan maps belonging to a given pid\n"
		"-P, --process=PROCESS	scan maps belonging to processes with "
		"given name\n"
		"-m, --map=mapname	scan maps with given mapping name\n"
		"-d, --dump		dump process maps\n"
		"-s, --shared-mappings	dump only shared mappings\n"
		"-h, --help		show this help\n",
		name);

	exit(0);
}

#define OPT_WITH_THREADS	0x101

static void get_all_pids_by_name(struct parse_opts *opts, char *name)
{
	struct pidlist *pidlist;
	DIR *dir = NULL;
	int pid;

	while ((pid = get_next_pid_by_name(&dir, name))) {
		pidlist = alloc_pidlist();
		if (pidlist == NULL)
			return;
		pidlist->pid = pid;
		list_add_tail(&pidlist->list, &opts->pidlist);
	}
}

void read_args(int argc, char *argv[], struct parse_opts *opts)
{
	int optind = 0, c;
	static struct option long_options[] = {
		{ .val = 'p', .name = "pid", .has_arg = 1, },
		{ .val = 'P', .name = "process", .has_arg = 1, },
		{ .val = 'm', .name = "map", .has_arg = 1, },
		{ .val = OPT_WITH_THREADS, .name = "with-threads" },
		{ .val = 'd', .name = "dump", },
		{ .val = 's', .name = "shared-mappings", },
		{ .val = 'h', .name = "help", },
	};
	char short_options[] = "p:P:m:sdh";
	opts->parse_mask = 0;

	while (1) {
		c = getopt_long(argc, argv, short_options, long_options,
				&optind);

		if (c == -1)
			break;

		switch (c) {
		case 'p':
		{
			struct pidlist *pid = alloc_pidlist();

			if (pid == NULL) {
				perror("malloc");
				return;
			}
			pid->pid = atoi(optarg);
			opts->parse_mask |= PARSE_PID;
			list_add_tail(&pid->list, &opts->pidlist);
			break;
		}
		case 'P':
			get_all_pids_by_name(opts, optarg);
			opts->parse_mask |= PARSE_PID;
			break;
		case 'm':
			opts->parse_mask |= PARSE_MAP_NAME;
			opts->name = optarg;
			break;
		case OPT_WITH_THREADS:
			opts->with_threads = 1;
			break;
		case 's':
			opts->parse_mask |= PARSE_SHARED_MAPPING;
			/* implies --dump */
		case 'd':
			opts->parse_mask |= PARSE_DUMP;
			break;
		case 'h':
			print_help_and_die(argv[0]);
			break;
		}
	}
}

int main(int argc, char *argv[])
{
	struct pageframe pf;
	struct process process_list;
	struct parse_opts opts;

	if (geteuid()) {
		printf("WARNING: Running without root priviledges. "
			"Results may be inaccurate\n");
	}

	init_parse_opts(&opts);

	read_args(argc, argv, &opts);

	if (argc < 3) {
		printf("A pid needs to be given as an argument\n");
		print_help_and_die(argv[0]);
	}

	clear_pageframe(&pf);

	memset(&process_list, 0, sizeof(process_list));
	INIT_LIST_HEAD(&process_list.list);

	if (scan_all_pids(&pf, &process_list, &opts))
		return 1;

	update_kpageflags(&pf);

	if (opts.parse_mask & PARSE_DUMP)
		dump_process_maps(&pf, &process_list, &opts);
	else
		print_pid_stats(&pf, &process_list, &opts);

	print_page_stats(&pf);

	return 0;
}