//
//  Enemy.cpp
//  
//
//  Created by Matthew Pick on 11/25/14.
//
//

#include "Enemy.h"

#include <GLUT/glut.h>
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#include <iostream>
using namespace std;

const float DEAD_Y_RADIUS = .1;
const float DEAD_X_RADIUS = .05;

const float X_TRANSLATION_VAL = .00175;

const float DEAD_Y_TRANSLATION = 0.02;

const int ACORN_EXPLOSION_SCORE = 50;
const int SQUIRREL_BOUNCE_SCORE = 100;

#define LEFT 1
#define RIGHT 2


Enemy::Enemy(float xStart, float yStart, int tex, int deadTex, int direction){
    centerX = xStart;
    centerY = yStart;
    enemyTex = tex;
    deadEnemyTex = deadTex;
    xDirection = direction;
    
    enemyDeadCounter = 0;
    
    enemyDead = false;
}


void Enemy::updateEnemyCoordinates(){
    
    if (xDirection == LEFT){
        if (centerX-X_RADIUS <= -.5){
            xDirection = RIGHT;
            centerX = -.5+X_RADIUS;
        }
        else centerX -= X_TRANSLATION_VAL;
    } else if (xDirection == RIGHT){
        if (centerX+X_RADIUS >= .5){
            xDirection = LEFT;
            centerX = .5-X_RADIUS;
        }
        else centerX += X_TRANSLATION_VAL;
        
    }
}

void Enemy::checkForAcornCollision(Acorn *acorn, float cameraPosition, int *score){
    bool collision = false;
    bool bottomCollision = false;
    
//    cout << "center: " << acorn->centerY << endl << endl;
    
    float acornLeftSide = acorn->centerX - acorn->X_RADIUS;
    float acornRightSide = acorn->centerX + acorn->X_RADIUS;
    
    float acornTopSide = acorn->centerY + acorn->Y_RADIUS;
    float acornBottomSide = acorn->centerY - acorn->Y_RADIUS;
    
    
    float enemyLeftSide = centerX - X_RADIUS;
    float enemyRightSide = centerX + X_RADIUS;
    
    float enemyTopSide = centerY + Y_RADIUS;
    float enemyBottomSide = centerY - Y_RADIUS;
    
    
    if (enemyBottomSide >= cameraPosition+1-(Y_RADIUS*2) || enemyDead) return;
    
    
    // check top left corner of enemy
    if (enemyLeftSide >= acornLeftSide && enemyLeftSide <= acornRightSide && enemyTopSide <= acornTopSide && enemyTopSide >= acornBottomSide){
        collision = true;
        cout << "enemy top left inside" << endl;
    }
    
    // check top right corner of enemy
    if (enemyRightSide >= acornLeftSide && enemyRightSide <= acornRightSide && enemyTopSide <= acornTopSide && enemyTopSide >= acornBottomSide){
        collision = true;
        cout << "enemy top right inside" << endl;
    }
    
    // check bottom left corner of enemy
    if (enemyLeftSide >=  acornLeftSide && enemyLeftSide <= acornRightSide && enemyBottomSide <= acornTopSide && enemyBottomSide >= acornBottomSide){
        collision = true;
        cout << "enemy bottom left inside" << endl;
    }
    
    // check bottom right corner of enemy
    if (enemyRightSide >= acornLeftSide && enemyRightSide <= acornRightSide && enemyBottomSide <= acornTopSide && enemyBottomSide >= acornBottomSide){
        collision = true;
        cout << "enemy bottom right inside" << endl;
    }
    
    
    //check if acorn bottom is colliding indicating bounce
    if (acornLeftSide >= enemyLeftSide && acornLeftSide <= enemyRightSide && acornBottomSide <= enemyTopSide && acornBottomSide >= enemyBottomSide){
        bottomCollision = true;
    }
    
    if (acornRightSide >= enemyLeftSide && acornRightSide <= enemyRightSide && acornBottomSide <= enemyTopSide && acornBottomSide >= enemyBottomSide){
        bottomCollision = true;
    }
    
    if (acornRightSide >= centerX && acornLeftSide <= centerX && acornBottomSide <= centerY && acornTopSide >= centerY){
        collision = true;
    }
    
    
    if (collision){
        cout << "here" << endl<< endl;
        acorn->explode = true;
        enemyDied();
        *score += ACORN_EXPLOSION_SCORE;
    }
}

