#include "TeamOptionen.h"
#include "../../../../Initialisierung/Initialisierung.h"
#include "../../../Karte/EditorKarte.h"

using namespace Editor;

TeamTool::TeamTool(UIInit& uiFactory, KarteDaten* daten)
	: RightTool()
{
	int teamAnzahl = daten->getTeamAnzahl();
	teamAuswahl = initAuswahlBox(0, 0, 150, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {});
	for (int i = 0; i < teamAnzahl; i++)
	{
		teamAuswahl->addEintrag(daten->getTeamName(i));
	}
	teamAuswahl->setEventAktion([this](void* p, AuswahlBox* a, int old, int auswahl)
		{
			this->selectTeam(auswahl + 1);
		});
	skillStartT = initTextFeld(0, 30, 290, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "---Startwerte---");
	skillStartStabilitätT = initTextFeld(0, 55, 200, 20, uiFactory, TextFeld::Style::Text, "Stabilität");
	skillStartEnergieT = initTextFeld(0, 80, 200, 20, uiFactory, TextFeld::Style::Text, "Energie");
	skillStartReparaturT = initTextFeld(0, 105, 200, 20, uiFactory, TextFeld::Style::Text, "Reparatur");
	skillStartAkkuT = initTextFeld(0, 130, 200, 20, uiFactory, TextFeld::Style::Text, "Akku");
	skillStartWendigkeitT = initTextFeld(0, 155, 200, 20, uiFactory, TextFeld::Style::Text, "Wendigkeit");
	skillStartBeschleunigungT = initTextFeld(0, 180, 200, 20, uiFactory, TextFeld::Style::Text, "Beschleunigung");
	skillStartAntriebEffizienzT = initTextFeld(0, 205, 200, 20, uiFactory, TextFeld::Style::Text, "Antrieb Effizienz");
	skillStartLaserIntensitätT = initTextFeld(0, 230, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Intensität");
	skillStartLaserEffizienzT = initTextFeld(0, 255, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Effizienz");
	skillStartLaserTempoT = initTextFeld(0, 280, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Tempo");
	skillStartEnergieSchildT = initTextFeld(0, 305, 200, 20, uiFactory, TextFeld::Style::Text, "Energie Schild");
	skillStartEnergieSchildEffizienzT = initTextFeld(0, 330, 200, 20, uiFactory, TextFeld::Style::Text, "Schild Effizienz");
	TeamDaten* Team = daten->getTeam(daten->getTeamIndexById(1));
	skillStartStabilität = initTextFeld(200, 55, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->maxStabilität));
	skillStartEnergie = initTextFeld(200, 80, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->maxEnergie));
	skillStartReparatur = initTextFeld(200, 105, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->reparatur));
	skillStartAkku = initTextFeld(200, 130, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->akkuLeistung));
	skillStartWendigkeit = initTextFeld(200, 155, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->wendigkeit));
	skillStartBeschleunigung = initTextFeld(200, 180, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->beschleunigung));
	skillStartAntriebEffizienz = initTextFeld(200, 205, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->antriebEffizienz));
	skillStartLaserIntensität = initTextFeld(200, 230, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->laserIntensität));
	skillStartLaserEffizienz = initTextFeld(200, 255, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->laserEffizienz));
	skillStartLaserTempo = initTextFeld(200, 280, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->laserTempo));
	skillStartEnergieSchild = initTextFeld(200, 305, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->energieSchild));
	skillStartEnergieSchildEffizienz = initTextFeld(200, 330, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text(Team->energieSchildEffizienz));
	speichern = initKnopf(0, 380, 100, 20, uiFactory, Knopf::Style::Normal, "Speichern");
	this->daten = daten;
}

TeamTool::~TeamTool()
{
	teamAuswahl->release();
	skillStartT->release();
	skillStartStabilitätT->release();
	skillStartEnergieT->release();
	skillStartReparaturT->release();
	skillStartAkkuT->release();
	skillStartWendigkeitT->release();
	skillStartBeschleunigungT->release();
	skillStartAntriebEffizienzT->release();
	skillStartLaserIntensitätT->release();
	skillStartLaserEffizienzT->release();
	skillStartLaserTempoT->release();
	skillStartEnergieSchildT->release();
	skillStartEnergieSchildEffizienzT->release();
	skillStartStabilität->release();
	skillStartEnergie->release();
	skillStartReparatur->release();
	skillStartAkku->release();
	skillStartWendigkeit->release();
	skillStartBeschleunigung->release();
	skillStartAntriebEffizienz->release();
	skillStartLaserIntensität->release();
	skillStartLaserEffizienz->release();
	skillStartLaserTempo->release();
	skillStartEnergieSchild->release();
	skillStartEnergieSchildEffizienz->release();
	speichern->release();
	daten->release();
}

