#include "FileVersion.hpp"
#include <cassert>
#include <cstring>
#include <fstream>
#include <sstream>
#include <regex>

namespace {
	bool ParseVersionFromELF(const std::string& filename, FileVersion::VersionInfo& info) {
		std::ifstream file(filename, std::ios::binary);
		if (!file) return false;

		// ELF魔数检查 (7F 45 4C 46)
		char magic[4];
		file.read(magic, 4);
		if (strncmp(magic, "\x7F""ELF", 4) != 0)
			return false;

		// 简化的ELF解析逻辑 - 实际项目应使用libelf
		file.seekg(0, std::ios::end);
		size_t size = file.tellg();
		file.seekg(0);

		std::string content(size, '\0');
		file.read(&content[0], size);

		// 使用正则表达式查找版本模式 (例如: "1.2.3.4")
		std::regex version_re(R"((\d+)\.(\d+)\.(\d+)\.(\d+))");
		std::smatch match;

		if (std::regex_search(content, match, version_re)) {
			info.major = static_cast<uint16_t>(std::stoi(match[1]));
			info.minor = static_cast<uint16_t>(std::stoi(match[2]));
			info.build = static_cast<uint16_t>(std::stoi(match[3]));
			info.revision = static_cast<uint16_t>(std::stoi(match[4]));
			return true;
		}
		return false;
	}
}

//-----------------------------------------------------------------------------
//		FileVersion
//-----------------------------------------------------------------------------

FileVersion::FileVersion() : m_bValid(false) {
	memset(&m_version, 0, sizeof(m_version));
}

FileVersion::FileVersion(const char* lpszFileName) : m_bValid(false) {
	memset(&m_version, 0, sizeof(m_version));
	Open(lpszFileName);
}

FileVersion::~FileVersion (void){
	Close ();
}

void FileVersion::Close() {
	m_bValid = false;
	memset(&m_version, 0, sizeof(m_version));
}

bool FileVersion::Open(const char* lpszFileName) {
	if (!lpszFileName) {
		assert(false);
		return false;
	}

	Close();
	m_bValid = GetVersionInfo(lpszFileName);
	return m_bValid;
}


bool FileVersion::GetVersionInfo (const char* lpszFileName)
{
	return ParseVersionFromELF(lpszFileName, m_version);
}

bool FileVersion::IsValid() const { return m_bValid; }

uint16_t FileVersion::GetVersionMajor() const {
	assert(m_bValid);
	return m_version.major;
}

uint16_t FileVersion::GetVersionMinor() const {
	assert(m_bValid);
	return m_version.minor;
}

uint16_t FileVersion::GetVersionBuild() const {
	assert(m_bValid);
	return m_version.build;
}

uint16_t FileVersion::GetVersionRevision() const {
	assert(m_bValid);
	return m_version.revision;
}

std::string FileVersion::GetVersionString() const {
	if (!m_bValid) return "";

	return std::to_string(m_version.major) + "." +
		std::to_string(m_version.minor) + "." +
		std::to_string(m_version.build) + "." +
		std::to_string(m_version.revision);
}