#include "pistring.h"


void PIString::appendFromChars(const char * c, int s) {
	int sz;
	wchar_t wc;
	for (int i = 0; i < s; ++i) {
		if (/*isascii(c[i])*/c[i] >= 0) {
			push_back(PIChar(c[i]));
			continue;
		}
		sz = mbtowc(&wc, &c[i], 4);
		//cout << sz << endl;
		switch (sz) {
		case 4:
			push_back(PIChar(*(int*)&(c[i])));
			i += 3;
			continue;
		case 3:
			push_back(PIChar(*(int*)&(c[i])));
			back().ch &= 0xFFFFFF;
			i += 2;
			continue;
		case 2:
			push_back(PIChar(*(short * )&(c[i])));
			++i;
			continue;
		default:
			push_back(PIChar(c[i]));
			break;
		}
	}
}


PIString & PIString::operator +=(const char * str) {
	int l = 0;
	while (str[l] != '\0') ++l;
	appendFromChars(str, l);
	return *this;
}


PIString & PIString::operator +=(const wchar_t * str) {
	//cout << "wc" << endl;
	int l = 0, sz;
	char * c = new char[MB_CUR_MAX];
	while (str[l] != 0) ++l;
	for (int i = 0; i < l; ++i) {
		sz = wctomb(c, str[i]);
		switch (sz) {
		case 4:
			push_back(PIChar(*(int*)c));
			continue;
		case 3:
			push_back(PIChar(*(int*)c));
			back().ch &= 0xFFFFFF;
			continue;
		case 2:
			push_back(PIChar(*(short * )c));
			continue;
		default:
			push_back(PIChar(c[0]));
			break;
		}
	}
	delete c;
	return *this;
}


PIString & PIString::operator +=(const wstring & str) {
	uint l = str.size();
	for (uint i = 0; i < l; ++i) push_back(str[i]);
	return *this;
}


PIString & PIString::operator +=(const PIString & str) {
	uint l = str.size();
	for (uint i = 0; i < l; ++i) push_back(str[i]);
	return *this;
}


bool PIString::operator ==(const PIString & str) const {
	uint l = str.size();
	if (size() != l) return false;
	for (uint i = 0; i < l; ++i)
		if (str[i] != at(i))
			return false;
	return true;
}


bool PIString::operator !=(const PIString & str) const {
	uint l = str.size();
	if (size() != l) return true;
	for (uint i = 0; i < l; ++i)
		if (str[i] != at(i))
			return true;
	return false;
}


bool PIString::operator <(const PIString & str) const {
	uint l = str.size();
	if (size() < l) return true;
	if (size() > l) return false;
	for (uint i = 0; i < l; ++i) {
		if (str[i] == at(i)) continue;
		if (str[i] < at(i)) return true;
		else return false;
	}
	return false;
}


bool PIString::operator >(const PIString & str) const {
	uint l = str.size();
	if (size() < l) return false;
	if (size() > l) return true;
	for (uint i = 0; i < l; ++i) {
		if (str[i] == at(i)) continue;
		if (str[i] < at(i)) return false;
		else return true;
	}
	return false;
}


PIString PIString::mid(const int start, const int len) const {
	PIString str;
	int s = start, l = len;
	if (l == 0) return str;
	if (s < 0) {
		l += s;
		s = 0;
	}
	if (l < 0) {
		for (uint i = s; i < size(); ++i)
			str += at(i);
	} else {
		if (l > length() - s)
			l = length() - s;
		for (int i = s; i < s + l; ++i)
			str += at(i);
	}
	return str;
}


PIString & PIString::cutMid(const int start, const int len) {
	int s = start, l = len;
	if (l == 0) return *this;
	if (s < 0) {
		l += s;
		s = 0;
	}
	if (l < 0)
		remove(s, size() - s);
	else {
		if (l > length() - s)
			l = length() - s;
		remove(s, l);
	}
	return *this;
}


PIString & PIString::trim() {
	int st = 0, fn = 0;
	for (int i = 0; i < length(); ++i)
		if (at(i) != ' ' && at(i) != '\t')
			{st = i; break;}
	for (int i = length() - 1; i >= 0; --i)
		if (at(i) != ' ' && at(i) != '\t')
			{fn = i; break;}
	*this = mid(st, fn - st + 1);
	return *this;
}


PIString PIString::trimmed() const {
	int st = 0, fn = 0;
	for (int i = 0; i < length(); ++i)
		if (at(i) != ' ' && at(i) != '\t')
			{st = i; break;}
	for (int i = length() - 1; i >= 0; --i)
		if (at(i) != ' ' && at(i) != '\t')
			{fn = i; break;}
	return mid(st, fn - st + 1);
}


PIString & PIString::replace(int from, int count, const PIString & with) {
	if (count < length() - from) remove(from, count);
	else remove(from, length() - from);
	uint c = with.length();
	for (uint i = 0; i < c; ++i) insert(from + i, with[i]);
	return *this;
}


