#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#include <unistd.h>

#include <filetype.h>
#include <test_read.h>
#include <test_write.h>
#include <test_create.h>
#include <test_delete.h>
#include <test_rename.h>
#include <test_link.h>
#include <test_lock.h>
#include <test_exec.h>


#define RESULT_OK "[   \x1b[1m\x1b[32mOK\x1b[39m\x1b[0m   ]"
#define RESULT_NG "[   \x1b[1m\x1b[31mNG\x1b[39m\x1b[0m   ]"

#ifdef UNITTEST
#define main test_main
#endif

typedef struct {
	const char* command;
	void (*cmd_func)(int argc, char* argv[]);
} CommandFunction;

void exec_command(int argc, char* argv[]);
void print_usage(int argc, char* argv[]);
void cmd_read(int argc, char* argv[]);
void cmd_write(int argc, char* argv[]);
void cmd_append(int argc, char* argv[]);
void cmd_create(int argc, char* argv[]);
void cmd_delete(int argc, char* argv[]);
void cmd_rename(int argc, char* argv[]);
void cmd_link(int argc, char* argv[]);
void cmd_lock(int argc, char* argv[]);
void cmd_exec(int argc, char* argv[]);

CommandFunction FUNC_TABLE[] = {
	{	"read"		, cmd_read		},
	{	"write"		, cmd_write		},
	{	"append"	, cmd_append	},
	{	"create"	, cmd_create	},
	{	"delete"	, cmd_delete	},
	{	"rename"	, cmd_rename	},
	{	"link"		, cmd_link		},
	{	"lock"		, cmd_lock		},
	{	"exec"		, cmd_exec		},
	{	"--help"	, print_usage	},
	{	NULL		, NULL			}
};







int main(int argc, char* argv[])
{
	exec_command(argc, argv);
	/*
	if (argc < 2)
	{
		print_usage();
		return 1;
	}

	const char* pathname = argv[1];
	*/
	/*
	bool ret = is_exists(pathname);
	printf("isexists = %d\n", ret);
	*/

	/*
	snprintf(buf, sizeof(buf), "%s.%s", pathname, "regular-file");
	ret = can_create_file(buf);
	printf("file = %d\n", ret);

	snprintf(buf, sizeof(buf), "%s.%s", pathname, "directory");
	ret = can_create_directory(buf);
	printf("directory = %d\n", ret);

	snprintf(buf, sizeof(buf), "%s.%s", pathname, "cdev-random");
	ret = can_create_character_device_file(buf, 1, 8);
	printf("cdev[r] = %d\n", ret);

	snprintf(buf, sizeof(buf), "%s.%s", pathname, "cdev-null");
	ret = can_create_character_device_file(buf, 1, 8);
	printf("cdev[w] = %d\n", ret);

	snprintf(buf, sizeof(buf), "%s.%s", pathname, "loopback");
	ret = can_create_block_device_file(buf, 7, 15);
	printf("bdev = %d\n", ret);

	snprintf(buf, sizeof(buf), "%s.%s", pathname, "socket");
	ret = can_create_socket(buf);
	printf("socket = %d\n", ret);

	snprintf(buf, sizeof(buf), "%s.%s", pathname, "pipe");
	ret = can_create_fifo(buf);
	printf("pipe = %d\n", ret);

	snprintf(buf, sizeof(buf), "%s.%s", pathname, "lnk");
	ret = can_create_symbolic_link(buf, "access-test");
	printf("link = %d\n", ret);

	snprintf(buf, sizeof(buf), "%s.%s", pathname, "regular-file");
	ret = can_delete(buf);
	printf("ret = %d\n", ret);
	*/



	return 0;
}





void exec_command(int argc, char* argv[])
{
	if (argc >= 2)
	{
		CommandFunction* cf = &FUNC_TABLE[0];
		while (cf->command != NULL)
		{
			if (strcmp(cf->command, argv[1]) == 0)
			{
				cf->cmd_func(argc, argv);
				return;
			}
			cf++;
		}
	}
	// ここに来たらエラー
	print_usage(argc, argv);
}


// read [pathname]
void cmd_read(int argc, char* argv[])
{
	if (argc >= 3)
	{
		const char* pathname = argv[2];
		bool ret = can_read(pathname);
		printf(" %-10s : %-50s  %s\n", "read", pathname, (ret) ? RESULT_OK : RESULT_NG);
	}
	else
	{
		print_usage(argc, argv);
	}
}

void cmd_write(int argc, char* argv[])
{
	if (argc >= 3)
	{
		const char* pathname = argv[2];
		bool ret = can_write(pathname);
		printf(" %-10s : %-50s  %s\n", "write", pathname, (ret) ? RESULT_OK : RESULT_NG);
	}
	else
	{
		print_usage(argc, argv);
	}
}

