#include "StateIngame.hpp"
#include "StateSplash.hpp"
#include "Asset.hpp"

StateIngame::StateIngame():
m_player() {
	m_map.load("data/map2.tmx");
	m_map2.load("data/map3.tmx");
	m_background.setTexture(Asset::texture("data/basic_background.png"));

	Renderer::registerDrawable(&m_background, 0, Renderer::Mode::BG, "Basic background");
	Renderer::registerDrawable(&m_background, 0, Renderer::Mode::BG, "Basic background");
	for (unsigned i = 0; i < LAYER_COUNT; ++i) {
		m_layer[i].create(m_map, i);
		m_layer[i + LAYER_COUNT].create(m_map2, i);
		Renderer::registerDrawable(&m_layer[i], i == 2 || i == 3 ? i + 100 : i, Renderer::Mode::FG, "Layer" + std::to_string(i));
		Renderer::registerDrawable(&m_layer[LAYER_COUNT + i], i == 2 || i == 3 ? i + 100 : i, Renderer::Mode::FG, "Layer" + std::to_string(i));
		Renderer::registerLayer(&m_layer[i]);
		Renderer::registerLayer(&m_layer[i + LAYER_COUNT]);
		m_layer[i].m_enabled = true;
		m_layer[LAYER_COUNT + i].m_enabled = false;
	}

	Renderer::list();
	m_spectre_list.emplace_back(Spectre::Settings({
		.sheet = "data/why/hand.png",
		.frames = 3,
		.frameDuration = 1.f,
		.size = 0.25f,
		.duration = 15.f,
		.scale = true, 
		.skew = true, 
		.rotate = true, 
		.follow = true, 
		.overlay = true,
		.rainbow = true
	}));
	m_spectre_list.emplace_back(Spectre::Settings({
		.sheet = "data/why/crescent.png",
		.frames = 3,
		.alt = 2,
		.frameDuration = 0.6f,
		.size = 0.3f,
		.duration = 15.f,
		.scale = true,
		.skew = true,
		.rotate = true,
		.follow = true,
		.overlay = true,
		.rainbow = true
	}));
	m_spectre_list.emplace_back(Spectre::Settings({
		.sheet = "data/why/donut.png",
		.frames = 3,
		.alt = 1,
		.frameDuration = 0.2f,
		.size = 0.2f,
		.duration = 6.f,
		.scale = true,
		.skew = true,
		.rotateRandom = true,
		.follow = false,
		.overlay = true,
		.rainbow = false
	}));
	m_spectre_list.emplace_back(Spectre::Settings({
		.sheet = "data/why/glowie.png",
		.frames = 2,
		.alt = 1,
		.frameDuration = 0.1f,
		.size = 0.7f,
		.duration = 10.f,
		.scale = false,
		.skew = true,
		.rotateRandom = true,
		.follow = true,
		.overlay = false,
		.rainbow = false
	}));
	m_spectre_list.emplace_back(Spectre::Settings({
		.sheet = "data/why/idk.png",
		.frames = 1,
		.alt = 1,
		.frameDuration = 4.f,
		.size = 1.f,
		.duration = 4.f,
		.scale = false,
		.skew = true,
		.rotate = true,
		.follow = true,
		.overlay = false,
		.rainbow = false
		}));
	m_spectre_list.emplace_back(Spectre::Settings({
		.sheet = "data/why/scarab.png",
		.frames = 1,
		.alt = 1,
		.frameDuration = 8.f,
		.size = 0.4f,
		.duration = 8.f,
		.scale = true,
		.skew = true,
		.rotate = true,
		.rotateRandom = true,
		.follow = true,
		.overlay = false,
		.rainbow = true
		}));


	m_vignette.setTexture(Asset::texture("data/vignette.png"));
	m_vignette.setColor(sf::Color(255, 255, 255, 0));
	Renderer::registerDrawable(&m_vignette, 0, Renderer::Mode::UI);

	m_wind.openFromFile("data/whitewind.ogg");
	m_brown.openFromFile("data/brownnoise.ogg");
	m_wind.setVolume(0.f);
	m_brown.setVolume(0.f);
	m_wind.setLoop(true);
	m_brown.setLoop(true);
	m_wind.play();
	m_brown.play();

	m_snd.setBuffer(Asset::sound("data/brownshort.wav"));
	m_snd.setLoop(false);
	m_snd.setVolume(40.f);

	reset();

	Log(INFO, "Ingame state up");
	stateReady();
}

StateIngame::~StateIngame() {
	Renderer::deregisterDrawable(&m_background);

	for (unsigned i = 0; i < LAYER_COUNT; ++i) {
		Renderer::deregisterDrawable(&m_layer[i]);
		Renderer::deregisterLayer(&m_layer[i]);
		Renderer::deregisterDrawable(&m_layer[i + LAYER_COUNT]);
		Renderer::deregisterLayer(&m_layer[i + LAYER_COUNT]);
	}

	Renderer::deregisterDrawable(&m_vignette);

	Log(INFO, "Ingame state down");
}

