#include "PowerCompensate.h"
#include "../DataManage/RWData.h"
#include "../utils/ConverType.hpp"

PowerCompensate::PowerCompensate()
{
}


PowerCompensate::~PowerCompensate()
{
}


void PowerCompensate::Generate(int cno,vector<string>& ins)
{
	char buffer[256];
	string strtemp = "INSERT INTO %s(%s,%s,%s,%s,%s) VALUES(%d,";
	sprintf_s(buffer, sizeof(buffer), strtemp.c_str(),
		TABLE_NAME.c_str(),
		FIELD_CNO.c_str(),
		FIELD_PERCENT.c_str(),
		FIELD_VALUE.c_str(),
		FIELD_VALUE_MIN.c_str(),
		FIELD_VALUE_MAX.c_str(),
		cno
	);
	string strsql = string(buffer) + "%d,%f,%f,%f)";
	
	for (int i = 5; i <= 100;i+=5) {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(),i,1.0f,0.0f,3.0f);
		ins.push_back(buffer);
	}
}

void PowerCompensate::SetPowerComp(stream::PowerCompensate* cp) {
	cp->set_cno(m_cno);
	cp->set_percent(m_percent);
	cp->set_value(m_value);
	cp->set_value_min(m_value_min);
	cp->set_value_max(m_value_max);

}


const string PowerCompensate::TABLE_NAME="PowerCompensate";
const string PowerCompensate::FIELD_CNO = "cno";
const string PowerCompensate::FIELD_PERCENT="percent";
const string PowerCompensate::FIELD_VALUE="value";
const string PowerCompensate::FIELD_VALUE_MIN="value_min";
const string PowerCompensate::FIELD_VALUE_MAX="value_max";


PowerCompensateCfg::PowerCompensateCfg() {

}

PowerCompensateCfg::~PowerCompensateCfg() {
	for (size_t i = 0; i < m_pcs.size();++i) {
		delete m_pcs[i];
	}
	m_pcs.clear();
}

float PowerCompensateCfg::CalcPowerCompensate(float power)
{
	float rel = power;
	for (size_t i = 0; i < m_pcs.size();++i) {
		if (power <= m_pcs[i]->m_percent) {
			if (i !=0) {
				if ((m_pcs[i]->m_value != m_pcs[i-1]->m_value) && (m_pcs[i]->m_percent != m_pcs[i - 1]->m_percent)) {
					float k = (m_pcs[i]->m_percent - m_pcs[i-1]->m_percent) / (m_pcs[i]->m_value - m_pcs[i-1]->m_value);
					float b = m_pcs[i]->m_percent - m_pcs[i]->m_value*k;
					rel = (power-b)/k*power;
				}
				else {
					rel = power*m_pcs[i]->m_value;
				}
			}
			break;
		}
	}
	return rel;
}

void PowerCompensateCfg::Update(const ReadData& rd, const list<Item>& lst) {
	auto start = lst.begin();
	while (start != lst.end()) {
		int percent = ConverType::TryToI(start->nameKey);
		for (auto it = m_pcs.begin(); it != m_pcs.end(); ++it) {
			if ((*it)->m_percent == percent) {
				(*it)->m_value = ConverType::TryToF(start->strValue);
				break;
			}
		}
		++start;
	}
	
}

bool PowerCompensateLess(const PowerCompensate * m1, const PowerCompensate * m2) {
	return m1->m_percent < m2->m_percent;
}