#include "ChangeFSPos.h"
#include <iomanip> 

void ChangeFSPos::reset()
{
	Lbp = 0.0;
	stnap = 0.0;
	stnfp = 0.0;
	rfrno = 0.0;
	iframe = 1;

	nfrtab = 0;			// 肋位数
	std::vector<int> t_fr;
	frno.swap(t_fr);	// 肋位号
	std::vector<double> t_frsp;
	frsp.swap(t_frsp); // 肋距
	std::vector<double> t_yfr;
	yfr.swap(t_yfr);	// 肋位号的纵向坐标位置
	yreffr = 0.0;		// 0号肋号位置

	stationpos = 0.0; // 0号站号起始位置
	nsp = 0;			   // 站数
	std::vector<double> t_sno;
	sno.swap(t_sno); // 站号
	std::vector<double> t_ssp;
	ssp.swap(t_ssp); // 站距
	std::vector<double> t_ys;
	ys.swap(t_ys);  // 站号的纵向坐标位置
	fn = "f4";
}

void ChangeFSPos::gpos_lpos(double gpos, int Ref, std::string &tlpos)
{
	double add = 0.0; // Stno, Lsno;
	double vlpos = 0.0;
	int N;

	tlpos =  " ";
	switch (Ref)
	{
	case 1:
		tlpos = std:: to_string(gpos);
		return;
	case 2:
		vlpos = gpos;
		tlpos =  "A " + std:: to_string(vlpos);
		break;
	case 3:
		vlpos = gpos - Lbp / 2;
		tlpos =  "M " + std:: to_string(vlpos);
		break;
	case 4:
		// gpos = Convert.ToDouble(String.Format((gpos - 0.0001).ToString (), "#0.0000")); //           'on-2006-11-2
		Frout(gpos, vlpos, add);
		tlpos =  "# " + std:: to_string(vlpos);
		break;
	case 5:
		// Stno = (gpos - stationpos) / (Lbp / (stnfp - stnap)) + stnap;
		// Lsno = Lbp / (stnfp - stnap);
		// vlpos = Convert.ToInt16(Stno);
		// add = (Stno - vlpos) * Lbp / (stnfp - stnap);
		Sout(gpos, vlpos, add);
		tlpos =  "$";
		break;
	default:
		break;
	}
	// 单位转换成mm
	add *= 1000;
	// string temp_tpos = tpos.Substring(1,1);
	tlpos = tlpos.substr(0, 1) + std:: to_string(vlpos);
	if (std::abs(add) < 0.000001)
	{
		return;
	}
	N = tlpos.length() + 1;

	// if (N < 5) tlpos = tlpos + "    ";
	N = fnmax(N, 5);

	if (add >= -0.0005)
	{
		tlpos = tlpos.substr(0, N - 1) +  "+";
		N = N + 1;
	}
	// string tempadd = add.ToString();
	// tlpos = tlpos.Substring(0, N - 1) + Convert.ToDouble(String.Format("{0:0.0000}", add));//Format(add, formatStr);
	std::ostringstream oss;
    oss << std::fixed << std::setprecision(4) << add;
    tlpos = tlpos.substr(0, N - 1) + oss.str();
}

void ChangeFSPos::lpos_gpos(const std::string &lpos, double &vgpos)
{
	double add = 0.0, vlpos;
	int Sign, N, Ref;
	std::string tpos;

	if (StringHelper::trim(lpos) ==  "")
	{
		return;
	}
	vgpos = 0;
	Ref = 2;
	tpos = StringHelper::toUpper(StringHelper::trim(lpos)); // UCase(Trim(lpos));

	std::string temp_tpos = tpos.substr(0, 1);

	if (temp_tpos !=  "M")
	{
		Ref = 4;
		if (temp_tpos ==  "F" && temp_tpos ==  "#")
		{
			if (nfrtab <= 0)
			{
				throw std::runtime_error("肋位不存在");
			}
		}
		else
		{
			Ref = 5;
			if (temp_tpos !=  "S" && temp_tpos !=  "$")
			{
				Ref = 1;
			}
		}
	}
	else
	{
		tpos = tpos.substr(2, tpos.length() - 1);
		vgpos = std::stod(tpos);
		switch (Ref)
		{
		case 3:
			vgpos = Lbp / 2 + vgpos;
			return;
		default:
			break;
		}
	}

	tpos = tpos.substr(1, tpos.length() - 1);
	tpos = StringHelper::trim(tpos);
	if (tpos.substr(0, 1) ==  "-")
	{
		Sign = -1;
		tpos = tpos.substr(1, tpos.length() - 1);
	}
	else
	{
		Sign = 1;
		if (tpos.substr(0, 1) ==  "+")
		{
			tpos = tpos.substr(1, tpos.length() - 1);
		}
	}
	// Sign = 1 + 2 * (Mid(tpos, 1, 1) = "-");
	N = (int)tpos.find( "+");
	if (N > 0)
	{
		add = std::stod(tpos.substr(N, tpos.length() - N));
		tpos = tpos.substr(0, N);
	}
	else
	{
		N = (int)tpos.find( "-");
		if (N > 0)
		{
			add = std::stod(tpos.substr(N, tpos.length() - N));
			tpos = tpos.substr(0, N);
		}
	}

	// 单位转换成m
	add /= 1000;
	vlpos = std::stod(tpos) * Sign;
	if (Ref != 5)
	{
		frin(vlpos, add, vgpos, iframe, rfrno, yreffr, nfrtab, frno, yfr, frsp);
	}
	else
	{
		// if (stnap != stnfp)
		//     vgpos = Lbp / (stnfp - stnap) * (vlpos - stnap) + add + stationpos;
		if (!Sin(vlpos, add, vgpos))
		{
			throw std::runtime_error("站不存在");
		}
	}
}