void TeamTool::doPublicMausEreignis(MausEreignis& me)
{
	bool vera = me.verarbeitet;
	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
		me.verarbeitet = 1;
	me.mx -= pos.x;
	me.my -= pos.y;
	teamAuswahl->doPublicMausEreignis(me);
	skillStartT->doPublicMausEreignis(me);
	skillStartStabilitätT->doPublicMausEreignis(me);
	skillStartEnergieT->doPublicMausEreignis(me);
	skillStartReparaturT->doPublicMausEreignis(me);
	skillStartAkkuT->doPublicMausEreignis(me);
	skillStartWendigkeitT->doPublicMausEreignis(me);
	skillStartBeschleunigungT->doPublicMausEreignis(me);
	skillStartAntriebEffizienzT->doPublicMausEreignis(me);
	skillStartLaserIntensitätT->doPublicMausEreignis(me);
	skillStartLaserEffizienzT->doPublicMausEreignis(me);
	skillStartLaserTempoT->doPublicMausEreignis(me);
	skillStartEnergieSchildT->doPublicMausEreignis(me);
	skillStartEnergieSchildEffizienzT->doPublicMausEreignis(me);
	skillStartStabilität->doPublicMausEreignis(me);
	skillStartEnergie->doPublicMausEreignis(me);
	skillStartReparatur->doPublicMausEreignis(me);
	skillStartAkku->doPublicMausEreignis(me);
	skillStartWendigkeit->doPublicMausEreignis(me);
	skillStartBeschleunigung->doPublicMausEreignis(me);
	skillStartAntriebEffizienz->doPublicMausEreignis(me);
	skillStartLaserIntensität->doPublicMausEreignis(me);
	skillStartLaserEffizienz->doPublicMausEreignis(me);
	skillStartLaserTempo->doPublicMausEreignis(me);
	skillStartEnergieSchild->doPublicMausEreignis(me);
	skillStartEnergieSchildEffizienz->doPublicMausEreignis(me);
	bool verarbeitet = me.verarbeitet;
	speichern->doPublicMausEreignis(me);
	if (!verarbeitet && me.verarbeitet && me.id == ME_RLinks)
	{
		TeamDaten* data = daten->getTeam(daten->getTeamIndexById(teamAuswahl->getAuswahl() + 1));
		data->maxStabilität = (int)*skillStartStabilität->zText();
		data->maxEnergie = (int)*skillStartEnergie->zText();
		data->reparatur = (double)*skillStartReparatur->zText();
		data->akkuLeistung = (double)*skillStartAkku->zText();
		data->wendigkeit = (double)*skillStartWendigkeit->zText();
		data->beschleunigung = (double)*skillStartBeschleunigung->zText();
		data->antriebEffizienz = (double)*skillStartAntriebEffizienz->zText();
		data->laserIntensität = (int)*skillStartLaserIntensität->zText();
		data->laserEffizienz = (int)*skillStartLaserEffizienz->zText();
		data->laserTempo = (int)*skillStartLaserTempo->zText();
		data->energieSchild = (double)*skillStartEnergieSchild->zText();
		data->energieSchildEffizienz = (double)*skillStartEnergieSchildEffizienz->zText();
		data->update();
	}
	me.mx += pos.x;
	me.my += pos.y;
	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
		me.verarbeitet = vera;
}

void TeamTool::doTastaturEreignis(TastaturEreignis& te)
{
	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
		return;
	teamAuswahl->doTastaturEreignis(te);
	skillStartT->doTastaturEreignis(te);
	skillStartStabilitätT->doTastaturEreignis(te);
	skillStartEnergieT->doTastaturEreignis(te);
	skillStartReparaturT->doTastaturEreignis(te);
	skillStartAkkuT->doTastaturEreignis(te);
	skillStartWendigkeitT->doTastaturEreignis(te);
	skillStartBeschleunigungT->doTastaturEreignis(te);
	skillStartAntriebEffizienzT->doTastaturEreignis(te);
	skillStartLaserIntensitätT->doTastaturEreignis(te);
	skillStartLaserEffizienzT->doTastaturEreignis(te);
	skillStartLaserTempoT->doTastaturEreignis(te);
	skillStartEnergieSchildT->doTastaturEreignis(te);
	skillStartEnergieSchildEffizienzT->doTastaturEreignis(te);
	skillStartStabilität->doTastaturEreignis(te);
	skillStartEnergie->doTastaturEreignis(te);
	skillStartReparatur->doTastaturEreignis(te);
	skillStartAkku->doTastaturEreignis(te);
	skillStartWendigkeit->doTastaturEreignis(te);
	skillStartBeschleunigung->doTastaturEreignis(te);
	skillStartAntriebEffizienz->doTastaturEreignis(te);
	skillStartLaserIntensität->doTastaturEreignis(te);
	skillStartLaserEffizienz->doTastaturEreignis(te);
	skillStartLaserTempo->doTastaturEreignis(te);
	skillStartEnergieSchild->doTastaturEreignis(te);
	skillStartEnergieSchildEffizienz->doTastaturEreignis(te);
	speichern->doTastaturEreignis(te);
}

