////////////////////////////////////////////////////////////////////////
// COMP2521 18x1 ... the Fury of Dracula
// GameView.c: GameView ADT implementation
//
// 2014-07-01   v1.0    Team Dracula <cs2521@cse.unsw.edu.au>
// 2017-12-01   v1.1    Team Dracula <cs2521@cse.unsw.edu.au>

#include <assert.h>
#include <err.h>
#include <stdbool.h>
#include <stdlib.h>
#include <sysexits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "Game.h"
#include "GameView.h"
#include "Globals.h"
#include "Map.h"// ... if you decide to use the Map ADT

#define MAX_SIZE 1000
#define LINE_LEN 40
#define PLAY_LEN 8

struct gameView {
    Round roundNumber;
    int currPlayer;
    int currScore;
    //pList players[NUM_PLAYERS];

    int godLife;
    int drsLife;
    int vanLife;
    int minLife;
    int draLife;

    int godLoca;
    int drsLoca;
    int vanLoca;
    int minLoca;
    int draLoca;

    char *pastP;

};
//static void pushToTrail(LocationID trail[TRAIL_SIZE], LocationID location);
//static int latestPlay(GameView gv);

static int pastPlaysLength(GameView gv){
    int i = 0;
    char *string = gv->pastP;
    while (string[i] != '\0'){
        i++;
    }
    return i;
}


// Creates a new GameView to summarise the current state of the game
GameView
newGameView (char *pastPlays, PlayerMessage messages[])
{
    GameView new = malloc (sizeof *new);
    //printf("%c is pastPlays[5]\n", pastPlays[5]);
    if (new == NULL) err (EX_OSERR, "couldn't allocate GameView");

    new->pastP = pastPlays;

    new->godLife = GAME_START_HUNTER_LIFE_POINTS;
    new->drsLife = GAME_START_HUNTER_LIFE_POINTS;
    new->vanLife = GAME_START_HUNTER_LIFE_POINTS;
    new->minLife = GAME_START_HUNTER_LIFE_POINTS;
    new->draLife = GAME_START_BLOOD_POINTS;

    new->godLoca = UNKNOWN_LOCATION;
    new->drsLoca = UNKNOWN_LOCATION;
    new->vanLoca = UNKNOWN_LOCATION;
    new->minLoca = UNKNOWN_LOCATION;
    new->draLoca = UNKNOWN_LOCATION;

    new->roundNumber = 0;
    new->currPlayer = 0;
    new->currScore = GAME_START_SCORE;

    return new;
}

// Frees all memory previously allocated for the GameView toBeDeleted
void
disposeGameView (GameView toBeDeleted)
{
    // COMPLETE THIS IMPLEMENTATION
    free (toBeDeleted);
}

//// Functions to return simple information about the current state of the game

// Get the current round
Round
getRound (GameView gv)
{
    if (strcmp(gv->pastP, "\0") == 0)   return 0;
    int i = 0;
    int roundCount = 0;
        while(gv->pastP[i] != '\0'){
            if (i%LINE_LEN == 0){
                roundCount++;
            }
            i++;
        }
    gv->roundNumber = roundCount;
    return roundCount;
}

// Get the id of current player - ie whose turn is it?
PlayerID
getCurrentPlayer (GameView gv)
{
    int pastPlaysLen = pastPlaysLength(gv);
    int i = 0;
    int currPlayer = 0;
    while (i < pastPlaysLen){
        if (i%8 == 0){
            currPlayer++;
            if (currPlayer > 4){
                currPlayer = 0;
            }
            //printf("i is divisible by 8, i is %d, currPlayer is %d\n", i, currPlayer);
        }
        i++;
    }
    //printf("%d is currplayer\n", currPlayer);
    return currPlayer;
}

// Get the current score
int
getScore (GameView gv)
{
    if (strcmp(gv->pastP, "\0") == 0){
        return GAME_START_SCORE;
    }

    return 0;
}