void StateIngame::reset() {
	//Collider::populate(m_blockLayer.rebuildCollider(m_renderer.getFocus()));
	//Collider::setLocalX(m_renderer.getPosition() - 320.f);
	//Collider::sort();
	Renderer::sort();
	Renderer::list();
}

void StateIngame::onEvent(sf::Event event) {
	if (event.type == sf::Event::GainedFocus) {
		m_paused = false;
	} else if (event.type == sf::Event::LostFocus) {
		m_paused = true;
	} else if (event.type == sf::Event::KeyReleased && event.key.code == sf::Keyboard::P) {
		m_paused = !m_paused;
	}
	else if (event.type == sf::Event::KeyReleased && event.key.code == sf::Keyboard::F1) {
		m_player.cheat();
	}
}

void StateIngame::onUpdate(float dt) {
	static float previous_chaos = Spectre::getChaos();
	m_player.update(dt);

	Spectre::addChaos(-dt / 120.f);

	for (Spectre* s : m_spectres) {
		if (!s->isDead()) {
			s->update(dt);
		}
	}

	for (size_t i = 0; i < m_spectres.size(); ++i) {
		if (m_spectres[i]->isDead()) {
			delete m_spectres[i];
			m_spectres.erase(m_spectres.begin() + i);
		}
	}

	if (m_wind.getVolume() > 30.f) {
		m_wind.setVolume(30.f);
	}
	else if (m_wind.getVolume() < 30.f) {
		m_wind.setVolume(m_wind.getVolume() + dt * 0.7f);
	}

	// Chaos changed
	if (previous_chaos != Spectre::getChaos()) {
		float chaos = Spectre::getChaos();
		previous_chaos = chaos;
		
		m_brown.setVolume(std::pow(10, 1.85f * chaos) - 0.1f);
		m_vignette.setColor(sf::Color(255, 255, 255, 255 * chaos));
	}

	static float spawn_clock = -10.f;
	if (Spectre::getMaxChaos() > 0.f) {
		spawn_clock += dt;
	}
	if (Spectre::getMaxChaos() > 0.f && spawn_clock > 3.f - 2.f * Spectre::getChaos()) {
		m_spectres.push_back(new Spectre(m_spectre_list[rand() % m_spectre_list.size()]));
		int dx = rand() % 600 + 600;
		int dy = rand() % 600 + 600;
		if (rand() % 2) {
			dx *= -1;
		}
		if (rand() % 2) {
			dy *= -1;
		}
		if (Renderer::readyToDie() || rand() % 10 <= 1) {
			m_spectres.back()->setPosition(m_player.getPosition() + sf::Vector2f(dx, dy));
		}
		else {
			m_spectres.back()->setPosition(m_player.getSpawnerPosition() + sf::Vector2f(dx, dy));
		}
		if (m_spectres.size() > 15) {
			m_spectres[0]->pleaseDie();
			m_spectres[1]->pleaseDie();
			m_spectres[2]->pleaseDie();
			//m_spectres.erase(m_spectres.begin());
		}
		spawn_clock = 0.f;
	}
	//Log(DEBUG, Spectre::getChaos(), " ", m_spectres.size());

	if (Spectre::getChaos() > 0.5f) {
		static float fucklock = 0.f;
		static int fuckid = -1;

		fucklock += dt;
		if (fuckid == -1 && fucklock > 21 - 17.f * Spectre::getChaos() && rand() % 500 == 0) {
			fuckid = rand() % LAYER_COUNT;
			fucklock = 0.f;
			m_layer[fuckid].m_enabled = false;
			m_layer[LAYER_COUNT + fuckid].m_enabled = true;
			m_layer[LAYER_COUNT + fuckid].whack();
			m_snd.play();
		}
		if (fucklock > 0.5f && fuckid != -1) {
			m_layer[fuckid].m_enabled = true;
			m_layer[LAYER_COUNT + fuckid].m_enabled = false;
			fuckid = -1;
			fucklock = 0.f;
		}

		if (Renderer::isDead()) {
			stateFin();
			stateDie();
		}
	}
	
	/*m_collider.update(dt);
	for (IEntity* ie : m_entities) {
		ie->update(dt);
	}
	m_renderer.update(dt);*/
}

void StateIngame::onRender() {
	/*m_collider.update(dt);
	for (IEntity* ie : m_entities) {
		ie->update(dt);
	}
	m_renderer.update(dt);*/
}


State* StateIngame::next() const {
	return nullptr;//new StateSplash(StateSplash::SplashType::VICTORY);
}