#pragma once
#if defined(__linux__)

#include "optick.config.h"
#if USE_OPTICK

#include "optick_core.platform.h"

#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/types.h>
#include <pthread.h>
#include <unistd.h>

namespace Optick
{
	const char* Platform::GetName() 
	{
		return "Linux";
	}

	ThreadID Platform::GetThreadID()
	{
		return syscall(SYS_gettid);
	}

	ProcessID Platform::GetProcessID()
	{
		return (ProcessID)getpid();
	}

	int64 Platform::GetFrequency()
	{
		return 1000000000;
	}

	int64 Platform::GetTime()
	{
		struct timespec ts;
		clock_gettime(CLOCK_MONOTONIC, &ts);
		return ts.tv_sec * 1000000000LL + ts.tv_nsec;
	}
}

#if OPTICK_ENABLE_TRACING

#include "optick_memory.h"

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
namespace ft
{
	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	struct base_event
	{
		int64_t timestamp;
		short common_type;
		uint8_t cpu_id;
		base_event(short type) : timestamp(-1), common_type(type), cpu_id(uint8_t(-1)) {}
};
	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	template<short TYPE>
	struct event : public base_event
	{
		static const short type = TYPE;
		event() : base_event(TYPE) {}
	};
	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	struct process_state
	{
		enum type
		{
			Unknown,
			//D	Uninterruptible sleep(usually IO)
			UninterruptibleSleep,
			//R	Running or runnable(on run queue)
			Running,
			//S	Interruptible sleep(waiting for an event to complete)
			InterruptibleSleep,
			//T	Stopped, either by a job control signal or because it is being traced.
			Stopped,
			//X	dead(should never be seen)
			Dead,
			//Z	Defunct(“zombie”) process, terminated but not reaped by its parent.
			Zombie,
		};
	};
	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	struct sched_switch : public event<305>
	{
		char prev_comm[16];
		pid_t prev_pid;
		int prev_prio;
		process_state::type prev_state;
		char next_comm[16];
		pid_t next_pid;
		int next_prio;
	};
	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
} // namespace ft
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Optick
{
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static const char* KERNEL_TRACING_PATH = "/sys/kernel/debug/tracing";
static const char* FTRACE_TRACE = "trace";
static const char* FTRACE_TRACING_ON = "tracing_on";
static const char* FTRACE_TRACE_CLOCK = "trace_clock";
static const char* FTRACE_OPTIONS_IRQ_INFO = "options/irq-info";
static const char* FTRACE_SCHED_SWITCH = "events/sched/sched_switch/enable";
static const uint8_t PROCESS_STATE_REASON_START = 38;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class FTrace : public Trace
{
	bool isActive;
	string password;

	bool Parse(const char* line);
	bool ProcessEvent(const ft::base_event& ev);

	void Set(const char* name, bool value);
	void Set(const char* name, const char* value);
	void Exec(const char* cmd);
public:

	FTrace();
	~FTrace();

	virtual void SetPassword(const char* pwd) override { password = pwd; }
	virtual CaptureStatus::Type Start(Mode::Type mode, int frequency, const ThreadList& threads) override;
	virtual bool Stop() override;
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
FTrace g_FTrace;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct Parser
{
	const char* cursor;
	const char* finish;
	size_t length;

	Parser(const char* b) : cursor(b), finish(b + strlen(b)) {}

	bool Skip(size_t count)
	{
		if ((size_t)(finish - cursor) > count)
		{
			cursor += count;
			return true;
		}
		return false;
	}

	bool Skip(const char* text, char* output = nullptr, size_t size = 0)
	{
		if (const char* ptr = strstr(cursor, text))
		{
			if (output != nullptr)
			{
				size_t count = std::min(size - 1, (size_t)(ptr - cursor));
				strncpy(output, cursor, count);
				output[count] = '\0';
			}
			cursor = ptr + strlen(text);
			return true;
		}
		return false;
	}

	void SkipSpaces()
	{
		while (cursor != finish && (*cursor == ' ' || *cursor == '\t' || *cursor == '\n'))
			++cursor;
	}

	bool Starts(const char* text) const
	{
		return strncmp(cursor, text, strlen(text)) == 0;
	}

	int GetInt() const
	{
		return atoi(cursor);
	}

	char GetChar() const
	{
		return *cursor;
	}
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CaptureStatus::Type FTrace::Start(Mode::Type mode, int /*frequency*/, const ThreadList& /*threads*/)
{
	if (!isActive)
	{
		// Disable tracing
		Set(FTRACE_TRACING_ON, false);
		// Cleanup old data
		Set(FTRACE_TRACE, "");
		// Set clock type
		Set(FTRACE_TRACE_CLOCK, "mono");
		// Disable irq info
		Set(FTRACE_OPTIONS_IRQ_INFO, false);
		// Enable switch events
		Set(FTRACE_SCHED_SWITCH, (mode & Mode::SWITCH_CONTEXT) != 0);

		// Enable tracing
		Set(FTRACE_TRACING_ON, true);

		isActive = true;
	}

	return CaptureStatus::OK;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool FTrace::Stop()
{
	if (!isActive)
	{
		return false;
	}

	// Reset variables
	Set(FTRACE_TRACING_ON, false);
	Set(FTRACE_SCHED_SWITCH, false);

	// Parsing the output
	char buffer[256] = { 0 };
	sprintf_s(buffer, "echo \'%s\' | sudo -S sh -c \'cat %s/%s\'", password.c_str(), KERNEL_TRACING_PATH, FTRACE_TRACE);
	if (FILE* pipe = popen(buffer, "r"))
	{
		char* line = NULL;
		size_t len = 0;
		while ((getline(&line, &len, pipe)) != -1)
			Parse(line);
		fclose(pipe);
	}

	// Cleanup data
	Set(FTRACE_TRACE, "");

	isActive = false;

	return true;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool FTrace::Parse(const char * line)
{
	// sched_switch:      
	//	   ConsoleApp-8687  [000]  181944.352057: sched_switch: prev_comm=ConsoleApp prev_pid=8687 prev_prio=120 prev_state=S ==> next_comm=ConsoleApp next_pid=8686 next_prio=120

	Parser p(line);
	if (p.Starts("#"))
		return true;

	if (!p.Skip(16))
		return false;

	if (!p.Skip("["))
		return false;

	int cpu = p.GetInt();
	if (!p.Skip("]"))
		return false;

	int64 timestampInt = p.GetInt();
	if (!p.Skip("."))
		return false;

	int64 timestampFraq = p.GetInt();
	if (!p.Skip(": "))
		return false;

	int64 timestamp = ((timestampInt * 1000000) + timestampFraq) * 1000;

	if (p.Starts("sched_switch:"))
	{
		ft::sched_switch ev;
		ev.cpu_id = cpu;
		ev.timestamp = timestamp;

		if (!p.Skip("prev_comm="))
			return false;

		if (!p.Skip(" prev_pid=", ev.prev_comm, OPTICK_ARRAY_SIZE(ev.prev_comm)))
			return false;

		ev.prev_pid = p.GetInt();

		if (!p.Skip(" prev_prio="))
			return false;

		ev.prev_prio = p.GetInt();

		if (!p.Skip(" prev_state="))
			return false;

		switch (p.GetChar())
		{
		case 'D':
			ev.prev_state = ft::process_state::UninterruptibleSleep;
			break;

		case 'R':
			ev.prev_state = ft::process_state::Running;
			break;

		case 'S':
			ev.prev_state = ft::process_state::InterruptibleSleep;
			break;

		case 'T':
			ev.prev_state = ft::process_state::Stopped;
			break;

		case 'X':
			ev.prev_state = ft::process_state::Dead;
			break;

		case 'Z':
			ev.prev_state = ft::process_state::Zombie;
			break;

		default:
			ev.prev_state = ft::process_state::Unknown;
			break;
		}

		if (!p.Skip("==> next_comm="))
			return false;

		if (!p.Skip(" next_pid=", ev.next_comm, OPTICK_ARRAY_SIZE(ev.prev_comm)))
			return false;

		ev.next_pid = p.GetInt();

		if (!p.Skip(" next_prio="))
			return false;

		ev.next_prio = p.GetInt();

		return ProcessEvent(ev);
	}
	return true;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool FTrace::ProcessEvent(const ft::base_event& ev)
{
	switch (ev.common_type)
	{
	case ft::sched_switch::type:
	{
		const ft::sched_switch& switchEv = (const ft::sched_switch&)ev;
		SwitchContextDesc desc;
		desc.reason = switchEv.prev_state + PROCESS_STATE_REASON_START;
		desc.cpuId = switchEv.cpu_id;
		desc.oldThreadId = (uint64)switchEv.prev_pid;
		desc.newThreadId = (uint64)switchEv.next_pid;
		desc.timestamp = switchEv.timestamp;
		Core::Get().ReportSwitchContext(desc);
		return true;
	}
	break;
	}

	return false;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void FTrace::Set(const char * name, bool value)
{
	Set(name, value ? "1" : "0");
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void FTrace::Set(const char* name, const char* value)
{
	char buffer[256] = { 0 };
	sprintf_s(buffer, "echo %s > %s/%s", value, KERNEL_TRACING_PATH, name);
	Exec(buffer);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void FTrace::Exec(const char* cmd)
{
	char buffer[256] = { 0 };
	sprintf_s(buffer, "echo \'%s\' | sudo -S sh -c \'%s\'", password.c_str(), cmd);
	std::system(buffer);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
FTrace::FTrace() : isActive(false)
{
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
FTrace::~FTrace()
{
	Stop();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Trace* Platform::GetTrace()
{
	return &g_FTrace;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SymbolEngine* Platform::GetSymbolEngine()
{
	return nullptr;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
#endif //OPTICK_ENABLE_TRACING
#endif //USE_OPTICK
#endif //__linux__