#include <iostream>
#include <iomanip>
#include <memory>
#include <thread>
#include <chrono>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
#include <sys/file.h>
#include <functional>

#include "async_scanner.h"

#define BUF_LEN_FOR_PID 64


static async_scanner	*scanner = nullptr;
static void sigHandler(int sig)
{
	// if (sig == SIGINT || sig == SIGTERM)
	// 	remove(MY_PID_FILE);
    printf("exit now for signal: %d\n", sig);
	if(scanner)
	{
		scanner->stop();
		scanner->release();
	}

	_exit(0);
}
static std::string get_command(void)
{
	std::string cmd("");
	char		in[2] = {0};

	while((in[0] = getchar()) != 0x0a)
		cmd += in;

	return std::move(cmd);
}

namespace test_cmd
{
	static void skip_space(const char*& ptr)
	{
		while(*ptr == ' ')
			ptr++;
	}

	static const char* free_cmd = "free ";
	static void free_memory(const char* cmd)
	{
		uint64_t	addr = 0;
		if(strstr(cmd, " 0x"))
		{
			cmd = strstr(cmd, " 0x") + 3;
			utils::from_hex_string(cmd, &addr);
		}
		else
		{
			cmd += strlen(free_cmd);
			addr = atoll(cmd);
		}
		printf("\t free %p? ", addr);
		if(getchar() == 'y')
			free((void*)addr);
	}

	static const char* rdm_cmd = "rdmem ";
	static void read_memory(const char* cmd)
	{
		uint64_t	addr = 0;
		if(strstr(cmd, " 0x"))
		{
			cmd = strstr(cmd, " 0x") + 3;
			utils::from_hex_string(cmd, &addr);
		}
		else
		{
			cmd += strlen(free_cmd);
			addr = atoll(cmd);
		}
		printf("\t read memory %p? ", addr);
		if(getchar() == 'y')
		{
			int	len = 128, off = 0;
			skip_space(cmd);
			cmd = strstr(cmd, " ");
			if(cmd)
			{
				skip_space(cmd);
				len = atoi(cmd);
			}

			uint8_t	*ptr = (uint8_t*)addr;
			std::string	str("");
			char		buf[2] = {0};
			for(; off < len; )
			{
				printf("%p: ", ptr + off);
				for(int c = 0; off < len && c < 16; ++c, ++off)
				{
					printf("%02X ", ptr[off]);
					if(ptr[off] >= ' ' && ptr[off] < 0x7f)
					{
						buf[0] = ptr[off];
						str += buf;
					}
					else
						str += ".";

					if((c + 1) % 16 == 0)
					{
						printf("    %s\n", str.c_str());
						str = "";
					}
					else if((c + 1) % 8 == 0)
					{
						printf(" ");
					}
				}
			}
			if(str.length())
				printf("    %s\n", str.c_str());
		}
	}

};

int main()
{
	/* Ctrl + C */
	if (signal(SIGINT, sigHandler) == SIG_ERR)
	{
		exit(-1);
	}

	/* kill pid / killall name */
	if (signal(SIGTERM, sigHandler) == SIG_ERR)
	{
		exit(-1);
	}

	/* kill pid / killall name */
	signal(SIGKILL, sigHandler);
	
	scanner = new async_scanner();
	int	err = scanner->last_error();

	while(err == 0)
	{
		std::string cmd(get_command());
		if(cmd == "exit")
			break;
		if(cmd == "mem")
			utils::print_memory_usage("    Memory usage", false);
		if(cmd.find(test_cmd::free_cmd) == 0)
			test_cmd::free_memory(cmd.c_str());
		if(cmd.find(test_cmd::rdm_cmd) == 0)
			test_cmd::read_memory(cmd.c_str());
	}

	async_scanner* tmp = scanner;

	scanner = nullptr;
	tmp->stop();
	tmp->release();

    return 0;
}