#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;
	}

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

	virtual std::string getPath() {
		return m_filePath;
	}
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_variant(utils::randRange(1, maxRandom)) {
	}

	~RandomGroundTile() override = default;

	std::string getPath() override {
		std::string toReplace{ "[0]" };
		std::string replacement = std::to_string(m_variant);

		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_variant;
};

namespace Tiles
{
	static GroundTileType AIR  = GroundTileType("", GroundTileTypes::Air);
	static GroundTileType DIRT = RandomGroundTile("tiles/dirt/dirt[0].png", GroundTileTypes::Dirt, 6);
	static GroundTileType IRON = 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;

	
	
};