#include ".\Lavos.h"

Lavos::Lavos( SplashManager* splashManager, CharacterManager* characterManager, CollisionManager* collisionManager, TextManager* newText, DialogueManager* newDialogue, int tileX, int tileY, int dialogue ) : Character( characterManager, collisionManager, newText, newDialogue, tileX, tileY, dialogue ){
	init(splashManager, tileX, tileY);
}

Lavos::Lavos( SplashManager* splashManager, CharacterManager* characterManager, CollisionManager* collisionManager, TextManager* newText, DialogueManager* newDialogue, int tileX, int tileY, int triggerId, int dialogue ) : Character( characterManager, collisionManager, newText, newDialogue, tileX, tileY, triggerId, dialogue ){
	init(splashManager, tileX, tileY);
}

Lavos::~Lavos(void){
}

void Lavos::init(SplashManager* _splashManager, int tileX, int tileY){
    splashManager = _splashManager; 
	RECT* boundingBox = new RECT(); boundingBox->left = 21;  boundingBox->top = 55;
	                                boundingBox->right = 51; boundingBox->bottom = 104;
    addSpriteState(0, 0, 4, boundingBox, 71, 113, Character::STATE::WALKING);

    boundingBox = new RECT(); boundingBox->left = 21;  boundingBox->top = 55;
	                          boundingBox->right = 51; boundingBox->bottom = 104;
    addSpriteState(0, 452, 1, boundingBox, 71, 113, Character::STATE::IDLE);

    boundingBox = new RECT(); boundingBox->left = 21;  boundingBox->top = 55;
	                          boundingBox->right = 51; boundingBox->bottom = 104;
    addSpriteState(0, 565, 2, boundingBox, 71, 113, Character::STATE::CASTING);

    boundingBox = new RECT(); boundingBox->left = 31;  boundingBox->top = 55;
	                          boundingBox->right = 61; boundingBox->bottom = 109;
    addSpriteState(285, 0, 2, boundingBox, 110, 132, Character::STATE::ATTACK);

    boundingBox = new RECT(); boundingBox->left = 21;  boundingBox->top = 79;
	                          boundingBox->right = 51; boundingBox->bottom = 104;
    addSpriteState(285, 265, 5, boundingBox, 96, 100, Character::STATE::CREATION);


	setHeadTextureId( 21 );
    pushState(Character::STATE::CREATION);
    setSpriteState(Character::STATE::CREATION);
    setClip( GameCore::DIRECTION::DOWN );
	setTextureId( 99, tileX, tileY, 1024, 1024, boundingBox );

	HP = 200;
	HP_MAX = HP;
    strength = 20;
    expEarnedForKilling = 200;

	setPosition( tileX, tileY, boundingBox );
	
	characterSprite->setModulationColor( D3DCOLOR_RGBA( 255, 255, 255, 255 ) );
}

void Lavos::collide(Character* moveChar ) {
    if( moveChar->getType() == Character::MAIN ) {
//        size_t test = strlen(dialogueManager->getFileDialogue(0)) + 1;
  //      char* ouch = (char*)malloc(sizeof(char)*test);
    //    strcpy(ouch, dialogueManager->getFileDialogue(0));
      //  dialogueManager->addDialogue(ouch, characterHeadSprite);
	    //textManager->addString( getX(), getY(), ouch, 15, 1, Text::WORLD );
        dialogueManager->addDialogue(0, characterHeadSprite);
    }
}

Character::TYPE Lavos::getType() {
	return Character::TYPE::ENEMY;
}

void Lavos::setSpriteState( Character::STATE aState ) {
    switch(aState){
        case Character::STATE::ATTACK:
	        currentSpriteState = getSpriteState(Character::STATE::ATTACK);
            break;
        case Character::STATE::ATTACK_READY:
            currentSpriteState = getSpriteState(Character::STATE::WALKING);
            break;
        case Character::STATE::ATTACKED:
            currentSpriteState = getSpriteState(Character::STATE::WALKING);
            break;
        case Character::STATE::CREATION:
            currentSpriteState = getSpriteState(Character::STATE::CREATION);
            break;
        case Character::STATE::DEAD:
            currentSpriteState = getSpriteState(Character::STATE::WALKING);
            break;
        case Character::STATE::DYING:
            currentSpriteState = getSpriteState(Character::STATE::WALKING);
            break;
        case Character::STATE::IDLE:
            currentSpriteState = getSpriteState(Character::STATE::IDLE);
            break;
        case Character::STATE::WALKING:
            currentSpriteState = getSpriteState(Character::STATE::WALKING);
            break;
        case Character::STATE::MAGIC:
            currentSpriteState = getSpriteState(Character::STATE::CASTING);
            break;
        case Character::STATE::CASTING:
            currentSpriteState = getSpriteState(Character::STATE::CASTING);
            break;
    }
}

void Lavos::creation(){
	//GameError("lavos: creation");
	if ( yOffset > currentSpriteState->numFrames ){
		pushState(Character::STATE::IDLE);
    } else {
        animateSprite(Character::SPEED::TENTH);
    }
}

void Lavos::idle(){
    faceMainCharacter();
	//GameError("lavos: idle");
    Character* main = characterManager->getMainCharacter();

	if ( yOffset > currentSpriteState->numFrames ){
		yOffset = 0;
    }
    int diffX = getX() - main->getX();
    int diffY = getY() - main->getY();

    if(abs(diffX) < 64 && abs(diffY) < 64){
        pushState(Character::STATE::ATTACK);
    } else if(abs(diffX) < 100 && abs(diffY) < 800 ||
              abs(diffX) < 800 && abs(diffY) < 100 ){
        pushState(Character::STATE::MAGIC);
    } else {
        pushState(Character::STATE::WALKING);
    }
    animateSprite(Character::SPEED::THIRD);
}

