#include <iostream>
#include <fstream>
#include <vector>

#include <hs.h>

class HyperscanTest
{
public:
	HyperscanTest()
	{
		db_ = nullptr;
		scratch_ = nullptr;
	}

	~HyperscanTest()
	{
		hs_free_scratch(scratch_);
		hs_free_database(db_);
	}

	// 정규표현식 샘플 패턴이 저장된 파일을 Hyperscan Pattern DB를 컴파일하기 위한 형태로 파싱해주는 함수입니다.
	//
	// 파싱하는 파일의 구조는 <id>:/<pattern>/<flags> 형태이며, 
	// id/pattern/flags를 각각 멤버 변수인 ids_, patterns_, flags_에 저장합니다.
	bool parseFile(const std::string &filename)
	{
		std::ifstream inFile(filename, std::ifstream::in);
		if (!inFile.good())
		{
			std::cout << "ERROR: unable to open file \"" << filename << "\"" << std::endl;
			return false;
		}

		for (int i = 1; !inFile.eof(); i++)
		{
			std::string line;
			getline(inFile, line);

			if (line.empty() || line[0] == '#')
			{
				continue;
			}

			size_t colonIdx = line.find_first_of(':');
			if (colonIdx == std::string::npos)
			{
				std::cout << "ERROR: Could not parse line " << i << std::endl;
				inFile.close();
				return false;
			}

			unsigned int id = std::stoi(line.substr(0, colonIdx).c_str());

			const std::string expr(line.substr(colonIdx + 1));

			size_t flagsStart = expr.find_last_of('/');
			if (flagsStart == std::string::npos)
			{
				std::cout << "ERROR: no trailing '/' char" << std::endl;
				inFile.close();
				return false;
			}

			std::string pcre(expr.substr(1, flagsStart - 1));
			std::string flagsStr(expr.substr(flagsStart + 1, expr.size() - flagsStart));
			unsigned int flag = parseFlags(flagsStr);

			patterns_.push_back(pcre);
			flags_.push_back(flag);
			ids_.push_back(id);
		}

		inFile.close();
		return true;
	}

	// 파싱된 데이터들을 활용하여 Hyperscan에서 사용하는 Pattern DB를 컴파일하는 함수입니다.
	bool compileDatabase()
	{
		hs_database_t *db = nullptr;
		hs_compile_error_t *compileErr;

		std::vector<const char *> cstrPatterns;
		cstrPatterns.reserve(patterns_.size());
		for (const auto &pattern : patterns_)
		{
			cstrPatterns.push_back(pattern.c_str());
		}

		hs_error_t err_compile = hs_compile_multi(cstrPatterns.data(), flags_.data(), ids_.data(), cstrPatterns.size(), HS_MODE_BLOCK, nullptr, &db, &compileErr);
		if (err_compile != HS_SUCCESS)
		{
			if (compileErr->expression < 0)
			{
				std::cout << "ERROR: " << compileErr->message << std::endl;
				hs_free_compile_error(compileErr);
				return false;
			}
			else
			{
				std::cout << "ERROR: Pattern '" << patterns_[compileErr->expression] << "' failed with error '" << compileErr->message << "'" << std::endl;
				hs_free_compile_error(compileErr);
				return false;
			}
		}

		if (db_ != nullptr)
			hs_free_database(db_);

		db_ = db;

		hs_error_t err_scratch = hs_alloc_scratch(db_, &scratch_);
		if (err_scratch != HS_SUCCESS)
		{
			std::cout << "ERROR: hs_alloc_scratch failed." << std::endl;
			return false;
		}

		return true;
	}

	// 인자로 전달된 패턴 정보가 Hyperscan Pattern DB에 존재하는지 여부를 반환하는 함수입니다.
	bool scanPattern(std::string pattern)
	{
		unsigned int match_count = 0;

		// 매칭되는 패턴이 Hyperscan Pattern DB에 존재한다면 hs_scan 함수의 6번째 인자로 등록되는 
		// 콜백 함수(해당 코드에서는 람다 함수로 구현)를 통해 결과를 확인할 수 있으며,
		// 5번째 인자인 ctx를 통해 hs_scan 외부의 변수에 콜백 함수의 결과를 저장할 수도 있습니다.
		if (hs_scan(
				db_,
				pattern.c_str(),
				pattern.length(),
				0,
				scratch_,
				[](unsigned int id, unsigned long long from, unsigned long long to, unsigned int flags, void *ctx) -> int
				{
					size_t *matches = (size_t *)ctx;
					(*matches)++;
					std::cout << "id: " << id << " from: " << from << " to: " << to << " flags: " << flags << std::endl;
					return 0;
				},
				&match_count) != HS_SUCCESS)
		{
			std::cout << "hs_scan failed." << std::endl;
			return false;
		}

		std::cout << "match count: " << match_count << std::endl;
		return true;
	}

private:
	hs_database_t *db_;
   	hs_stream_t *stream_;
   	hs_scratch_t *scratch_;

	std::vector<unsigned int> ids_;
   	std::vector<std::string> patterns_;
   	std::vector<unsigned int> flags_;

	// parseFile 함수에서 호출하며 파일에 등록된 flags 정보를 Hyperscan에서 정의한 상수 값으로 변환하는 작업을 합니다.
	int parseFlags(const std::string &flagsStr)
	{
		unsigned int flags = 0;

		for (const auto &c : flagsStr)
		{
			switch (c)
			{
			case 'i':
				flags |= HS_FLAG_CASELESS;
				break;
			case 'm':
				flags |= HS_FLAG_MULTILINE;
				break;
			case 's':
				flags |= HS_FLAG_DOTALL;
				break;
			case 'H':
				flags |= HS_FLAG_SINGLEMATCH;
				break;
			case 'V':
				flags |= HS_FLAG_ALLOWEMPTY;
				break;
			case '8':
				flags |= HS_FLAG_UTF8;
				break;
			case 'W':
				flags |= HS_FLAG_UCP;
				break;
			case '\r': // stray carriage-return
				break;
			}
		}

		return flags;
	}
};

int main()
{
   	HyperscanTest hst;

	// 1. 정규표현식 샘플 패턴들이 등록된 파일을 Hyperscan에서 사용 가능한 형태로 파싱
	if(!hst.parseFile("./pattern.db"))
	{
		std::cout << "parseFile failed." << std::endl;
		return 0;
	}

	// 2. Hyperscan Pattern DB 컴파일
	if(!hst.compileDatabase())
	{
		std::cout << "compileDatabase failed." << std::endl;
		return 0;
	}

	do
   	{
    	std::string pattren = "";
    	std::cout << "체크할 패턴을 입력하세요 >> ";
    	getline(std::cin, pattren);

		// 3. 컴파일된 Hyperscan Pattern DB를 기반으로 패턴 체크
		if(!hst.scanPattern(pattren))
		{
			std::cout << "scanPattern failed." << std::endl;
		}
   	} while (true);

	return 0;
}