/** @file
 * @author Edouard DUPIN
 * @copyright 2010, Edouard DUPIN, all right reserved
 * @license GPL v3 (see license file)
 */
#include <appl/debug.hpp>
#include <appl/global.hpp>
#include <appl/HighlightPattern.hpp>

appl::HighlightPattern::HighlightPattern(const ememory::SharedPtr<appl::GlyphPainting>& _glyphPainting, const exml::Element& _child, int32_t _level) :
  m_glyphPainting(_glyphPainting),
  m_paternName(""),
  m_hasParsingError(true),
  m_regexValue(),
  m_hasEndRegEx(false),
  m_regExp(),
  m_colorName(""),
  m_level(0) {
	parseRules(_child, _level);
}

appl::HighlightPattern::HighlightPattern() :
  m_glyphPainting(),
  m_paternName(""),
  m_hasParsingError(true),
  m_regexValue(),
  m_hasEndRegEx(false),
  m_regExp(),
  m_colorName(""),
  m_level(0) {
	
}

appl::HighlightPattern::~HighlightPattern() {
	
}

void appl::HighlightPattern::setPatern(const std::string& _regExp, const std::string& _regExpStop, bool _hasEndRegEx) {
	m_regexValue[0] = _regExp;
	m_regexValue[1] = _regExpStop;
	m_hasEndRegEx = _hasEndRegEx;
	APPL_DEBUG("parse regex='" << _regExp << "' -> '" << _regExpStop << "'");
	m_hasParsingError = false;
	if (_regExp != "") {
		try {
			m_regExp[0].assign(_regExp, std::regex_constants::optimize | std::regex_constants::ECMAScript);
		} catch (std::regex_error e) {
			m_hasParsingError = true;
			APPL_ERROR("can not parse regex : '" << e.what() << "' for : " << _regExp);
		}
	}
	if (_regExpStop != "") {
		try {
			m_regExp[1].assign(_regExpStop, std::regex_constants::optimize | std::regex_constants::ECMAScript);
		} catch (std::regex_error e) {
			m_hasParsingError = true;
			APPL_ERROR("can not parse regex : '" << e.what() << "' for : " << _regExpStop);
		}
	}
}

std::pair<std::string,std::string> appl::HighlightPattern::getPaternString() {
	return std::make_pair(m_regexValue[0], m_regexValue[1]);
}

void appl::HighlightPattern::setColorGlyph(const std::string& _colorName) {
	m_colorName = _colorName;
	m_colorId = m_glyphPainting->request(m_colorName);
	APPL_VERBOSE("Resuest color name '" << m_colorName << "' => id=" << m_colorId);
}

void appl::HighlightPattern::display() {
	APPL_INFO("patern : '" << m_paternName << "' level=" << m_level );
	APPL_INFO("  == > colorName '" << m_colorName << "'");
	APPL_INFO("  == > regex '" << m_regexValue[0] << "' ==> '" << m_regexValue[1] << "'");
}

void appl::HighlightPattern::parseRules(const exml::Element& _child, int32_t _level) {
	//--------------------------------------------------------------------------------------------
	/*
		<rule name="my preprocesseur">
			<color>preprocesseur</color>
			<regex>#</regex>
			<sub>namexxx</sub>
		</rule>
	*/
	//--------------------------------------------------------------------------------------------
	// process attribute
	std::string highLightName = _child.attributes["name"];
	std::string myEdnDataTmp = "???";
	if (highLightName.size()!=0) {
		myEdnDataTmp = highLightName;
	}
	setName(myEdnDataTmp);
	setLevel(_level);
	
	exml::Element xChild = _child.nodes["color"];
	if (xChild.exist() == true) {
		std::string myData = xChild.getText();
		if (myData.size() != 0) {
			setColorGlyph(myData);
		}
	}
	std::string paterStart;
	std::string paterStop;
	xChild = _child.nodes["regex"];
	if (xChild.exist() == true) {
		if (xChild.nodes.size() == 1 && xChild.nodes[0].getType() == exml::nodeType::text) {
			std::string myData = xChild.getText();
			if (myData.size() != 0) {
				paterStart = myData;
			}
			setPatern(paterStart);
		} else {
			exml::Element xxChild = xChild.nodes["start"];
			if (xxChild.exist() == true) {
				std::string myData = xxChild.getText();
				if (myData.size() != 0) {
					paterStart = myData;
				}
			}
			xxChild = xChild.nodes["stop"];
			if (xxChild.exist() == true) {
				std::string myData = xxChild.getText();
				if (myData.size() != 0) {
					paterStop = myData;
				}
			}
			setPatern(paterStart, paterStop, true);
		}
	}
	xChild = _child.nodes["sub"];
	if (xChild.exist() == true) {
		std::string myData = xChild.getText();
		if (myData.size() != 0) {
			setSubPatternName(myData);
		}
	}
}