PIString & PIString::replace(const PIString & what, const PIString & with, bool * ok) {
	int s = find(what);
	if (s >= 0) replace(s, what.length(), with);
	if (ok != 0) *ok = (s >= 0);
	return *this;
}


PIString & PIString::replaceAll(const PIString & what, const PIString & with) {
	bool ok = true;
	while (ok) replace(what, with, &ok);
	return *this;
}


PIString & PIString::insert(int index, const PIString & str) {
	uint c = str.length();
	for (uint i = 0; i < c; ++i) insert(index + i, str[i]);
	return *this;
}


PIStringList PIString::split(const PIString & delim) const {
	PIStringList sl;
	if (isEmpty() || delim.isEmpty()) return sl;
	PIString ts(*this);
	int ci = ts.find(delim);
	while (ci >= 0) {
		sl << ts.left(ci);
		ts.cutLeft(ci + delim.length());
		ci = ts.find(delim);
	}
	if (ts.length() > 0) sl << ts;
	return sl;
}


int PIString::find(const char str, const int start) const {
	for (int i = start; i < length(); ++i)
		if (at(i) == str)
			return i;
	return -1;
}


int PIString::find(const PIString str, const int start) const {
	int l = str.length();
	for (int i = start; i < length() - l + 1; ++i)
		if (mid(i, l) == str)
			return i;
	return -1;
}


int PIString::findLast(const char str, const int start) const {
	for (int i = length() - 1; i >= start; --i)
		if (at(i) == str)
			return i;
	return -1;
}


int PIString::findLast(const PIString str, const int start) const {
	int l = str.length();
	for (int i = length() - l; i >= start; --i)
		if (mid(i, l) == str)
			return i;
	return -1;
}


PIString PIString::toUpperCase() const {
	PIString str(*this);
	int l = str.size();
	for (int i = 0; i < l; ++i) str[i] = str[i].toUpper();
	return str;
}


PIString PIString::toLowerCase() const {
	PIString str(*this);
	int l = str.size();
	for (int i = 0; i < l; ++i) str[i] = str[i].toLower();
	return str;
}


string PIString::convertToStd() const {
	string s;
	if (size() > 0) {
		for (int i = 0; i < length(); ++i) {
			if (at(i).isAscii())
				s.push_back(at(i).toAscii());
			else {
				s.push_back(at(i).toCharPtr()[0]);
				s.push_back(at(i).toCharPtr()[1]);
			}
		}
	}
	return s;
}


char PIString::toChar() const {
	PIString s(toNativeDecimalPoints());
	char v;
	sscanf(s.stdString().c_str(), "%c", &v);
	return v;
}


short PIString::toShort() const {
	PIString s(trimmed().toLowerCase().toNativeDecimalPoints());
	short v;
	if (s.left(2) == "0x") {sscanf(s.stdString().c_str(), "%hx", &v); return v;}
	if (s.left(1) == "0") {sscanf(s.stdString().c_str(), "%ho", &v); return v;}
	sscanf(s.stdString().c_str(), "%hd", &v);
	return v;
}


int PIString::toInt() const {
	PIString s(trimmed().toLowerCase().toNativeDecimalPoints());
	int v;
	if (s.left(2) == "0x") {sscanf(s.stdString().c_str(), "%x", &v); return v;}
	if (s.left(1) == "0") {sscanf(s.stdString().c_str(), "%o", &v); return v;}
	sscanf(s.stdString().c_str(), "%d", &v);
	return v;
}


long PIString::toLong() const {
	PIString s(trimmed().toLowerCase().toNativeDecimalPoints());
	long v;
	if (s.left(2) == "0x") {sscanf(s.stdString().c_str(), "%lx", &v); return v;}
	if (s.left(1) == "0") {sscanf(s.stdString().c_str(), "%lo", &v); return v;}
	sscanf(s.stdString().c_str(), "%ld", &v);
	return v;
}


llong PIString::toLLong() const {
	PIString s(trimmed().toLowerCase().toNativeDecimalPoints());
	llong v;
	if (s.left(2) == "0x") {sscanf(s.stdString().c_str(), "%llx", &v); return v;}
	if (s.left(1) == "0") {sscanf(s.stdString().c_str(), "%llo", &v); return v;}
	sscanf(s.stdString().c_str(), "%lld", &v);
	return v;
}


char chrUpr(char c) {
	if (c >= 'a' && c <= 'z') return c + 'A' - 'a';
	//if (c >= 'а' && c <= 'я') return c + 'А' - 'а';
	return c;
}


char chrLwr(char c) {
	if (c >= 'A' && c <= 'Z') return c + 'a' - 'A';
	//if (c >= 'А' && c <= 'Я') return c + 'а' - 'А';
	return c;
}


PIStringList& PIStringList::removeDuplicates() {
	PIStringList l;
	PIString s;
	bool ae;
	for (uint i = 0; i < size(); ++i) {
		ae = false;
		s = at(i);
		for (uint j = 0; j < l.size(); ++j) {
			if (s != l[j]) continue;
			ae = true; break;
		}
		if (!ae) {
			l << s;
			continue;
		}
		remove(i);
		--i;
	}
	return *this;
}