void Enemy::checkForSquirrelCollision(Squirrel *squirrel, float cameraPosition, int *score){
    
    bool collision = false;
    bool bottomCollision = false;
    
    float squirrelLeftSide = squirrel->centerX - squirrel->X_RADIUS;
    float squirrelRightSide = squirrel->centerX + squirrel->X_RADIUS;
    
    float squirrelTopSide = squirrel->centerY + squirrel->Y_RADIUS;
    float squirrelBottomSide = squirrel->centerY - squirrel->Y_RADIUS;
    
    
    float enemyLeftSide = centerX - X_RADIUS;
    float enemyRightSide = centerX + X_RADIUS;
    
    float enemyTopSide = centerY + Y_RADIUS;
    float enemyBottomSide = centerY - Y_RADIUS;
    
    
    if (enemyBottomSide >= cameraPosition+1-(Y_RADIUS*2) || enemyDead) return;
    

    // check top left corner of enemy
    if (enemyLeftSide >= squirrelLeftSide && enemyLeftSide <= squirrelRightSide && enemyTopSide <= squirrelTopSide && enemyTopSide >= squirrelBottomSide){
        collision = true;
        cout << "enemy top left inside" << endl;
    }
    
    // check top right corner of enemy
    if (enemyRightSide >= squirrelLeftSide && enemyRightSide <= squirrelRightSide && enemyTopSide <= squirrelTopSide && enemyTopSide >= squirrelBottomSide){
        collision = true;
        cout << "enemy top right inside" << endl;
    }
    
    // check bottom left corner of enemy
    if (enemyLeftSide >=  squirrelLeftSide && enemyLeftSide <= squirrelRightSide && enemyBottomSide <= squirrelTopSide && enemyBottomSide >= squirrelBottomSide){
        collision = true;
        cout << "enemy bottom left inside" << endl;
    }
    
    // check bottom right corner of enemy
    if (enemyRightSide >= squirrelLeftSide && enemyRightSide <= squirrelRightSide && enemyBottomSide <= squirrelTopSide && enemyBottomSide >= squirrelBottomSide){
        collision = true;
        cout << "enemy bottom right inside" << endl;
    }
    
    
    //check if squirrel bottom is colliding indicating bounce
    if (squirrelLeftSide >= enemyLeftSide && squirrelLeftSide <= enemyRightSide && squirrelBottomSide <= enemyTopSide && squirrelBottomSide >= enemyBottomSide){
        bottomCollision = true;
    }
    
    if (squirrelRightSide >= enemyLeftSide && squirrelRightSide <= enemyRightSide && squirrelBottomSide <= enemyTopSide && squirrelBottomSide >= enemyBottomSide){
        bottomCollision = true;
    }
    
    if (squirrel->centerY >= enemyBottomSide && squirrelTopSide >= enemyTopSide && squirrel->centerX >= enemyLeftSide && squirrel->centerX <= enemyRightSide){
        bottomCollision = true;
    }
    
    
    if (collision){
        if (squirrel->getYAcceleration() < 0 && bottomCollision){
            squirrel->bounce();
            enemyDied();
            *score += SQUIRREL_BOUNCE_SCORE;
        }
        else squirrel->squirrelDied();
    }
}

void Enemy::enemyDied(){
    enemyDead = true;
}


void Enemy::draw(float cameraPosition){
    if (!enemyDead){
        
        glEnable(GL_TEXTURE_2D);
        glEnable(GL_ALPHA_TEST);
        
        glBindTexture(GL_TEXTURE_2D, enemyTex);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        
        glColor4f(1, 1, 1, 1);
        
        glBegin(GL_QUADS);
        
            if (xDirection == LEFT) glTexCoord2d(0, 0);
            else glTexCoord2d(1, 0);
            glVertex2f(centerX-X_RADIUS, centerY-Y_RADIUS);
        
            if (xDirection == LEFT) glTexCoord2d(0, 1);
            else glTexCoord2d(1, 1);
            glVertex2f(centerX-X_RADIUS, centerY+Y_RADIUS);
        
            if (xDirection == LEFT) glTexCoord2d(1, 1);
            else glTexCoord2d(0, 1);
            glVertex2f(centerX+X_RADIUS, centerY+Y_RADIUS);
        
            if (xDirection == LEFT) glTexCoord2d(1, 0);
            else glTexCoord2d(0, 0);
            glVertex2f(centerX+X_RADIUS, centerY-Y_RADIUS);
        
        glEnd();
        
        updateEnemyCoordinates();
        
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_ALPHA_TEST);
        
    } else {
        if (cameraPosition-1 <= centerY+Y_RADIUS){
            glEnable(GL_TEXTURE_2D);
            glEnable(GL_ALPHA_TEST);
            
            glBindTexture(GL_TEXTURE_2D, deadEnemyTex);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            
            glColor4f(1, 1, 1, 1);
            
            glBegin(GL_QUADS);
            
                glTexCoord2d(0, 0);
                glVertex2f(centerX-DEAD_X_RADIUS, centerY-(DEAD_Y_TRANSLATION*enemyDeadCounter)-DEAD_Y_RADIUS);
                
                glTexCoord2d(0,1);
                glVertex2f(centerX-DEAD_X_RADIUS, centerY-(DEAD_Y_TRANSLATION*enemyDeadCounter)+DEAD_Y_RADIUS);
                
                glTexCoord2d(1,1);
                glVertex2f(centerX+DEAD_X_RADIUS, centerY-(DEAD_Y_TRANSLATION*enemyDeadCounter)+DEAD_Y_RADIUS);
                
                glTexCoord2d(1,0);
                glVertex2f(centerX+DEAD_X_RADIUS, centerY-(DEAD_Y_TRANSLATION*enemyDeadCounter)-DEAD_Y_RADIUS);
            
            glEnd();
            
            glDisable(GL_TEXTURE_2D);
            glDisable(GL_ALPHA_TEST);
            
            enemyDeadCounter++;
        }
    }
}