#include "Level.h"
#include <iostream>
#include <fstream>

#include "Monster.h"
#include "Pickup.h"
#include "Hazard.h"
#include "Platform.h"

Level::Level() {
    startX = -1;
    startY = -1;
}

void Level::changeLevel(int levelNo) {
    std::cout << "Level::changeLevel(): Loading level " << levelNo << ".\n";

    // Creating some objects for fun/demonstration purposes
    Monster monster1;
    Pickup pickup1;
    Hazard hazard1;
    Platform platform1;

    // Load background image
    if (!(background = loadImage("space.png")))
        std::cout << "Level::changeLevel: Error loading background image.\n";

    // Make player into a Marcus
    player.setImage("marcussheet.png");
    player.setClip(ORIENT_FRONT, MARCUS_WIDTH * 0, 0, MARCUS_WIDTH, MARCUS_HEIGHT);
    player.setClip(ORIENT_BACK, MARCUS_WIDTH * 1, 0, MARCUS_WIDTH, MARCUS_HEIGHT);
    player.setClip(ORIENT_RIGHT, MARCUS_WIDTH * 2, 0, MARCUS_WIDTH, MARCUS_HEIGHT);
    player.setClip(ORIENT_LEFT, MARCUS_WIDTH * 3, 0, MARCUS_WIDTH, MARCUS_HEIGHT);

    // Read the map file (all level/player init should be done here, not above)
    loadMap(levelNo);

    if (startX < 0) {
        startX = 0;
        startY = 0;
    }

    player.setX(startX);
    player.setY(startY);

    cameraX = 0;
}

void Level::move() {
    // Construct a rectangle for player, for collision detection
    SDL_Rect rect;
    rect.w = player.getClip()->w;
    rect.h = player.getClip()->h;
    // Only record y-coord for now
    rect.y = player.getY();

    // Apply gravity
    player.incYVel(GRAVITY);

    // Player x-axis movement
    rect.x = player.getX() + player.getXVel();

    // If there's a collision in the x-axis ...
    while (checkCollision(rect)) {
        // ... fit snugly to edge
        if (player.getXVel() > 0) {
            rect.x--;
        } else {
            rect.x++;
        }
    }

    if (rect.x >= 0 && rect.x <= SCREEN_WIDTH - rect.w - 32) {
        player.setX(rect.x);
    }

    // Player y-axis movement
    rect.y = player.getY() + player.getYVel();

    // If there's a collision in the y-axis ...
    if (checkCollision(rect)) {
        while (checkCollision(rect)) {
            // ... fit snugly to edge
            if (player.getYVel() > 0)
                rect.y--;
            else
                rect.y++;
        }

        player.setYVel(0);
    }

    player.setY(rect.y);

    // Kill the player if they fall off the screen
    if (player.getY() > SCREEN_HEIGHT) {
        player.kill();
        player.setX(startX);
        player.setY(startY);
        cameraX = 0;
    }

    player.orient();
}

void Level::draw(Screen *screen) {
    // Blit background
    screen->blit(0, 0, background);

    screen->blit(player.getX(), player.getY(), player.image, player.getClip());

    // Scroll level
    if (player.getX() == 0 || player.getX() >= SCREEN_WIDTH
        - player.getClip()->w - 32 - MOVE_AMOUNT) {
        if (player.getXVel() < 0 || player.getXVel() > 0)
            cameraX -= player.getXVel();
    }

    // Don't let the camera move to before the start of the level
    if (cameraX > 0)
            cameraX = 0;

    // Draw each platform...
    for (int i = 0; i < numPlatforms; i++) {
        // ...if it is visible
        if (platform[i].getX() + TILE_SIZE + cameraX >= 0 && platform[i].getX()
            + cameraX <= SCREEN_WIDTH) {
            screen->blit(platform[i].getX() + cameraX, platform[i].getY(),
                         platform[0].image, platform[i].getClip());
        }
    }
}

void Level::loadMap(int LevelNo) {
    numPlatforms = 0;
    // TODO: Let each Platform have a reference a single tiles image
    platform[0].setImage("tiles.png");

    // Open map file
    std::ifstream map("level01.map");

    if (!map)
        std::cout << "map is NULL.\n";

    // Read each tile...
    for (int i = 0; i < MAP_X * MAP_Y; i++) {
        int type = -1;

        map >> type;

        if (map.fail()) {
            std::cout << "map.fail().\n";
        }

        // ...and register it as a platform if it's a platform
        if (type == 1 || type == 2) {
            // Set x/y-coordinates
            platform[numPlatforms].setX((i % MAP_X) * TILE_SIZE);
            platform[numPlatforms].setY((i / MAP_X) * TILE_SIZE);

            // Set the correct sprite sheet clip
            platform[numPlatforms].setClip(0, TILE_SIZE * (type - 1), 0, TILE_SIZE, TILE_SIZE);

            numPlatforms++;
        } else if (type == 'P') {
            // Set the player starting position
            startX = (i % MAP_X) * TILE_SIZE;
            startY = (i / MAP_X) * TILE_SIZE - player.getClip()->h;
        }
    }

    // Close map file
    map.close();
}

bool Level::checkCollision(SDL_Rect r) {
    // Loop through each platform
    for (int i = 0; i < numPlatforms; i++) {
        // Check for collisions in the x-axis ...
        if (r.x - cameraX > platform[i].getX() - r.w && r.x - cameraX < platform[i].getX() + TILE_SIZE)
            // ... if found, check for collisions in the y-axis
            if (r.y > platform[i].getY() - r.h && r.y < platform[i].getY() + TILE_SIZE)
                return true;
    }

    return false;
}