void cmd_append(int argc, char* argv[])
{
	if (argc >= 3)
	{
		const char* pathname = argv[2];
		bool ret = can_write(pathname);
		printf(" %-10s : %-50s  %s\n", "append", pathname, (ret) ? RESULT_OK : RESULT_NG);
	}
	else
	{
		print_usage(argc, argv);
	}
}
void cmd_create(int argc, char* argv[])
{
	if (argc >= 4)
	{
		int maj, min;
		const char* cmdname;
		const char* pathname = argv[2];
		char type = argv[3][0];
		bool ret = false;
		switch (type)
		{
			case 'r':
				cmdname = "create[r]";
				ret = can_create_file(pathname);
				break;
			case 'd':
				cmdname = "create[d]";
				ret = can_create_directory(pathname);
				break;
			case 'c':
				cmdname = "create[c]";
				maj = (argc >= 5) ? atoi(argv[4]) : 1;
				min = (argc >= 6) ? atoi(argv[5]) : 3;
				ret = can_create_character_device_file(pathname, maj, min);
				break;
			case 'b':
				cmdname = "create[b]";
				maj = (argc >= 5) ? atoi(argv[4]) : 1;
				min = (argc >= 6) ? atoi(argv[5]) : 3;
				ret = can_create_block_device_file(pathname, maj, min);
				break;
			case 's':
				cmdname = "create[s]";
				ret = can_create_socket(pathname);
				break;
			case 'p':
				cmdname = "create[p]";
				ret = can_create_fifo(pathname);
				break;
			case 'l':
				cmdname = "create[l]";
				if (argc >= 5)
				{
					const char* target = argv[4];
					ret = can_create_symbolic_link(pathname, target);
				}
				else
				{
					print_usage(argc, argv);
					return;
				}
				break;
			default:
				cmdname = "create[-]";
				ret = false;
				break;
		}
		printf(" %-10s : %-50s  %s\n", cmdname, pathname, (ret) ? RESULT_OK : RESULT_NG);

	}
	else
	{
		print_usage(argc, argv);
	}
}
void cmd_delete(int argc, char* argv[])
{
	if (argc >= 3)
	{
		const char* pathname = argv[2];
		bool ret = can_delete(pathname);
		printf(" %-10s : %-50s  %s\n", "delete", pathname, (ret) ? RESULT_OK : RESULT_NG);
	}
	else
	{
		print_usage(argc, argv);
	}
}
void cmd_rename(int argc, char* argv[])
{
	if (argc >= 4)
	{
		const char* pathname = argv[2];
		const char* newpath  = argv[3];
		bool ret = can_rename(pathname, newpath);
		printf(" %-10s : %-50s  %s\n", "rename", pathname, (ret) ? RESULT_OK : RESULT_NG);
	}
	else
	{
		print_usage(argc, argv);
	}
}
void cmd_link(int argc, char* argv[])
{
	if (argc >= 4)
	{
		const char* pathname = argv[2];
		const char* linkpath = argv[3];
		bool ret = can_link(pathname, linkpath);
		printf(" %-10s : %-50s  %s\n", "link", pathname, (ret) ? RESULT_OK : RESULT_NG);
	}
	else
	{
		print_usage(argc, argv);
	}
}
void cmd_lock(int argc, char* argv[])
{
	if (argc >= 3)
	{
		const char* pathname = argv[2];
		bool ret = can_lock(pathname, false);
		printf(" %-10s : %-50s  %s\n", "lock", pathname, (ret) ? RESULT_OK : RESULT_NG);
	}
	else
	{
		print_usage(argc, argv);
	}
}
void cmd_exec(int argc, char* argv[])
{
	if (argc >= 3)
	{
		const char* pathname = argv[2];
		bool ret = can_exec(pathname);
		printf(" %-10s : %-50s  %s\n", "exec", pathname, (ret) ? RESULT_OK : RESULT_NG);
	}
	else
	{
		print_usage(argc, argv);
	}
}


/**
 * Usage 出力します。
 */
void print_usage(int argc, char* argv[])
{
	(void) argc;
	(void) argv;
	printf("Usage\n");
	printf("./test-access [command] [command args...]\n");
	printf("\n");
	printf("command:\n");
	printf("  read   : read   [pathname]\n");
	printf("  write  : write  [pathname]\n");
	printf("  append : append [pathname]\n");
	printf("  create : create [pathname] [args]\n");
	printf("           args:\n");
	printf("             r                 : regular file\n");
	printf("             d                 : directory\n");
	printf("             c [major] [minor] : character device\n");
	printf("	                             Ex. create [pathname] c 1 3 --> null\n");
	printf("	                             Ex. create [pathname] c 1 8 --> random\n");
	printf("             b [major] [minor] : block device\n");
	printf("	                             Ex. create [pathname] b 7 15 --> loopback15\n");
	printf("             s                 : socket\n");
	printf("             p                 : pipe\n");
	printf("             l                 : link [frompath]\n");
	printf("  delete : delete [pathname]\n");
	printf("  rename : rename [pathname] [newpathname]\n");
	printf("  link   : link   [pathname] [linkpath]\n");
	printf("  lock   : lock   [pathname]\n");
	printf("  exec   : exec   [pathname]\n");
	printf("\n");
}