// Networking_Test_1.cpp : Defines the entry point for the console application.
//

#include "stdafx.h" //what is this garbage

#include <SFML/Graphics.hpp>
#include <SFML/Audio.hpp>
#include <SFML/Network.hpp>
#include <iostream>
#include <string>

#include <vector>
#include <limits>
#include <fstream>
#include <sstream>
#include <math.h>
#include <list>
#include <algorithm>
#include <iterator>
#include <deque>
#include <unordered_map>

class Packet_Component {
protected:

public:
	virtual void packet_write(sf::Packet &packet) = 0;
	virtual bool packet_read(sf::Packet &packet) = 0;

	template <typename T>
	void vec_write_component(sf::Packet &packet, std::vector <T> &read_from) {
		packet << static_cast<sf::Uint16>(read_from.size());
		for (auto i = read_from.begin(); i != read_from.end(); i++) {
			(*i).packet_write(packet);
		}
	}

	template <typename T>
	bool vec_read_component(sf::Packet &packet, std::vector <T> &write_to) {
		sf::Uint16 vec_size;
		if (! (packet >> vec_size)) {
			return false;
		}

		write_to.resize(vec_size);

		for (auto i = write_to.begin(); i != write_to.end(); i++) {
			if (! (*i).packet_read(packet)) {
				return false;
			}
		}

		return true;
	}

	/*void vec_write_component(sf::Packet &packet, std::vector <Packet_Component> &read_from) {
		packet << static_cast<sf::Uint16>(read_from.size());
		for (auto i = read_from.begin(); i != read_from.end(); i++) {
			(*i).packet_write(packet);
		}
	}
	bool vec_read_component(sf::Packet &packet, std::vector <Packet_Component> &write_to) {
		sf::Uint16 vec_size;
		if (! (packet >> vec_size)) {
			return false;
		}

		write_to.resize(vec_size);

		for (auto i = write_to.begin(); i != write_to.end(); i++) {
			if ( ! (*i).packet_read(packet)) {
				return false;
			}
		}
	}*/

	Packet_Component() {}
	virtual ~Packet_Component() {}
};

class Test : public Packet_Component {
	//friend sf::Packet& operator >>(sf::Packet& packet, Test& data);
	//friend sf::Packet& operator <<(sf::Packet& packet, Test& data);
protected:
	sf::Uint64 _value;
public:
	sf::Uint64 value() { return _value; }
	void clear() { _value = 0; }
	virtual void packet_write(sf::Packet &packet);
	virtual bool packet_read(sf::Packet &packet);
	Test() : _value(0) {}
	Test(sf::Uint64 value) : _value(value) {}
};
void Test::packet_write(sf::Packet &packet) {
	packet << _value;
}
bool Test::packet_read(sf::Packet &packet) {
	if (! (packet >> _value) ) {
		return false;
	}
	return true;
}

class Bun : public Packet_Component {
protected:
	sf::String _value;
public:
	sf::String value() { return _value; }
	void report() { std::cout << _value.toAnsiString() << "\n"; }

	virtual void packet_write(sf::Packet &packet);
	virtual bool packet_read(sf::Packet &packet);
	Bun() : _value("Plain") {}
	Bun(sf::String value) : _value(value) {}
};
void Bun::packet_write(sf::Packet &packet) {
	packet << _value;
}
bool Bun::packet_read(sf::Packet &packet) {
	if (! (packet >> _value)) {
		return false;
	}
	return true;
}

class Patty : public Packet_Component {
protected:
	sf::String _value;
public:
	sf::String value() { return _value; }
	void report() { std::cout << _value.toAnsiString() << "\n"; }

	virtual void packet_write(sf::Packet &packet);
	virtual bool packet_read(sf::Packet &packet);
	Patty() : _value("Beef") {}
	Patty(sf::String value) : _value(value) {}
};
void Patty::packet_write(sf::Packet &packet) {
	packet << _value;
}
bool Patty::packet_read(sf::Packet &packet) {
	if (! (packet >> _value)) {
		return false;
	}
	return true;
}

class Meat : public Packet_Component {
protected:
	std::vector <Patty> _patties;
public:
	void patties(std::vector<Patty> &addTo) { addTo = _patties; }
	void report() {
		for (auto i = _patties.begin(); i != _patties.end(); i++) {
			(*i).report();
		}
	}

