#pragma once
#include "Collision.h"
#include "Texture.h"
#include "TextureManager.h"



enum class GroundTileTypes
{
	Air,
	Dirt,
	Stone,
	Iron
};

class GroundTileType {
public:
	GroundTileType(const std::string& filePath, GroundTileTypes type): m_filePath(filePath), m_type(type) {}
	virtual ~GroundTileType() = default;
	bool operator== ( const GroundTileType& rhs ) const {
		return m_type == rhs.m_type;
	}
	bool operator!= ( const GroundTileType& rhs) const {
		return m_type != rhs.m_type;
	}

	virtual bool operator== (const GroundTileType* rhs) const {
		return rhs->m_type == m_type;
	}
	virtual bool operator!= (const GroundTileType* rhs) const {
		return rhs->m_type != m_type;
	}

	virtual std::string getPath() const {
		return m_filePath;
	}

	virtual GroundTileTypes getType() const {
		return m_type;
	}
protected:
	std::string m_filePath;
private:
	GroundTileTypes m_type;
};

class RandomGroundTile: public GroundTileType {
public:
	RandomGroundTile(const std::string& filePath, GroundTileTypes type, int maxRandom): GroundTileType(filePath, type), m_maxRandom(maxRandom) {
	}

	~RandomGroundTile() override = default;

	bool operator== (const GroundTileType* rhs) const override{
		return rhs->getType() == this->getType();
	}
	
	bool operator!= (const GroundTileType* rhs) const override{
		return rhs->getType() != this->getType();
	}	
	
	std::string getPath() const override {
		int variant = utils::randRange(1, m_maxRandom);
		std::string toReplace{ "[0]" };
		std::string replacement = std::to_string(utils::randRange(1, m_maxRandom));

		size_t found = m_filePath.find(toReplace);
		std::string newFilePath{ m_filePath };
		
		if(found != std::string::npos) {
			newFilePath.replace(found, 3, replacement);
		}
		
		return newFilePath;
	} 
private:
	int m_maxRandom;
};

namespace Tiles
{
	static GroundTileType* AIR  = new GroundTileType("", GroundTileTypes::Air);
	static GroundTileType* DIRT = new RandomGroundTile("tiles/dirt/dirt[0].png", GroundTileTypes::Dirt, 5);
	static GroundTileType* IRON = new GroundTileType("tiles/ores/Ore_Ironium.png", GroundTileTypes::Iron);
}

class WorldTile {
public:
	WorldTile() = default;
	WorldTile(const Point2f& position, GroundTileType* groundTileType, TextureManager* pTextureManager);
	~WorldTile();
	
	void Draw() const;

	Point2f GetPosition() const { return m_Position; }
	void	SetPosition(const Point2f& position) { m_Position = position; }

	Point2f GetSize() const { return Point2f{ 50, 50 }; }

	GroundTileType* GetTileType() const { return m_GroundTileType; }
	void SetTileType(GroundTileType* type) { m_GroundTileType = type; }

	Collision::TileCollisionRect GetCollisionRect();

	bool m_Hightlight{ false };
	
	
private:
	Point2f m_Position;
	GroundTileType* m_GroundTileType;

	Texture* m_pTexture;

	Collision::CollisionRect m_CollisionRect;

	
	
};