/*
 * Copyright (C)2005-2019 Haxe Foundation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

import python.internal.UBuiltins;
import python.lib.Re;
import python.lib.Re.MatchObject;
import python.lib.Re.Pattern;

@:coreApi
class EReg {
	var pattern:Regex;
	var matchObj:MatchObject;
	var global:Bool;

	public function new(r:String, opt:String) {
		global = false;
		var options = 0;
		for (i in 0...opt.length) {
			var c = StringTools.fastCodeAt(opt, i);
			if (c == "m".code)
				options |= Re.M;
			if (c == "i".code)
				options |= Re.I;
			if (c == "s".code)
				options |= Re.S;
			if (c == "u".code)
				options |= Re.U;
			if (c == "g".code)
				global = true;
		}
		pattern = Re.compile(r, options);
	}

	public inline function match(s:String):Bool {
		matchObj = Re.search(pattern, s);
		return matchObj != null;
	}

	public inline function matched(n:Int):String {
		return matchObj.group(n);
	}

	public inline function matchedLeft():String {
		return matchObj.string.substr(0, matchObj.start());
	}

	public inline function matchedRight():String {
		return matchObj.string.substr(matchObj.end());
	}

	public inline function matchedPos():{pos:Int, len:Int} {
		return {pos: matchObj.start(), len: matchObj.end() - matchObj.start()};
	}

	public function matchSub(s:String, pos:Int, len:Int = -1):Bool {
		if (len != -1) {
			matchObj = pattern.search(s, pos, pos + len);
		} else {
			matchObj = pattern.search(s, pos);
		}

		return this.matchObj != null;
	}

	public function split(s:String):Array<String> {
		return if (global) {
			var ret = [];
			var lastEnd = 0;

			for (x in Re.finditer(pattern, s)) {
				ret.push(s.substring(lastEnd, x.start()));
				lastEnd = x.end();
			}
			ret.push(s.substr(lastEnd));
			ret;
		} else {
			this.match(s);
			if (matchObj == null) {
				[s];
			} else {
				[s.substring(0, matchObj.start()), s.substr(matchObj.end())];
			}
		}
	}

	public function replace(s:String, by:String):String {
		var by = by.split("$$").join("_hx_#repl#__");
		function replace(x:MatchObject) {
			var res = by;
			var g = x.groups();
			for (i in 0...g.length) {
				var gs = g[i];
				if (gs == null)
					continue;
				res = res.split("$" + UBuiltins.str(i + 1)).join(gs);
			}
			res = res.split("_hx_#repl#__").join("$");
			return res;
		}
		return Re.sub(pattern, replace, s, global ? 0 : 1);
	}

	public function map(s:String, f:EReg->String):String {
		var buf = new StringBuf();
		var pos = 0;
		var right = s;

		var cur = this;
		while (pos < s.length) {
			if (matchObj == null) {
				matchObj = Re.search(pattern, s);
			} else {
				matchObj = matchObj.re.search(s, pos);
			}

			if (matchObj == null)
				break;

			var pos1 = matchObj.end();

			var curPos = cur.matchedPos();

			buf.add(cur.matchedLeft().substr(pos));
			buf.add(f(cur));

			right = cur.matchedRight();

			if (!global) {
				buf.add(right);
				return buf.toString();
			}

			if (curPos.len == 0) {
				buf.add(s.charAt(pos1));
				right = right.substr(1);
				pos = pos1 + 1;
			} else {
				pos = pos1;
			}
		}
		buf.add(right);
		return buf.toString();
	}

	public static inline function escape(s:String):String {
		return Re.escape(s);
	}
}