	virtual void packet_write(sf::Packet &packet);
	virtual bool packet_read(sf::Packet &packet);
	Meat() : _patties({ Patty() }) {}
	Meat(std::vector <Patty> &patties) : _patties(patties) {}
};
void Meat::packet_write(sf::Packet &packet) {
	vec_write_component(packet, _patties);
}
bool Meat::packet_read(sf::Packet &packet) {
	return vec_read_component(packet, _patties);
}

class Veggie : public Packet_Component {
protected:
	sf::Uint64 _number;
	sf::String _type;
public:
	sf::Uint64 number() { return _number; }
	sf::String type() { return _type; }
	void report() { std::cout << _type.toAnsiString() << " x " << _number << "\n"; }

	virtual void packet_write(sf::Packet &packet);
	virtual bool packet_read(sf::Packet &packet);
	Veggie() : _number(0), _type("") {}
	Veggie(sf::Uint64 number, sf::String type) : _number(number), _type(type) {}
};
void Veggie::packet_write(sf::Packet &packet) {
	packet << _number << _type;
}
bool Veggie::packet_read(sf::Packet &packet) {
	if (! (packet >> _number >> _type)) {
		return false;
	}
	return true;
}

class Vegetables : public Packet_Component {
protected:
	std::vector <Veggie> _veggies;
public:
	void veggies(std::vector<Veggie> &addTo) { addTo = _veggies; }
	void report() {
		for (auto i = _veggies.begin(); i != _veggies.end(); i++) {
			(*i).report();
		}
	}

	virtual void packet_write(sf::Packet &packet);
	virtual bool packet_read(sf::Packet &packet);
	Vegetables() {}
	Vegetables(std::vector <Veggie> &veggies) : _veggies(veggies) {}
};
void Vegetables::packet_write(sf::Packet &packet) {
	vec_write_component(packet, _veggies);
}
bool Vegetables::packet_read(sf::Packet &packet) {
	return vec_read_component(packet, _veggies);
}

class Condiment : public Packet_Component {
protected:
	sf::Int64 _position;
	float _coverage;
	sf::String _type;
public:
	sf::Int64 position() { return _position; }
	float coverage() { return _coverage; }
	sf::String type() { return _type; }
	void report() { std::cout << _type.toAnsiString() << " on Layer# " << _position << " over " << _coverage << "% \n"; }

	virtual void packet_write(sf::Packet &packet);
	virtual bool packet_read(sf::Packet &packet);
	Condiment() : _position(0), _coverage(0.0), _type("") {}
	Condiment(sf::Int64 position, float coverage, sf::String type) : _position(position), _coverage(coverage), _type(type) {}
};
void Condiment::packet_write(sf::Packet &packet) {
	packet << _position << _coverage << _type;
}
bool Condiment::packet_read(sf::Packet &packet) {
	if (! (packet >> _position >> _coverage >> _type)) {
		return false;
	}
	return true;
}

class Condiments : public Packet_Component {
protected:
	std::vector <Condiment> _condiments;
public:
	void condiments(std::vector<Condiment> &addTo) { addTo = _condiments; }
	void report() {
		for (auto i = _condiments.begin(); i != _condiments.end(); i++) {
			(*i).report();
		}
	}

	virtual void packet_write(sf::Packet &packet);
	virtual bool packet_read(sf::Packet &packet);
	Condiments() {}
	Condiments(std::vector <Condiment> &condiments) : _condiments(condiments) {}
};
void Condiments::packet_write(sf::Packet &packet) {
	vec_write_component(packet, _condiments);
}
bool Condiments::packet_read(sf::Packet &packet) {
	return vec_read_component(packet, _condiments);
}

class Toppings : public Packet_Component {
public:
	Bun _bun;
	Meat _meat;
	Vegetables _vegetables;
	Condiments _condiments;

	void report() {
		_bun.report();
		_meat.report();
		_vegetables.report();
		_condiments.report();
	}

	virtual void packet_write(sf::Packet &packet);
	virtual bool packet_read(sf::Packet &packet);
	Toppings() {}
	Toppings(Bun &bun, Meat &meat, Vegetables &vegetables, Condiments &condiments) : _bun(bun), _meat(meat), _vegetables(vegetables), _condiments(condiments) {}
	virtual ~Toppings() {}
};
void Toppings::packet_write(sf::Packet &packet) {
	_bun.packet_write(packet);
	_meat.packet_write(packet);
	_vegetables.packet_write(packet);
	_condiments.packet_write(packet);
}
bool Toppings::packet_read(sf::Packet &packet) {
	if (! _bun.packet_read(packet)) {
		return false;
	}
	if (! _meat.packet_read(packet)) {
		return false;
	}
	if (! _vegetables.packet_read(packet)) {
		return false;
	}
	if (! _condiments.packet_read(packet)) {
		return false;
	}
	return true;
}

