#include <iostream>
#include <cstdlib>
#include <utility>
#include <vector>
#include <ctime>
using namespace std;

class Organism {
public:
	int get_x();
	int get_y();
	int get_steps_made();
	char get_type();
	void set_x(int x_coord);
	void set_y(int y_coord);
	void iterate_steps_made();
	void set_steps_made(int steps);
	void set_type(char type_char);
private:
	int x;
	int y;
	int steps_made;
	char type;
};

class World {
public:
	World();
	World(const World& other);
	World(World&& other);
	~World();
	World& operator=(const World& right);
	World& operator=(World&& right);

	int get_current_step();
	void iterate_current_step();
	void set_organism(int x, int y, Organism* organism);
	void drop_organism(int x, int y);
	void display_world();
	Organism* get_organism(int x, int y);
	vector<Organism*>& operator[](int index);
private:
	int current_step;
	vector < vector<Organism*>> grid;
};

class Ant : public Organism {
public:
	Ant(int x, int y);
	void move(World& world);
private:
};

class Doodlebug : public Organism {
public:
	Doodlebug(int x, int y);
	//void move(const World& world);
private:
};

int main() {
	World world = World();
	world.display_world();

	return 0;
}

World::World() {
	int x, y;
	vector<Organism*> temp(20);

	srand(time(0));
	current_step = 1;

	for (x = 0; x < 20; x++) {
		grid.push_back(temp);
		for (y = 0; y < 20; y++) {
			grid[x][y] = nullptr;
		}
	}

	for (int i = 0; i < 5; i++) {
		do {
			x = rand() % 20;
			y = rand() % 20;
		} while (grid[x][y] != nullptr);
		grid[x][y] = new Doodlebug(x, y);
	}

	for (int i = 0; i < 100; i++) {
		do {
			x = rand() % 20;
			y = rand() % 20;
		} while (grid[x][y] != nullptr);
		grid[x][y] = new Ant(x, y);
	}
}

World::World(const World& other) {
	current_step = other.current_step;

	for (int x = 0; x < 20; x++) {
		for (int y = 0; y < 20; y++) {
			if (other.grid[x][y] == nullptr) {
				grid[x][y] = nullptr;
			}
			else if (other.grid[x][y]->get_type() == 'A') {
				grid[x][y] = new Ant(other.grid[x][y]->get_x(), other.grid[x][y]->get_y());
			}
			else if (other.grid[x][y]->get_type() == 'D') {
				grid[x][y] = new Doodlebug(other.grid[x][y]->get_x(), other.grid[x][y]->get_y());
			}
		}
	}
}

World::World(World&& other) {
	current_step = other.current_step;
	swap(grid, other.grid);
}

World::~World() {
	for (int x = 0; x < 20; x++) {
		for (int y = 0; y < 20; y++) {
			if (grid[x][y] != nullptr) {
				delete grid[x][y];
			}
		}
	}
}

World& World::operator=(const World& right) {
	current_step = right.current_step;

	for (int x = 0; x < 20; x++) {
		for (int y = 0; y < 20; y++) {
			if (right.grid[x][y] == nullptr) {
				grid[x][y] = nullptr;
			}
			else if (right.grid[x][y]->get_type() == 'A') {
				grid[x][y] = new Ant(right.grid[x][y]->get_x(), right.grid[x][y]->get_y());
			}
			else if (right.grid[x][y]->get_type() == 'D') {
				grid[x][y] = new Doodlebug(right.grid[x][y]->get_x(), right.grid[x][y]->get_y());
			}
		}
	}

	return *this;
}

World& World::operator=(World&& right) {
	current_step = right.current_step;
	swap(grid, right.grid);

	return *this;
}

int World::get_current_step() {
	return current_step;
}

void World::iterate_current_step() {
	current_step++;
}

void World::set_organism(int x, int y, Organism* organism) {
	grid[x][y] = organism;
}

void World::drop_organism(int x, int y) {
	grid[x][y] = nullptr;
}

void World::display_world() {
	for (int y = 0; y < 20; y++) {
		for (int x = 0; x < 20; x++) {
			if (grid[x][y] = nullptr) {
				cout << " ";
			}
			else if (grid[x][y]->get_type() == 'A') {
				cout << "O";
			}
			else if (grid[x][y]->get_type() == 'D') {
				cout << "X";
			}
		}
		cout << endl;
	}
}

Organism* World::get_organism(int x, int y) {
	return grid[x][y];
}

vector<Organism*>& World::operator[](int index) {
	return grid[index];
}

int Organism::get_x() {
	return x;
}

int Organism::get_y() {
	return y;
}

int Organism::get_steps_made() {
	return steps_made;
}

char Organism::get_type() {
	return type;
}

void Organism::set_x(int x_coord) {
	x = x_coord;
}

void Organism::set_y(int y_coord) {
	y = y_coord;
}

void Organism::set_steps_made(int steps) {
	steps_made = steps;
}

void Organism::iterate_steps_made() {
	steps_made++;
}

void Organism::set_type(char type_char) {
	type = type_char;
}

Ant::Ant(int x, int y) {
	set_x(x);
	set_y(y);
	set_steps_made(0);
	set_type('A');
	//cout << get_x() << " " << get_y() << endl;
}

void Ant::move(World& world) {
	int direction;
	int temp_x = get_x();
	int temp_y = get_y();

	srand(time(0));
	direction = rand() % 4;

	switch (direction) {
	case 0:
		if (get_y() != 19 && get_steps_made() < world.get_current_step() && world.get_organism(get_x(), get_y() + 1) == nullptr) {
			world.set_organism(get_x(), get_y() + 1, this);
			world.drop_organism(get_x(), get_y());
			set_y(get_y() + 1);
			iterate_steps_made();
		}
			break;
	case 1:
		if (get_x() != 19 && get_steps_made() < world.get_current_step() && world.get_organism(get_x() + 1, get_y()) == nullptr) {
			world.set_organism(get_x() + 1, get_y(), this);
			world.drop_organism(get_x(), get_y());
			set_x(get_x() + 1);
			iterate_steps_made();
		}
			break;
	case 2:
		if (get_y() != 0 && get_steps_made() < world.get_current_step() && world.get_organism(get_x(), get_y() - 1) == nullptr) {
			world.set_organism(get_x(), get_y() - 1, this);
			world.drop_organism(get_x(), get_y());
			set_y(get_y() - 1);
			iterate_steps_made();
		}
			break;
	case 4:
		if (get_x() != 0 && get_steps_made() < world.get_current_step() && world.get_organism(get_x() - 1, get_y()) == nullptr) {
			world.set_organism(get_x() - 1, get_y(), this);
			world.drop_organism(get_x(), get_y());
			set_x(get_x() - 1);
			iterate_steps_made();
		}
		break;
	}
}

Doodlebug::Doodlebug(int x, int y) {
	set_x(x);
	set_y(y);
	set_type('D');
}