#define _CRT_SECURE_NO_WARNINGS
#include "debug_log.hpp"

#include <atomic>
#include <cstdarg>
#include <cstdio>
#include <mutex>

#include <windows.h>

#include "coop/log_ring.hpp"

namespace coop::hook
{

namespace
{

std::mutex g_log_mutex;
FILE* g_log_file = nullptr;
bool g_log_tried = false;
std::atomic<coop::LogRing*> g_log_ring{nullptr};

// Logging is opt-in so an injected DLL doesn't write to disk in normal use.
// Enable it by setting the COOP_HOOK_LOG environment variable for the target, or
// (more practical for a Steam-launched game we can't set env on) by creating the
// sentinel file %TEMP%\coop_hook.log.on — every process sees the same %TEMP%, so
// the probe / debugger can flip it without touching the game's environment.
bool logging_enabled()
{
	wchar_t buf[8] = {};
	if (GetEnvironmentVariableW(L"COOP_HOOK_LOG", buf, 8) > 0)
	{
		return true;
	}
	wchar_t dir[MAX_PATH] = {};
	const DWORD n = GetTempPathW(MAX_PATH, dir);
	if (n != 0 && n < MAX_PATH)
	{
		const std::wstring sentinel = std::wstring(dir) + L"coop_hook.log.on";
		return GetFileAttributesW(sentinel.c_str()) != INVALID_FILE_ATTRIBUTES;
	}
	return false;
}

FILE* log_file_locked()
{
	if (!g_log_tried)
	{
		g_log_tried = true;
		if (logging_enabled())
		{
			wchar_t dir[MAX_PATH] = {};
			const DWORD n = GetTempPathW(MAX_PATH, dir);
			if (n != 0 && n < MAX_PATH)
			{
				std::wstring path = std::wstring(dir) + L"coop_hook.log";
				g_log_file = _wfopen(path.c_str(), L"a");
			}
		}
	}
	return g_log_file;
}

} // namespace

void set_log_ring(coop::LogRing* ring)
{
	g_log_ring.store(ring, std::memory_order_release);
}

namespace
{
const char* level_tag(std::uint32_t level)
{
	switch (level)
	{
	case coop::LogLevel_Warn:
		return "WARN ";
	case coop::LogLevel_Error:
		return "ERROR";
	default:
		return "info ";
	}
}

void vlog(std::uint32_t level, const char* fmt, va_list args)
{
	// Format the line once.
	char line[coop::kLogMsgLen];
	std::vsnprintf(line, sizeof(line), fmt, args);

	// Stream to the host's Log window over the shared ring (the primary sink).
	if (coop::LogRing* ring = g_log_ring.load(std::memory_order_acquire))
	{
		coop::log_ring_push(*ring, GetCurrentProcessId(), level, GetTickCount64(), line);
	}

	// Also mirror to the file when the opt-in trace is enabled.
	std::scoped_lock lock(g_log_mutex);
	FILE* f = log_file_locked();
	if (f != nullptr)
	{
		SYSTEMTIME st;
		GetLocalTime(&st);
		std::fprintf(f, "[%02u:%02u:%02u.%03u pid=%lu %s] %s\n", st.wHour, st.wMinute, st.wSecond,
		             st.wMilliseconds, GetCurrentProcessId(), level_tag(level), line);
		std::fflush(f);
	}
}
} // namespace

void logf(const char* fmt, ...)
{
	va_list args;
	va_start(args, fmt);
	vlog(coop::LogLevel_Info, fmt, args);
	va_end(args);
}

void logw(const char* fmt, ...)
{
	va_list args;
	va_start(args, fmt);
	vlog(coop::LogLevel_Warn, fmt, args);
	va_end(args);
}

void loge(const char* fmt, ...)
{
	va_list args;
	va_start(args, fmt);
	vlog(coop::LogLevel_Error, fmt, args);
	va_end(args);
}

} // namespace coop::hook