static std::pair<int64_t,int64_t> findRegex(int32_t _start,
                                            int32_t _stop,
                                            std::regex& _regex,
                                            const std::string& _buffer) {
	std::smatch resultMatch;
	std::regex_constants::match_flag_type flags = std::regex_constants::match_continuous; // check only the match at the first character.
	//APPL_DEBUG("find data at : start=" << _start << " stop=" << _stop << " regex='" << m_regexValue << "'");
	if ((int64_t)_stop <= (int64_t)_buffer.size()) {
		char val = _buffer[_stop];
		if (    val != '\n'
		     && val != '\r') {
			//after last char ==> not end of line ($ would not work))
			flags |= std::regex_constants::match_not_eol;
		}
		/*
		if (!(    ('a' <= val && val <= 'z')
		       || ('A' <= val && val <= 'Z')
		       || ('0' <= val && val <= '9')
		       || val == '_')) {
			flags |= std::regex_constants::match_not_eow;
		}
		*/
	}
	if (_start>0) {
		flags |= std::regex_constants::match_prev_avail;
	}
	if (    _stop < 0
	     || size_t(_stop) > _buffer.size()) {
		APPL_ERROR(" error in indexing for regex ... _stop=" << _stop << " >= _buffer.size()=" << _buffer.size());
		return std::pair<int64_t,int64_t>(-1,0);
	}
	if (    _start < 0
	     || size_t(_start) > _buffer.size()) {
		APPL_ERROR(" error in indexing for regex ... _start=" << _start << " >= _buffer.size()=" << _buffer.size());
		return std::pair<int64_t,int64_t>(-1,0);
	}
	if (_start > _stop) {
		APPL_ERROR(" error in indexing for regex ... _start=" << _start << " > _stop=" << _stop);
		return std::pair<int64_t,int64_t>(-1,0);
	}
	std::regex_search(_buffer.begin() + _start, _buffer.begin() + _stop, resultMatch, _regex, flags);
	if (resultMatch.size() > 0) {
		int64_t start = std::distance(_buffer.begin(), resultMatch[0].first);
		int64_t stop = std::distance(_buffer.begin(), resultMatch[0].second);
		//APPL_DEBUG("find data at : start=" << _resultat.start << " stop=" << _resultat.stop << " data='" <<std::string(_buffer, _resultat.start, _resultat.stop-_resultat.start) << "'" );
		/*
		if (true){
			//TK_DEBUG("in line : '" << etk::to_string(_buffer) << "'");
			APPL_DEBUG("    Find " << resultMatch.size() << " elements");
			for (size_t iii=0; iii<resultMatch.size(); ++iii) {
				int32_t posStart = std::distance(_buffer.begin(), resultMatch[iii].first);
				int32_t posStop = std::distance(_buffer.begin(), resultMatch[iii].second);
				APPL_DEBUG("          [" << iii << "] " << posStart << " to " << posStop);
			}
		}
		*/
		return std::pair<int64_t,int64_t>(start,stop);
	}
	return std::pair<int64_t,int64_t>(-1,0);
}

bool appl::HighlightPattern::find(int32_t _start,
                                  int32_t _stop,
                                  appl::HighlightInfo& _resultat,
                                  const std::string& _buffer) {
	//APPL_DEBUG(" try to find the element");
	_resultat.start = -1;
	_resultat.stop = -1;
	_resultat.notEnded = false;
	_resultat.patern = this;
	if (m_hasParsingError == true) {
		return false;
	}
	// phase 1 start regEx or global regex:
	if (m_regexValue[0].size() == 0) {
		return false;
	}
	std::pair<int64_t,int64_t> ret0 = findRegex(_start, _stop, m_regExp[0], _buffer);
	if (ret0.first >= 0) {
		_resultat.start = ret0.first;
		_resultat.stop = ret0.second;
		//APPL_DEBUG("find data at : start=" << _resultat.start << " stop=" << _resultat.stop << " data='" <<std::string(_buffer, _resultat.start, _resultat.stop-_resultat.start) << "'" );
		// second step : Complex searching ...
		if (m_hasEndRegEx == true) {
			// when no regex specify ==> get all the buffer ...
			if (m_regexValue[1].size() == 0) {
				_resultat.stop = _stop;
				return true;
			}
			_start = _resultat.stop;
			while (_start < _stop) {
				std::pair<int64_t,int64_t> ret1 = findRegex(_start, _stop, m_regExp[1], _buffer);
				if (ret1.first >= 0) {
					_resultat.stop = ret1.second;
					return true;
				}
				_start++;
			}
			_resultat.stop = _stop;
			_resultat.notEnded = true; // TODO : Manege back the not ended ...
			return false;
		}
		return true;
	}
	return false;
}