#include <string>
#include <vector>

#include <SDL.h>
#include <SDL_image.h>

#ifndef _MAPS_H_
#define _MAPS_H_

struct tile{
	Uint16 tileSize;
	Uint16 sourceX;
	Uint16 sourceY;
	Uint16 drawX;
	Uint16 drawY;
	SDL_Surface* sourceImg;
};//struct tile

class tileMap{
	public:
		//data members
		SDL_Surface* sourceImg;
		std::vector<tile> map;
		std::vector<tile> tiles;
		//functions
		tileMap();
		tileMap(const char filename[],Uint16 tileSize,Uint8 gutter_size);
		tileMap(SDL_Surface* source_image,Uint16 tileSize,Uint8 gutter_size);
		void initMap(Uint16 map_width,Uint16 map_height);
		void drawMap(SDL_Surface* dest,int startX,int startY);
		Uint16 getTotalTiles();
		Uint16 getTileSize();
		Uint8 getGutterSize();
		Uint16 getMapWidth();
		Uint16 getMapHeight();
	private:
		//data members
		Uint16 totalTiles;
		Uint16 mapWidth;
		Uint16 mapHeight;
		Uint16 tileSize;
		Uint8 gutterSize;
		//functions
		void loadTiles();
};


#endif // _MAPS_H_

#include <string>
#include <vector>

#include <SDL.h>
#include <SDL_image.h>

#include "maps.h"

using namespace std;

tileMap::tileMap(){
	this->sourceImg = NULL;
}//tileMap::tileMap()

tileMap::tileMap(const char fileName[],Uint16 tile_size,Uint8 gutter_size){
	//fill out class info
	this->sourceImg = NULL;
	this->sourceImg = IMG_Load(fileName);
	this->tileSize = tile_size;
	this->totalTiles = ((sourceImg->w / this->tileSize) + (sourceImg->h / this->tileSize));
	this->gutterSize = gutter_size;

	//load the tiles
	if(this->sourceImg != NULL)
		this->loadTiles();
}//tileManager::tileManager(const char filename[],Uint16 tileWidth,Uint16 tileHeight)

tileMap::tileMap(SDL_Surface* source_image,Uint16 tile_size,Uint8 gutter_size){
	//fill out class info
	this->sourceImg = source_image;
	this->tileSize = tile_size;
	this->totalTiles = ((sourceImg->w / this->tileSize) + (sourceImg->h / this->tileSize));
	this->gutterSize = gutter_size;
}//tileMap(SDL_Surface* source_image,Uint16 tileSize,Uint8 gutter_size)

void tileMap::loadTiles(){
	this->tiles.clear();
	//for each row of tiles
	for(int rowIter = this->gutterSize ; rowIter < (this->sourceImg->w / (this->tileSize + this->gutterSize)) ; rowIter += (this->tileSize + this->gutterSize)){
		//for each column of tiles(per row)
		for(int colIter = this->gutterSize ; colIter < (this->sourceImg->w / (this->tileSize + this->gutterSize)) ; colIter += (this->tileSize + this->gutterSize)){
			tile iter;
			iter.tileSize = this->tileSize;
			iter.sourceImg = this->sourceImg;
			iter.sourceX = rowIter;
			iter.sourceY = colIter;

			this->tiles.push_back(iter);
		}//for each column of tiles(per row)
	}//for each row of tiles
}//void tileManager::loadTiles()

void tileMap::initMap(Uint16 map_width,Uint16 map_height){
	this->mapWidth = map_width;
	this->mapHeight = map_height;

	//Uint16 maxTile=0;
	//Uint16 randTile=0;
	//for(std::vector<tile>::iterator iter = this->tiles.begin() ; iter < this->tiles.end() ; iter++)
	//	maxTile++;

	//loop through each row of tiles
	for(int tileX=0 ; tileX < map_width ; tileX++){
		for(int tileY=0 ; tileY < map_height ; tileY++){
			//create an iterator to hold temporary data used to fill
			//the map that's being initialized
			tile iter;

			//randTile = rand()%maxTile;

			//randTile=rand()%maxTile;
			iter.sourceImg = this->sourceImg;
			iter.tileSize = this->tileSize;
			iter.sourceX = this->tiles[0].sourceX;
			iter.sourceY = this->tiles[0].sourceY;
			iter.drawX = tileX * this->tileSize;
			iter.drawY = tileY * this->tileSize;

			//add the tile to the map
			this->map.push_back(iter);
		}//for each column
	}//for each row
}//initMap(Uint16 map_width,Uint16 map_height)

void tileMap::drawMap(SDL_Surface* dest,int startX,int startY){
	//for each tile in the map
	SDL_Rect sourcePos;
	SDL_Rect destPos;
	for(std::vector<tile>::iterator iter = this->map.begin(); iter < this->map.end() ; iter++){
		//if it is on the surface horizontally (not too far left or right)
		if(iter->drawX + iter->tileSize > 0 && iter->drawX < dest->w){
			//if it is on the surface vertically (not too far up or down)
			if(iter->drawY + iter->tileSize > 0 && iter->drawY < dest->h){
				//grab the source positions and dimensions
				sourcePos.x = iter->sourceX;
				sourcePos.y = iter->sourceY;
				sourcePos.w = iter->tileSize;
				sourcePos.h = iter->tileSize;

				//get the destination position and dimensins
				destPos.x = (startX + iter->drawX);
				destPos.y = (startY + iter->drawY);
				//destPos.w = sourcePos.w;
				//destPos.h = sourcePos.h;

				//(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect))
				SDL_BlitSurface(iter->sourceImg,&sourcePos,dest,&destPos);
			}
		}
	}//for each tile in the map
}//void drawMap(SDL_Surface* dest,int startX,int startY);

Uint16 tileMap::getTotalTiles(){
	return this->totalTiles;
}//Uint16 getTotalTiles()

Uint16 tileMap::getTileSize(){
	return this->tileSize;
}//Uint16 getTotalTiles()

Uint8 tileMap::getGutterSize(){
	return this->gutterSize;
}//Uint16 getTotalTiles()

Uint16 tileMap::getMapWidth(){
	return this->mapWidth;
}//Uint16 tileMap::getMapWidth()

Uint16 tileMap::getMapHeight(){
	return this->mapHeight;
}//Uint16 tileMap::getMapHeight();