class Burger : public Packet_Component {
protected:

public:
	Toppings _toppings;

	void report() {
		_toppings.report();
	}

	virtual void packet_write(sf::Packet &packet);
	virtual bool packet_read(sf::Packet &packet);
	Burger() {}
	Burger(Toppings &toppings) : _toppings(toppings) {}
	virtual ~Burger() {}
};
void Burger::packet_write(sf::Packet &packet) {
	_toppings.packet_write(packet);
}
bool Burger::packet_read(sf::Packet &packet) {
	return _toppings.packet_read(packet);
}

/*class Garbage : public Packet_Component {
public:
	std::vector <int> _values;
	virtual void packet_write(sf::Packet &packet) {}
	virtual bool packet_read(sf::Packet &packet) {}
	void test() {
		sf::Packet packet;
		vec_write_component(packet, _values);
	}
	Garbage() : _values({ 1,2,3,4,5 }) {}
};*/

/*
sf::Packet& operator <<(sf::Packet& packet, Test& data)
{
	return packet << data._value;
}

sf::Packet& operator >>(sf::Packet& packet, Test& data)
{
	return packet >> data._value;
}
*/

class Client {
protected:
	sf::TcpSocket _socket;
public:
	sf::TcpSocket &socket() { return _socket; }
	bool connect(sf::IpAddress server_address, unsigned short server_port);
	bool send_to_server(sf::Packet &packet);
	bool receive_from_server();

	void update();

	Client();
	Client(const Client &copy) {}
};
Client::Client() {

}
bool Client::connect(sf::IpAddress server_address, unsigned short server_port) {
	if (_socket.connect(server_address, server_port) != sf::Socket::Done)
	{
		return false;
	}

	return true;
}
bool Client::send_to_server(sf::Packet &packet) {
	if (_socket.send(packet) != sf::Socket::Done) {
		return false;
	}
	return true;
}
bool Client::receive_from_server() {
	sf::Packet temp;
	if (_socket.receive(temp) == sf::Socket::Done) {
		//PUSH INTO GAME STATE

		return true;
	}
	return false;
}
void Client::update() {
	sf::Packet temp;
	receive_from_server();
}

class Server {
protected:
	const unsigned short _port_listener_default;
	const unsigned short _port_limit;

	bool _listening_for_connections;

	sf::IpAddress _address;
	unsigned short _port_listener;
	sf::TcpListener _listener;
	std::vector <Client> _clients;
public:
	sf::IpAddress address() { return _address; }
	unsigned short port_listener() { return _port_listener; }

	bool initialize();
	void accept_connections();
	void finalize_connections();

	bool distribute(sf::Packet &packet);
	bool receive_and_distribute();

	void update();