bool ChangeFSPos::Frout(double gpos, double &Vlpos, double &Add)
{
	if (nfrtab == 0)
	{
		return false;
	}

	int I;
	std::vector<double> frList = GetFX();
	int startFr = frno[1];
	int endFr = frno[1 + nfrtab];
	Vlpos = 0;
	Add = 0;
	for (I = startFr; I <= endFr; I++)
	{
		if (std::abs(gpos - frList[I - startFr]) < 1e-7)
		{
			break;
		}
		if (gpos > frList[I - startFr])
		{
			continue;
		}
		else
		{
			if (I == startFr)
			{
				break;
			}
			else
			{
				I--;
				break;
			}
		}
	}

	if (I > endFr)
	{
		I = endFr;
	}

	Vlpos = I;
	Add = gpos - frList[I - startFr];
	return true;
}

double ChangeFSPos::FNFract(double X)
{
	if (std::floor(X + 0.00001) > std::floor(X))
	{
		X = X + 0.00001;
	}
	return X - std::floor(X + 0.00001);
	// if  (Int(X + 0.00001) > Int(X))
	//     X = X + 0.00001;

	// return X - Int(X + 0.00001)
}

double ChangeFSPos::FNFract_(double X)
{
	return X - std::floor(X);
}

void ChangeFSPos::frin(double vlpos, double add, double &gpos, int iframe, double rfrno, double Yreffr, double nfrtab, std::vector<int> &frno, std::vector<double> &yfr, std::vector<double> &frsp)
{

	int I, Sign;
	Sign = 2 * iframe - 1;
	if (nfrtab == 0)
	{
		throw std::runtime_error("未定义肋位，请先定义肋位!");
	}
	if (vlpos < frno[1] || vlpos > frno[static_cast<int>(nfrtab) + 1])
	{
		throw std::runtime_error("肋位超出范围!");
	}
	if (nfrtab <= 1)
	{
		gpos = Sign * (vlpos - rfrno) * frsp[1] + Yreffr;
	}
	else
	{
		if (vlpos <= frno[1])
		{
			gpos = yfr[1] + Sign * frsp[1] * (vlpos - frno[1]);
		}
		else
		{
			for (I = 2; I <= nfrtab; I++)
			{
				if (frno[I] > vlpos)
				{
					break;
				}
			}
			gpos = yfr[I - 1] + Sign * frsp[I - 1] * (vlpos - frno[I - 1]);
		}
	}

	gpos = gpos + add;
}

int ChangeFSPos::fnmax(int X1, int X2)
{
	int FNMMAX1;
	FNMMAX1 = X1;

	if (FNMMAX1 >= X2)
	{
		return FNMMAX1;
	}
	FNMMAX1 = X2;
	return FNMMAX1;
}

bool ChangeFSPos::Sout(double gpos, double &Vlpos, double &Add)
{
	int I;
	std::vector<double> Ds1(nsp + 1);

	Vlpos = 0;
	Add = 0;

	if (nsp == 0)
	{
		return false;
	}

	for (I = 1; I <= nsp; I++)
	{
		if (std::abs(gpos - ys[I]) < 1e-7)
		{
			break;
		}
		if (gpos > ys[I])
		{
			continue;
		}
		else
		{
			if (I == 0)
			{
				break;
			}
			else
			{
				I--;
				break;
				;
			}
		}
	}

	if (I > nsp)
	{
		I = nsp;
	}

	Vlpos = sno[I];
	Add = gpos - ys[I];
	return true;
}