bool TeamTool::tick(double tickVal)
{
	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
		return __super::tick(tickVal);
	bool ret = __super::tick(tickVal);
	ret |= teamAuswahl->tick(tickVal);
	ret |= skillStartT->tick(tickVal);
	ret |= skillStartStabilitätT->tick(tickVal);
	ret |= skillStartEnergieT->tick(tickVal);
	ret |= skillStartReparaturT->tick(tickVal);
	ret |= skillStartAkkuT->tick(tickVal);
	ret |= skillStartWendigkeitT->tick(tickVal);
	ret |= skillStartBeschleunigungT->tick(tickVal);
	ret |= skillStartAntriebEffizienzT->tick(tickVal);
	ret |= skillStartLaserIntensitätT->tick(tickVal);
	ret |= skillStartLaserEffizienzT->tick(tickVal);
	ret |= skillStartLaserTempoT->tick(tickVal);
	ret |= skillStartEnergieSchildT->tick(tickVal);
	ret |= skillStartEnergieSchildEffizienzT->tick(tickVal);
	ret |= skillStartStabilität->tick(tickVal);
	ret |= skillStartEnergie->tick(tickVal);
	ret |= skillStartReparatur->tick(tickVal);
	ret |= skillStartAkku->tick(tickVal);
	ret |= skillStartWendigkeit->tick(tickVal);
	ret |= skillStartBeschleunigung->tick(tickVal);
	ret |= skillStartAntriebEffizienz->tick(tickVal);
	ret |= skillStartLaserIntensität->tick(tickVal);
	ret |= skillStartLaserEffizienz->tick(tickVal);
	ret |= skillStartLaserTempo->tick(tickVal);
	ret |= skillStartEnergieSchild->tick(tickVal);
	ret |= skillStartEnergieSchildEffizienz->tick(tickVal);
	ret |= speichern->tick(tickVal);
	return ret;
}

void TeamTool::render(Bild& rObj)
{
	if (hatStyleNicht(Zeichnung::Style::Sichtbar))
		return;
	if (rObj.setDrawOptions(pos, gr))
	{
		skillStartT->render(rObj);
		skillStartStabilitätT->render(rObj);
		skillStartEnergieT->render(rObj);
		skillStartReparaturT->render(rObj);
		skillStartAkkuT->render(rObj);
		skillStartWendigkeitT->render(rObj);
		skillStartBeschleunigungT->render(rObj);
		skillStartAntriebEffizienzT->render(rObj);
		skillStartLaserIntensitätT->render(rObj);
		skillStartLaserEffizienzT->render(rObj);
		skillStartLaserTempoT->render(rObj);
		skillStartEnergieSchildT->render(rObj);
		skillStartEnergieSchildEffizienzT->render(rObj);
		skillStartStabilität->render(rObj);
		skillStartEnergie->render(rObj);
		skillStartReparatur->render(rObj);
		skillStartAkku->render(rObj);
		skillStartWendigkeit->render(rObj);
		skillStartBeschleunigung->render(rObj);
		skillStartAntriebEffizienz->render(rObj);
		skillStartLaserIntensität->render(rObj);
		skillStartLaserEffizienz->render(rObj);
		skillStartLaserTempo->render(rObj);
		skillStartEnergieSchild->render(rObj);
		skillStartEnergieSchildEffizienz->render(rObj);
		speichern->render(rObj);
		teamAuswahl->render(rObj);
		rObj.releaseDrawOptions();
	}
}

void TeamTool::selectTeam(int id)
{
	int index = daten->getTeamIndexById(id);
	teamAuswahl->setAuswahl(id - 1);
	TeamDaten* Team = daten->getTeam(index);
	skillStartStabilität->setText(Text(Team->maxStabilität));
	skillStartEnergie->setText(Text(Team->maxEnergie));
	skillStartReparatur->setText(Text(Team->reparatur));
	skillStartAkku->setText(Text(Team->akkuLeistung));
	skillStartWendigkeit->setText(Text(Team->wendigkeit));
	skillStartBeschleunigung->setText(Text(Team->beschleunigung));
	skillStartAntriebEffizienz->setText(Text(Team->antriebEffizienz));
	skillStartLaserIntensität->setText(Text(Team->laserIntensität));
	skillStartLaserEffizienz->setText(Text(Team->laserEffizienz));
	skillStartLaserTempo->setText(Text(Team->laserTempo));
	skillStartEnergieSchild->setText(Text(Team->energieSchild));
	skillStartEnergieSchildEffizienz->setText(Text(Team->energieSchildEffizienz));
}