// Get the current health points for a given player
int
getHealth (GameView gv, PlayerID player)
{
    //int turnsMade = pastPlaysLength(gv)/8;
    int turnCount = 0;
    int i = 3;
    int playerAdd = 0;
    int playerHealth = 0;
    if (player == PLAYER_LORD_GODALMING) {
        playerAdd = 3;
        playerHealth = gv->godLife;
    }
    if (player == PLAYER_DR_SEWARD){
        playerAdd = 11;
        playerHealth = gv->drsLife;
    }
    if (player == PLAYER_VAN_HELSING){
        playerAdd = 19;
        playerHealth = gv->vanLife;
    }
    if (player == PLAYER_MINA_HARKER){
        playerAdd = 27;
        playerHealth = gv->minLife;
    }
    if (player == PLAYER_DRACULA){
        playerAdd = 3;
        playerHealth = gv->draLife;
    }

    if (player != PLAYER_DRACULA) {
        while (turnCount < getRound(gv)){
            printf("looping turncount\n");
            while (i < 5){
                if (gv->pastP[playerAdd+i] == 'D'){
                    playerHealth = playerHealth - 4;
                    printf("dracula encounters\n");
                }
                i++;
            }
            turnCount++;
            playerAdd = playerAdd+39;
            i = 0;
        }
        printf("%d is playerHealth\n", playerHealth);
        return playerHealth;
    }

    else if (player == PLAYER_DRACULA){
        int i = 0;
        char *string = gv->pastP;
        while ((playerAdd + i) < pastPlaysLength(gv)){
            while (i < 5){
                if (string[playerAdd + i] == 'D'){
                    gv->draLife = gv->draLife - 10;
                    printf("dracula encounetsszz\n");
                }
                i++;
            }
            i = 0;
            playerAdd = playerAdd+8;
            turnCount++;
        }
        printf("dralife is %d\n", gv->draLife);
        return gv->draLife;
    }

    return 0;
}

// Get the current location id of a given player
LocationID
getLocation (GameView gv, PlayerID player)
{
    int currPlayer = getCurrentPlayer(gv);
    printf("%d is currPlayer\n", currPlayer);
    char loca[2] = {0};
    loca[2] = '\0';
    int i = 1;
    if (strcmp(gv->pastP, "\0") == 0){
        return UNKNOWN_LOCATION;
    }
    if (player == PLAYER_LORD_GODALMING){
        loca[0] = gv->pastP[(LINE_LEN * (getRound(gv)-i)) + 1];
        loca[1] = gv->pastP[(LINE_LEN * (getRound(gv)-i)) + 2];
    }
    if (player == PLAYER_DR_SEWARD){
        if (currPlayer < 1 && getRound(gv)>1) i = 2;
        loca[0] = gv->pastP[(LINE_LEN * (getRound(gv)-i)) + 9];
        loca[1] = gv->pastP[(LINE_LEN * (getRound(gv)-i)) + 10];
    }
    if (player == PLAYER_VAN_HELSING){
        if (currPlayer < 2 && getRound(gv)>1) i = 2;
        loca[0] = gv->pastP[(LINE_LEN * (getRound(gv)-i)) + 17];
        loca[1] = gv->pastP[(LINE_LEN * (getRound(gv)-i)) + 18];
    }
    if (player == PLAYER_MINA_HARKER){
        if (currPlayer < 3 && getRound(gv)>1) i = 2;
        loca[0] = gv->pastP[(LINE_LEN * (getRound(gv)-i)) + 25];
        loca[1] = gv->pastP[(LINE_LEN * (getRound(gv)-i)) + 26];
    }
    if (player == PLAYER_DRACULA){
        if (currPlayer < 4 && getRound(gv)>1) i = 2;
        loca[0] = gv->pastP[(LINE_LEN * (getRound(gv)-i)) + 33];
        loca[1] = gv->pastP[(LINE_LEN * (getRound(gv)-i)) + 34];
    }



        printf("%s is loca\n", loca);
    char *b = loca;
    LocationID m = abbrevToID(b);
    printf("%d is m\n", m);
    if (player == PLAYER_DRACULA){
        if (validPlace(m))  {
            printf("validplace\n");
            return m;
        }
        if (loca[0] == 'C' && loca[1] == '?') return CITY_UNKNOWN;
        if (loca[0] == 'S' && loca[1] == '?') return SEA_UNKNOWN;
        if (loca[0] == 'H' && loca[1] == 'I') return HIDE;
        /*if (loca[0] == 'D' && loca[1] == '1') return DOUBLE_BACK_ONE;
        if (loca[0] == 'D' && loca[1] == '2') return DOUBLE_BACK_TWO;
        if (loca[0] == 'D' && loca[1] == '3') return DOUBLE_BACK_THREE;
        if (loca[0] == 'D' && loca[1] == '4') return DOUBLE_BACK_FOUR;
        if (loca[0] == 'D' && loca[1] == '5') return DOUBLE_BACK_FIVE;*/
        if (loca[0] == 'T' && loca[1] == 'P') return TELEPORT;
        else return UNKNOWN_LOCATION;
    }
    return m;
}