	Server();
	virtual ~Server() {}
};
Server::Server() :
	_port_listener_default(54000),_port_limit(55000), _listening_for_connections(false)
{
	//LISTENER DOES NOT STOP PROGRAM FROM RUNNING, RETURNS 0 UNLESS IT FINDS A CONNECTION WAITING
	_listener.setBlocking(false);
	//START WITH ONE EMPTY CLIENT TO CONNECT
	_clients.resize(1);
}
bool Server::initialize() {
	//_address = sf::IpAddress::getPublicAddress();
	//TEMP
	_address = sf::IpAddress::getLocalAddress();

	if (_address == sf::IpAddress::None) {
		return false;
	}

	_port_listener = _port_listener_default;
	while ((_listener.listen(_port_listener) != sf::Socket::Done)) {
		_port_listener++;
		if (_port_listener > _port_limit) {
			return false;
		}
	}

	//FLAG SO THAT UPDATE WILL KNOW TO CHECK FOR NEW CONNECTIONS
	_listening_for_connections = true;

	return true;
}
void Server::accept_connections() {
	if (_listener.accept(_clients.back().socket()) == sf::Socket::Done) {
		//ADD ANOTHER EMPTY CLIENT AT THE END TO FILL
		_clients.resize(_clients.size() + 1);
	}
}
void Server::finalize_connections() {
	_listening_for_connections = false;
	//TRIM THE LAST EMPTY CLIENT
	_clients.pop_back();
}
bool Server::distribute(sf::Packet &packet) {
	for(auto i = _clients.begin(); i != _clients.end(); i++) {
		//SEND ON EACH CLIENT SOCKET (DISTINCT FROM THE METHOD BY WHICH A CLIENT SENDS OR RECEIVES TO/FROM SERVER
		if ((*i).socket().send(packet) != sf::Socket::Done) {
			return false;
		}
	}
	//THEN PUSH TO OWN GAME STATE

	return true;
}
bool Server::receive_and_distribute() {
	sf::Packet temp;
	bool found = false;
	for (auto i = _clients.begin(); i != _clients.end(); i++) {
		//RECEIVER ALONG EACH CLIENT'S SOCKET UNTIL A PACKET IS FOUND
		//DISTINCT FROM THE CLIENT METHODS TO SEND/RECEIVE TO/FROM SERVER
		if ((*i).socket().receive(temp) == sf::Socket::Done) {
			found = true;
			break;
		}
	}

	if (found) {
		//SEND TO ALL CLIENTS
		distribute(temp);
		//THEN PUSH TO OWN GAME STATE

		//TEMP
		Burger burger_receiver;
		burger_receiver.packet_read(temp);
		burger_receiver.report();
	}

	return true;
}
void Server::update() {
	if (_listening_for_connections) {
		accept_connections();
	}

	receive_and_distribute();
}

class Connection {
protected:
	//FLAGS WHETHER THIS COMPUTER IS HOSTING THE GAME
	bool _hosting;

public:
	Server server_self;
	Client client_self;

	bool connect_as_client(sf::IpAddress server_address, unsigned short server_port);
	bool connect_as_server();
	void packet_distribute(sf::Packet &packet);

	void start_game();

	void update();

	Connection();
};
Connection::Connection() :
	_hosting(false)
{

}
bool Connection::connect_as_client(sf::IpAddress server_address, unsigned short server_port) {
	return client_self.connect(server_address, server_port);
}
bool Connection::connect_as_server() {
	if (! server_self.initialize()) {
		return false;
	}

	_hosting = true;
	return true;
}
void Connection::packet_distribute(sf::Packet &packet) {
	if (_hosting) {
		server_self.distribute(packet);
		//SEND PACKET TO ALL OTHER CLIENTS THEN TO CLIENT_SELF
	}
	else {
		client_self.send_to_server(packet);
		//SEND PACKET TO HOST, WAIT TO RECEIVE IT BACK
	}
}
void Connection::start_game() {
	if (_hosting) {
		//SERVER: TRIM EMPTY CONNECTION FROM SERVER AND STOP UPDATE FROM FINDING NEW CONNECTIONS
		server_self.finalize_connections();
	}
}
void Connection::update() {
	if (_hosting) {
		server_self.update();
	}
	else {
		client_self.update();
	}
}

int main()
{

	//Garbage garbage;
	//garbage.test();

	std::cout << "Started." << std::endl;

	Connection _connection_server;
	Connection _connection_client;

	if (! _connection_server.connect_as_server()) {
		std::cout << "Error\n";
	}
	_connection_client.connect_as_client(_connection_server.server_self.address(), _connection_server.server_self.port_listener());

	_connection_server.update();

	_connection_server.start_game();

	Burger burger_sender(Toppings(Bun("Sesame"), Meat(std::vector<Patty>({ Patty("Beef"), Patty("Chicken") })), Vegetables(std::vector<Veggie>({ Veggie(6, "Pickles"),Veggie(20, "Lettuce"),Veggie(1, "Tomato") })), Condiments(std::vector<Condiment>({ Condiment(-1,0.33,"Mustard"), Condiment(2,0.66,"Ketchup") }))));
	burger_sender.report();

	sf::Packet packet_sender;

	burger_sender.packet_write(packet_sender);

	_connection_client.packet_distribute(packet_sender);
	_connection_server.update();
	_connection_server.update();
	_connection_server.update();

	/*Burger burger_receiver;
	burger_receiver.packet_read(packet_receiver);

	std::cout << "\n\nReceived::\n";
	burger_receiver.report();*/

	std::cout << "Finished." << std::endl;

	system("pause");

	return 0;
}