bool ChangeFSPos::Sin(double vlpos, double add, double &gpos)
{
	if (nsp == 0)
	{
		throw std::runtime_error("未定义站位，清先定义站位!");
	}
	// if(!ResetS(ref vlpos, ref add))
	//{
	//     return false;
	// }
	int i;
	for (i = 1; i <= nsp; i++)
	{
		if (std::abs(sno[i] - vlpos) < 0.0001)
		{
			break;
		}
	}
	if (i > nsp) // 站不存在
	{
		return false;
	}

	gpos = ys[i] + add;
	return true;
}

bool ChangeFSPos::ResetS(double &vlpos, double &add)
{
	double vlpos_ = vlpos;
	double add_ = add;

	vlpos = static_cast<int>(vlpos);
	double v = vlpos_ - vlpos;

	if (std::abs(v) < 1e-7)
	{
		return true;
	}

	int i;
	for (i = 1; i <= nsp; i++)
	{
		if (std::abs(sno[i] - vlpos) < 0.0001)
		{
			if (i == nsp)
			{
				return false;
			}
			add = add_ + v * (ys[i + 1] - ys[i]);
			break;
		}
	}

	if (i > nsp) // 站不存在
	{
		return false;
	}

	return true;
}

double ChangeFSPos::ShowX(const std::string &str)
{
	try
	{
		double tem_val = 0.0;
		std::string tem_str;

		if (str ==  "")
		{
			return NAN;
		}
		tem_str = str;
		// C# TO C++ CONVERTER NOTE: The following 'switch' operated on a string and was converted to C++ 'if-else' logic:
		//		switch (str.Substring(0, 1).ToUpper())
		// ORIGINAL LINE: case "F":
		if (StringHelper::toUpper(str.substr(0, 1)) ==  "F" || StringHelper::toUpper(str.substr(0, 1)) ==  "$" || StringHelper::toUpper(str.substr(0, 1)) ==  "S" || StringHelper::toUpper(str.substr(0, 1)) ==  "#" || StringHelper::toUpper(str.substr(0, 1)) ==  "M")
		{

			lpos_gpos(tem_str, tem_val);
		}
		else
		{
			return std::stod(str);
		}
		return tem_val;
	}
	catch (...)
	{
		return 0;
	}
}

std::string ChangeFSPos::ShowF_Sharp(std::string &str)
{
	return StringHelper::replace(ShowF(str),  "F",  "#");
}

std::string ChangeFSPos::ShowF(std::string str)
{
	double tem_val;
	std::string tem_str;

	if (str ==  "")
	{
		return  "";
	}
	tem_str = str;
	std::string temstr1 = str.substr(0, 1);
	// C# TO C++ CONVERTER NOTE: The following 'switch' operated on a string and was converted to C++ 'if-else' logic:
	//		switch (temstr1.ToUpper())
	// ORIGINAL LINE: case "#":
	if (StringHelper::toUpper(temstr1) ==  "#" || StringHelper::toUpper(temstr1) ==  "F")
	{
	}
	else
	{
		tem_val = std::stod(str);
		gpos_lpos(tem_val, 4, tem_str);
		str = tem_str;
	}
	return str;
}

std::string ChangeFSPos::ShowS(std::string str)
{
	double tem_val;
	std::string tem_str;

	if (str ==  "")
	{
		return  "";
	}
	tem_str = str;
	// C# TO C++ CONVERTER NOTE: The following 'switch' operated on a string and was converted to C++ 'if-else' logic:
	//		switch (str.Substring(0, 1).ToUpper())
	// ORIGINAL LINE: case "$":
	if (StringHelper::toUpper(str.substr(0, 1)) ==  "$" || StringHelper::toUpper(str.substr(0, 1)) ==  "S")
	{
	}
	else
	{
		tem_val = std::stod(str);
		gpos_lpos(tem_val, 5, tem_str);
		str = tem_str;
	}

	return str;
}