void Lavos::walking(){
	//GameError("lavos: walking");
    if(yOffset > currentSpriteState->numFrames){
        popState();
    } else {
        Character* main = characterManager->getMainCharacter();
        int diffX = getX() - main->getX();
        int diffY = getY() - main->getY();
        
        if(diffX > 0){
            characterManager->moveCharacter(this, GameCore::DIRECTION::LEFT);
        } else if(diffX < 0){
            characterManager->moveCharacter(this, GameCore::DIRECTION::RIGHT);
        }
        if(diffY > 0){
            characterManager->moveCharacter(this, GameCore::DIRECTION::UP);
        } else if(diffY < 0){
            characterManager->moveCharacter(this, GameCore::DIRECTION::DOWN);
        }
        animateSprite(Character::SPEED::FIFTH);
    }
}

void Lavos::dying(){
	//GameError("lavos: dying");
	if( alpha > 0 ) {
		alpha -= 32;
	    characterSprite->setModulationColor( D3DCOLOR_RGBA( 255, 255, 255, alpha ) );
        move( GameCore::DIRECTION::UP, GameCore::DIRECTION::DOWN );
        move( GameCore::DIRECTION::UP, GameCore::DIRECTION::DOWN );
	} else {
        splashManager->loadSplash(903, DIK_RETURN, new ExitAfterSplash());
        characterManager->addToMainCharacterExperience(expEarnedForKilling);
        pushState(Character::STATE::DEAD);
	}
}

void Lavos::attacked(){
	//GameError("lavos: attacked");
	bool damaged = true;

    if (!attacker ){//|| attacker->getType() == Character::TYPE::PROJECTILE){
		damaged = false;
	}else if(attacker->getType() == Character::TYPE::PROJECTILE){
        if(this == ((Fireball*)attacker)->getCaster()){
            damaged = false;
        }
    }
	if(damaged){
		takeDamage();

		GameCore::DIRECTION move;
		if(attackedFrom == GameCore::DIRECTION::DOWN){
			move = GameCore::DIRECTION::UP;
		} else if(attackedFrom == GameCore::DIRECTION::UP){
			move = GameCore::DIRECTION::DOWN;
		} else if(attackedFrom == GameCore::DIRECTION::LEFT){
			move = GameCore::DIRECTION::RIGHT;
		} else if(attackedFrom == GameCore::DIRECTION::RIGHT){
			move = GameCore::DIRECTION::LEFT;
		}
		characterManager->moveCharacter( this, attackedFrom );
		characterManager->moveCharacter( this, attackedFrom );
		if( (attackedFrom == GameCore::DOWN) || (attackedFrom == GameCore::UP)){
			characterManager->moveCharacter( this, attackedFrom );
			characterManager->moveCharacter( this, attackedFrom );
		} 
		setClip( move );
	}
    if( getHP() <= 0 ) {
	    pushState( Character::DYING );
	} else {
		popState();
	}
    attacker = 0;
}

void Lavos::attack(){
	//GameError("lavos: attack");
    if ( yOffset == 1 ){
    	characterManager->checkAttack(this);
    }
	if ( yOffset > currentSpriteState->numFrames ){
    //if ( yOffset == currentSpriteState->numFrames - 1 ){
		popState(); // one for attack
    } else {
        animateSprite(Character::SPEED::NORMAL);
    }
}

void Lavos::attackReady(){
	//GameError("lavos: attack ready");
}

void Lavos::dead(){
	//GameError("lavos: dead");
}

void Lavos::magic() {
    isCasting = false;
    pushState(Character::STATE::CASTING);
}

void Lavos::casting() {
//GameError("casting");
    if(!isCasting){
        isCasting = true;
        isDoneCasting = false;

        RECT* box = new RECT;
		box->bottom = getBoundingBox()->bottom + getY();
		box->top = getBoundingBox()->top + getY();
		box->left = getBoundingBox()->left + getX();
		box->right = getBoundingBox()->right + getX();

		int heightDiff = box->bottom - box->top;
		int widthDiff = box->right - box->left;

		int fireX = box->left + (widthDiff/2);
        int fireY = getY() + currentSpriteState->height/2;

		switch( facing ) {
			case GameCore::DIRECTION::RIGHT:
				fireX += (widthDiff/2) + 15;
				fireX += 15;
				break;
			case GameCore::DIRECTION::LEFT:
				fireX -= (widthDiff/2);
				fireX -= 30;
				break;
			case GameCore::DIRECTION::UP:
				fireY -= 45;
				break;
			case GameCore::DIRECTION::DOWN:
				fireY += 55;
				break;
		}
		TILE* tile = getTile();
		Fireball* fire = new Fireball(this, characterManager, collisionManager, textManager, dialogueManager,tile->x,tile->y+2, facing, -1);
		fireX = fireX - fire->getBoundingBox()->left - ((fire->getBoundingBox()->right - fire->getBoundingBox()->left)/2);
		fireY = fireY - fire->getBoundingBox()->top - ((fire->getBoundingBox()->bottom - fire->getBoundingBox()->top)/2);
		
		fire->setX( fireX );
		fire->setY( fireY );
		characterManager->addCharacter(fire);
    } else if(!isDoneCasting){
        animateSprite(Character::SPEED::NORMAL);
    } else if (isDoneCasting){
        isCasting = false;
        popState(); // pop casting
        popState(); // pop magic
    }
}