//// Functions that return information about the history of the game

// Fills the trail array with the location ids of the last 6 turns
void
getHistory (GameView gv, PlayerID player, LocationID trail[TRAIL_SIZE])
{
    // REPLACE THIS WITH YOUR OWN IMPLEMENTATION
}

//// Functions that query the map to find information about connectivity

// Returns an array of LocationIDs for all directly connected locations

LocationID *
connectedLocations (GameView gv, int *numLocations,
    LocationID from, PlayerID player, Round round,
    bool road, bool rail, bool sea)
{
    // REPLACE THIS WITH YOUR OWN IMPLEMENTATION
    *numLocations = 0;
    return NULL;
}

// THIS PART JUST ADDED
/*void getHistory (GameView gv, PlayerID player, LocationID trail[TRAIL_SIZE])
{
    //Check if its the beginning of the game
    if (gv->roundNumber == 0) {
        int trailC = 0;
        while(trailC < TRAIL_SIZE){//add UNKNOWN_LOCATION to entire trail
            trail[trailC] = UNKNOWN_LOCATION;
            trailC++;
        }
    } else {
        //find latest play index in pastP
        int lastPlay = latestPlay(gv);
        while(pastP[lastPlay] != player){
            lastPlay = lastPlay - PLAY_LEN;
        }//latest play by player

        //now we fill in the trail, finally.
        int countr = 0;
        while(countr < TRAIL_SIZE){
            char currLoc[2];
            //extract location abbreviation
            currLoc[0] = pastP[lastPlay+1];
            currLoc[1] = pastP[lastplay+2];
            currLoc[2] = '\0';

            //turn location abbreviation to locationID
            LocationID currLocation = abbrevToID(currLoc);

            //finally, add locationID to trail
            pushToTrail(trail, currLocation);

            lastPlay = lastPlay - LINE_LEN;//go back to the previous round
            countr++;//will only go to 6 to ensure trail is at most last 6 plays.
        }
        //after all of this the trail array should be updated for
        //whichever player was parsed into the function.
    }
}

//local function to push location onto trail. oldest location falls off trail.
static void pushToTrail(LocationID trail[TRAIL_SIZE], LocationID location){
    assert(trail != NULL);
    int i = 0;
    LocationID temp = trail[i];
    while(trail[i] != '\0'){
        //tests to see if were adding to end of array
        if(i+1 == TRAIL_SIZE){
            trail[i] = location;
            i++;//increments and then loop ends.

        } else {//operation to shift numbers along array.
            trail[i] = location;
            location = temp;
            temp = trail[i+1];
            i++;
        }
    }
}

static int latestPlay(GameView gv){
    int i = 0;
    while(gv->pastP[i] != '\0'){//iterate to latest playt at end of pastP array
        i++;
    }
    i = i - PLAY_LEN;//subtract to reach the beginning
    return i;*/