std::string ChangeFSPos::ShowNonPlusS(std::string &str)
{
	if (str ==  "")
	{
		return  "";
	}
	std::string tem_str = str;
	// C# TO C++ CONVERTER NOTE: The following 'switch' operated on a string and was converted to C++ 'if-else' logic:
	//		switch (str.Substring(0, 1).ToUpper())
	// ORIGINAL LINE: case "$":
	if (StringHelper::toUpper(str.substr(0, 1)) ==  "$" || StringHelper::toUpper(str.substr(0, 1)) ==  "S")
	{
	}
	else
	{
		// double gpos = double.Parse(str);
		// double Stno = (gpos - stationpos) / (Lbp / (stnfp - stnap)) + stnap;
		// str = "S"+Stno.ToString("f3");
		double gpos = std::stod(str);
		double Stno = 0, add = 0;
		Sout(gpos, Stno, add);
		// C# TO C++ CONVERTER TASK: There is no C++ equivalent to 'ToString':
		std::ostringstream oss;
		oss << std::fixed << std::setprecision(3) << Stno;
		
		str = "S" + oss.str();
	}
	return str;
}

void ChangeFSPos::SetSecConvert(ModelData *model)
{
	try
	{
		int count, i, iframe1;
		std::vector<int> frno1;
		std::vector<double> frsp1;
		double tem_sign;

		std::vector<double> sno1;
		std::vector<double> ys1;

		Lbp = model->getLpp();

		i = 0;
		stationpos = model->getSt0X();
		count = model->getStationSize();
		for (auto dKey : model->getStation()) // 取得起始、终止站号
		{
			if (i == 0)
			{
				stnap = dKey.second.m_Num;
			}
			else if (i == (count - 1))
			{
				stnfp = dKey.second.m_Num;
			}
			i++;
		}
		nsp = count; // 站个数
		sno = std::vector<double>(count + 1);
		ssp = std::vector<double>(count + 1);
		ys = std::vector<double>(count + 1);

		// 站表
		if (count > 0)
		{
			sno1 = std::vector<double>(count);
			ys1 = std::vector<double>(count);

			i = 0;
			for (auto pair : model->getStation())
			{
				sno1[i] = pair.second.m_Num;
				ys1[i] = pair.second.m_Pos;
				i++;
			}

			for (i = 1; i <= count; i++)
			{
				sno[i] = sno1[i - 1]; // 站号
				ys[i] = ys1[i - 1];
			}

			ssp[count] = 0;
			for (i = 1; i < count; i++)
			{
				ssp[i] = ys[i + 1] - ys[i];
			}
		}

		//=================================================================
		// 肋位表
		iframe1 = -1; // 默认是递增
		iframe1 = model->getShipFrame();
		iframe = std::abs(iframe1);
		rfrno = 0;					  // 默认是从0号肋位开始
		yreffr = model->getF0X(); // 0号肋位起始位置

		count = model->getFrames().size(); // 肋位个数

		nfrtab = count; // 肋位个数
		frno = std::vector<int>(count + 2);
		frsp = std::vector<double>(count + 1);
		yfr = std::vector<double>(count + 1);

		if (count > 0)
		{
			frno1 = std::vector<int>(count + 1);
			frsp1 = std::vector<double>(count);

			i = 0;
			for (auto pair : model->getFrames())
			{
				frno1[i] = pair.second.m_NumS;
				frno1[i + 1] = pair.second.m_Num;
				frsp1[i] = pair.second.m_Dis;
				i++;
			}

			for (i = 1; i <= count; i++)
			{
				frno[i] = frno1[i - 1]; // 肋位号
				frsp[i] = frsp1[i - 1];
			}
			frno[i] = frno1[i - 1];

			tem_sign = 2 * iframe - 1;
			yfr[1] = 0; // 第一个肋位起始位置
			for (i = 2; i <= count; i++)
			{
				yfr[i] = yfr[i - 1] + tem_sign * frsp[i - 1] * (frno[i] - frno[i - 1]);
			}

			double vgpos = 0;
			frin(0, 0, vgpos, 1, rfrno, yreffr, nfrtab, frno, yfr, frsp);

			for (i = 0; i < count; i++)
			{
				yfr[i + 1] -= vgpos - yreffr;
			}
		}
	}
	catch (...)
	{
	}
}

std::vector<double> ChangeFSPos::GetFX()
{
	std::vector<double> fx;
	if (nfrtab < 1)
	{
		return fx;
	}
	int startNo = frno[1];
	int endNo = frno[1 + nfrtab];
	for (int i = startNo; i < endNo + 1; i++)
	{
		fx.push_back(ShowX( "#" + std:: to_string(i)));
	}
	return fx;
}

std::vector<double> ChangeFSPos::GetSX()
{
	std::vector<double> sx;
	for (int i = 0; i < nsp; i++)
	{
		sx.push_back(ys[i + 1]);
	}
	return sx;
}