/* 
 * Copyright (C) 2005-2008 MaNGOS <http://www.mangosproject.org/>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "Object.h"
#include "Player.h"
#include "BattleGround.h"
#include "BattleGroundAV.h"
#include "Creature.h"
#include "Chat.h"
#include "ObjectMgr.h"
#include "MapManager.h"
#include "Language.h"
#include <iostream>

BattleGroundAV::BattleGroundAV()
{

}

BattleGroundAV::~BattleGroundAV()
{

}

void BattleGroundAV::HandleKillPlayer(Player *player, Player *killer)
{
    if(GetStatus() != STATUS_IN_PROGRESS)
        return;

    uint8 teamIndex = GetTeamIndexByTeamId(player->GetTeam());
	if(teamIndex==0)
        AScore--;
    else HScore--;

	UpdateScore();
}
void BattleGroundAV::HandleKillUnit(Unit *unit, Player *killer)
{
    if(GetStatus() != STATUS_IN_PROGRESS)
        return;
    uint32 ressources = 0;
    uint32 reputation = 0;
    uint32 honor = 0;
    uint16 teamIndex = 0;
    if(GetTeamIndexByTeamId(killer->GetTeam()) == BG_TEAM_ALLIANCE)
        teamIndex = HORDE;
    else teamIndex = ALLIANCE;
    //check for general/captain mobs, generals end battleground and captains decrease tickets by 100
    switch(unit->GetEntry())
    {
        case 11948:
            reputation = 389;
            honor = 80;
            EndBattleGround(HORDE);
            break;
        case 11946:
            reputation = 389;
            honor = 80;
            EndBattleGround(ALLIANCE);
            break;
        case 11949:
            reputation = 125;
            honor = 60;
            rew.m_CaptainsAlive[BG_TEAM_ALLIANCE]--;
            rew.m_CaptainsKilled[BG_TEAM_HORDE]++;
            ressources = 100;
            break;
        case 11947:
            reputation = 125;
            honor = 60;
            rew.m_CaptainsAlive[BG_TEAM_HORDE]--;
            rew.m_CaptainsKilled[BG_TEAM_ALLIANCE]++;
            ressources = 100;
            break;
        case 13557:
            /* todo: CaptureMine(killer->GetTeam()); */
            reputation = 125;
            break;
        case 13539:
            /*todo: CaptureMine(killer->GetTeam()); */
            reputation = 125;
            break;
        default:
            ressources = 0;
            honor = 0;
            break;
    }
    uint32 faction = 0;
	if(teamIndex==0)
        HScore -= ressources;
    else AScore -= ressources;
    if(killer->GetTeam() == ALLIANCE)
        faction = 730;
    else faction = 729;

    if(reputation)
        RewardReputation(faction,reputation, killer->GetTeam(),killer);
    if(honor)
        RewardHonor(honor,killer->GetTeam(),killer);

	UpdateScore();
}
void BattleGroundAV::UpdateScore()
{
	uint32 TAScore = (AScore<0)?0:AScore;
	uint32 THScore = (HScore<0)?0:HScore;

	UpdateWorldState(AV_Alliance_Score, TAScore);
	UpdateWorldState(AV_Horde_Score, THScore);
}

void BattleGroundAV::InitWorldStates()
{
		UpdateWorldState(AV_Alliance_Score, AScore);
		UpdateWorldState(AV_Horde_Score, HScore);
		UpdateWorldState(AV_SHOW_H_SCORE, 1);
		UpdateWorldState(AV_SHOW_A_SCORE, 1);
}

void BattleGroundAV::Update(time_t diff)
{
    BattleGround::Update(diff);
    //BG is in preparation!
    if (GetStatus() == STATUS_WAIT_JOIN && GetPlayersSize())
    {
        ModifyStartDelayTime(diff);
		InitWorldStates();

        if (!(m_Events & 0x01))
        {
            m_Events |= 0x01;

            sLog.outDebug("Alterac Valley: entering state STATUS_WAIT_JOIN ...");

            // Starting doors
            MapManager::Instance().GetMap(GetMapId(), m_bgobjects[BG_AV_OBJECT_GATE_A])->Add(m_bgobjects[BG_AV_OBJECT_GATE_A]);
            MapManager::Instance().GetMap(GetMapId(), m_bgobjects[BG_AV_OBJECT_GATE_H])->Add(m_bgobjects[BG_AV_OBJECT_GATE_H]);

            SetStartDelayTime(START_DELAY0);
        }
        // After 1 minute, warning is signalled
        else if (GetStartDelayTime() <= START_DELAY1 && !(m_Events & 0x04))
        {
            m_Events |= 0x04;
            SendMessageToAll(LANG_BG_AV_ONEMINTOSTART);
        }
        // After 1,5 minute, warning is signalled
        else if (GetStartDelayTime() <= START_DELAY2 && !(m_Events & 0x08))
        {
            m_Events |= 0x08;
            SendMessageToAll(LANG_BG_AV_HALFMINTOSTART);
        }
        // After 2 minutes, gates OPEN ! x)
        else if (GetStartDelayTime() <= 0 && !(m_Events & 0x10))
        {
            m_Events |= 0x10;
            SendMessageToAll(LANG_BG_AV_STARTED);

            m_bgobjects[BG_AV_OBJECT_GATE_A]->SetUInt32Value(GAMEOBJECT_FLAGS,33);
            m_bgobjects[BG_AV_OBJECT_GATE_A]->SetUInt32Value(GAMEOBJECT_STATE,0);
            m_bgobjects[BG_AV_OBJECT_GATE_H]->SetUInt32Value(GAMEOBJECT_FLAGS,33);
            m_bgobjects[BG_AV_OBJECT_GATE_H]->SetUInt32Value(GAMEOBJECT_STATE,0);
            // Create banners for nodes 0-14
			for(uint32 i=BG_AV_OBJECT_FIRSTAID_STATION; i<(BG_AV_OBJECT_FIRSTAID_STATION+15); i++)
			{
				_CreateBanner(i);
				_ShowBanner(i);
                // set status of graveyards+mines
				if(!BG_AV_Nodes[i]._IsTower)
				{
                    //alliance graveyards
					if(i<7)
                        m_Nodestatus[i]=3;
                    //horde graveyards
					else if(i>7)
                        m_Nodestatus[i]=4;
                    //neutral graveyards
					else if(i=7)
                        m_Nodestatus[i]=0;
					_UpdateGYNode(i);
				}
			}
            PlaySoundToAll(SOUND_BG_START);
            SetStatus(STATUS_IN_PROGRESS);
            //set neutral graveyard to wasneutral=true ??? why! we got Nodestatus[7]=0; which is the same
			BG_AV_Nodes[7]._WasNeutral=true;
        }
    }
    //bg started/doors opened starting to spawn nodes/graveyards
    else if(GetStatus() == STATUS_IN_PROGRESS)
    {
        // Test win condition
        if (HScore <= 0)
            EndBattleGround(ALLIANCE);
        if (AScore <= 0)
            EndBattleGround(HORDE);

        // Towers/Nodes 0-14 capture check(time to capture remaining)
		for(uint32 i=BG_AV_OBJECT_FIRSTAID_STATION; i<BG_AV_OBJECT_IRONDEEP_MINE; i++)
		{
            // if it still needs to repop
			if(BG_AV_Nodes[i].RespawnTimer)
            {
                if(BG_AV_Nodes[i].RespawnTimer>diff)
                {
                    BG_AV_Nodes[i].RespawnTimer-=diff;
                }
                else
                {
				    BG_AV_Nodes[i].RespawnTimer=0;
				    _ShowBanner(i);
				}
            }
            // if it is attacked calculate time to destroy
			if(BG_AV_Nodes[i].StateTimer)
				if(BG_AV_Nodes[i].StateTimer>diff)
                {
                    BG_AV_Nodes[i].StateTimer-=diff;
                }
                //node will be destroyed
				else 
                {
					BG_AV_Nodes[i].StateTimer=0;
					//_DeleteBanner(i);
					UpdateWorldState(BG_AV_Nodes[i].WStates[BG_AV_Nodes[i].State],0);
                    // set from attacked(ally/horde: 3/4) to under control/destroyed(ally/horde: 1/2)
					BG_AV_Nodes[i].State-=2;
                    // set attacker dependant from nodestate(ally/horde: 0/1)
					uint8 teamIndex = BG_AV_Nodes[i].State-1;
					char buf[256];
					uint8 type = (teamIndex == 0) ? CHAT_MSG_BG_SYSTEM_ALLIANCE : CHAT_MSG_BG_SYSTEM_HORDE;
                    //if node=tower take ressources/set rewards
					if(BG_AV_Nodes[i]._IsTower)
					{
                        //Node has been destoryed
						sprintf(buf, LANG_BG_AV_TOWER_TAKEN, _GetNodeName(i));
						BG_AV_Nodes[i]._WasNeutral=false;
						if(teamIndex == 0)
                        {
                            HScore-=BG_AV_SCORE_TOWER_LOST;
                            rew.m_TowersControlled[BG_TEAM_HORDE]--;
                            rew.m_TowersDestroyed[BG_TEAM_ALLIANCE]++;
                        }
                        else
                        {
                            rew.m_TowersControlled[BG_TEAM_ALLIANCE]--;
                            rew.m_TowersDestroyed[BG_TEAM_HORDE]++;
                            AScore-=BG_AV_SCORE_TOWER_LOST;
                        }
						_DeleteBanner(i);
					}
                    //if node=mine/graveyard
                    else if(!BG_AV_Nodes[i]._IsMine && !BG_AV_Nodes[i]._IsTower)
					{
						_DeleteBanner(i);
						BG_AV_Nodes[i]._WasNeutral=false;
						_CreateBanner(i);
                        //going into repop
						BG_AV_Nodes[i].RespawnTimer=BG_AV_BANNER_RESPAWN_TIMER;
                        //who attacked node? -> (ally/horde: 3/4)
						m_Nodestatus[i]=teamIndex+3;
						_UpdateGYNode(i);
						sprintf(buf, LANG_BG_AV_GRAVE_TAKEN, _GetNodeName(i), (teamIndex == 0) ? LANG_BG_AB_ALLY : LANG_BG_AB_HORDE);
					}
					UpdateWorldState(BG_AV_Nodes[i].WStates[BG_AV_Nodes[i].State],1);
					WorldPacket data;
					ChatHandler::FillMessageData(&data, NULL, type, LANG_UNIVERSAL, NULL, 0, buf, NULL);
					SendPacketToAll(&data);
					UpdateScore();
				}
		}
	}
}

void BattleGroundAV::_CreateBanner(uint32 node)
{
    //if not already spawned: do spawn!
	if(!m_bgobjects[node])
	{
		m_bgobjects[node]= new GameObject(NULL);
		m_bgobjects[node+BG_AV_AURA]= new GameObject(NULL);
		sLog.outDebug("Alterac Valley: CREATE => node=%u id=%u state=%u",node,BG_AV_Nodes[node].GO_ids[BG_AV_Nodes[node].State],BG_AV_Nodes[node].State);
        if(!m_bgobjects[node]->Create(objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT), BG_AV_Nodes[node].GO_ids[BG_AV_Nodes[node].State] , GetMapId(), 
	        BG_AV_Nodes[node].x, BG_AV_Nodes[node].y, BG_AV_Nodes[node].z, BG_AV_Nodes[node].a, BG_AV_Nodes[node].r0, BG_AV_Nodes[node].r1, BG_AV_Nodes[node].r2, BG_AV_Nodes[node].r3, 100, 1))
                sLog.outError("Could not create banner on node: %u",node);

    uint32 banneraura = BG_AV_State_Auras[BG_AV_Nodes[node].State];
    // set banneraura for towers
    if(BG_AV_Nodes[node]._IsTower)
        banneraura = BG_AV_State_Auras_Small[BG_AV_Nodes[node].State];
    //apply banneraura
    if(!m_bgobjects[node+BG_AV_AURA]->Create(objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT), banneraura , GetMapId(), 
	    BG_AV_Nodes[node].x, BG_AV_Nodes[node].y, BG_AV_Nodes[node].z,
	    BG_AV_Nodes[node].a, BG_AV_Nodes[node].r0, BG_AV_Nodes[node].r1, 
	    BG_AV_Nodes[node].r2, BG_AV_Nodes[node].r3, 0, 0))
            sLog.outError("Could not create banner aura on node: %u",node);
    }
	else
	{
		sLog.outError("Alterac Valley: Bad node => %u OBJECT IS THERE",node);
	}
}
//repop banner!
void BattleGroundAV::_ShowBanner(uint32 node)
{
    if(!m_bgobjects[node])
        return;
	sLog.outDebug("Alterac Valley: SHOW => node=%u",node);
	MapManager::Instance().GetMap(GetMapId(), m_bgobjects[node])->Add(m_bgobjects[node]);
	MapManager::Instance().GetMap(GetMapId(), m_bgobjects[node+BG_AV_AURA])->Add(m_bgobjects[node+BG_AV_AURA]);
}
//remove banner
void BattleGroundAV::_DeleteBanner(uint32 node)
{
	sLog.outDebug("Alterac Valley: DELETE => node=%u",node);
	m_bgobjects[node]->Delete();
	m_bgobjects[node]=NULL;
	m_bgobjects[node+BG_AV_AURA]->Delete();
	m_bgobjects[node+BG_AV_AURA]=NULL;
    //only for towers 
	if(BG_AV_Nodes[node]._IsTower && !BG_AV_Nodes[node]._WasNeutral)
	{
		m_bgobjects[node+BG_AV_FIRES]= new GameObject(NULL);
		if(!m_bgobjects[node+BG_AV_FIRES]->Create(objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT), BG_AB_OBJECTID_FIRE , GetMapId(), 
			BG_AV_Nodes[node].x, BG_AV_Nodes[node].y, BG_AV_Nodes[node].z, BG_AV_Nodes[node].a, BG_AV_Nodes[node].r0, BG_AV_Nodes[node].r1, BG_AV_Nodes[node].r2, BG_AV_Nodes[node].r3, 0, 0))
            sLog.outError("Could not create fire aura on node: %u",node);
	}
}


void BattleGroundAV::AddPlayer(Player *plr)
{
    BattleGround::AddPlayer(plr);
    //create score and add it to map, default values are set in constructor
    BattleGroundAVScore* sc = new BattleGroundAVScore;

    m_PlayerScores[plr->GetGUID()] = sc;
}

void BattleGroundAV::RemovePlayer(Player *plr,uint64 guid)
{
    if(GetPlayersSize()==0)
    {
        sLog.outDebug("Alterac Valley: BG ended, objects despawning...");

        // delete everything (for times, when BG will instanced)
		for(uint32 i=BG_AV_OBJECT_FIRSTAID_STATION; i<(BG_AV_OBJECT_FIRSTAID_STATION+15); i++)
			if(BG_AV_Nodes[i].RespawnTimer)
			{
				BG_AV_Nodes[i].RespawnTimer=0;
				_ShowBanner(i); //if object is created but not spawned - may generate error
			}

        for(uint32 i = 0; i < BG_AV_OBJECT_MAX; i++)
            if (m_bgobjects[i])
			{
				m_bgobjects[i]->Delete();
				m_bgobjects[i] = NULL;
			}

		for(uint32 i = 0; i < BG_AV_SPIRITHEALER_COUNT; i++)
            if(m_spiritGuides[i])
		    {
			    m_spiritGuides[i]->CleanupsBeforeDelete();
			    ObjectAccessor::Instance().AddObjectToRemoveList(m_spiritGuides[i]);
			    m_spiritGuides[i] = NULL;
			    m_Nodestatus[i]=0;
		    }

        for(uint32 i = 0; i < BG_AV_CREATURE_COUNT; i++)
            if(m_bgcreatures[i])
            {
                m_bgcreatures[i]->CleanupsBeforeDelete();
            }
		Reset();
        SetupBattleGround();
	}
}

void BattleGroundAV::HandleAreaTrigger(Player *Source, uint32 Trigger)
{
    // this is wrong way to implement these things. On official it done by gameobject spell cast.
    if(GetStatus() != STATUS_IN_PROGRESS)
        return;

    uint32 SpellId = 0;
    switch(Trigger)
    {
        case 95:
        case 2608:
			if(Source->GetTeam() != ALLIANCE)
                Source->GetSession()->SendAreaTriggerMessage("Only The Alliance can use that portal");
            else
                Source->LeaveBattleground();
            break;
        case 2606:
            if(Source->GetTeam() != HORDE)
                Source->GetSession()->SendAreaTriggerMessage("Only The Horde can use that portal");
            else
                Source->LeaveBattleground();
            break;
        case 3326:
        case 3327:
        case 3328:
        case 3329:
        case 3330:
        case 3331:
			Source->GetSession()->SendAreaTriggerMessage("Warning: Unhandled AreaTrigger in Battleground: %u", Trigger);
			//Source->Unmount();
            break;
        default:
            sLog.outError("WARNING: Unhandled AreaTrigger in Battleground: %u", Trigger);
            Source->GetSession()->SendAreaTriggerMessage("Warning: Unhandled AreaTrigger in Battleground: %u", Trigger);
            break;
    }

    if(SpellId)
        Source->CastSpell(Source, SpellId, true);
}

void BattleGroundAV::UpdatePlayerScore(Player* Source, uint32 type, uint32 value)
{

    std::map<uint64, BattleGroundScore*>::iterator itr = m_PlayerScores.find(Source->GetGUID());

    if(itr == m_PlayerScores.end())                         // player not found...
        return;

    switch(type)
    {
        case SCORE_GRAVEYARDS_ASSAULTED:
            ((BattleGroundAVScore*)itr->second)->GraveyardsAssaulted += value;
            break;
        case SCORE_GRAVEYARDS_DEFENDED:
            ((BattleGroundAVScore*)itr->second)->GraveyardsDefended += value;
            break;
        case SCORE_TOWERS_ASSAULTED:
            ((BattleGroundAVScore*)itr->second)->TowersAssaulted += value;
            break;
        case SCORE_TOWERS_DEFENDED:
            ((BattleGroundAVScore*)itr->second)->TowersDefended += value;
            break;
        case SCORE_MINES_CAPTURED:
            ((BattleGroundAVScore*)itr->second)->MinesCaptured += value;
            break;
        case SCORE_LEADERS_KILLED:
            ((BattleGroundAVScore*)itr->second)->LeadersKilled += value;
            break;
        case SCORE_SECONDARY_OBJECTIVES:
            ((BattleGroundAVScore*)itr->second)->SecondaryObjectives += value;
            break;
        default:
            BattleGround::UpdatePlayerScore(Source,type,value);
            break;
    }
}

/* Invoked if a player used a banner as a gameobject */
void BattleGroundAV::EventPlayerCapturedBanner(Player *source)
{
    if(GetStatus() != STATUS_IN_PROGRESS)
        return;

	uint8 node = BG_AV_OBJECT_FIRSTAID_STATION;
    while (node < BG_AV_OBJECT_IRONDEEP_MINE)
	{
		if(m_bgobjects[node])
			if((source->IsWithinDistInMap(m_bgobjects[node], 10))) // player and nodes distance
				break;
        ++node;
	}

    if (node == (BG_AV_OBJECT_FIRSTAID_STATION+15))
    {
        // this means our player isn't close to any of banners - maybe cheater ??
		return;
    }

	_DeleteBanner(node);

    uint8 teamIndex = GetTeamIndexByTeamId(source->GetTeam());
    char buf[256];
    uint8 type = (teamIndex == 0) ? CHAT_MSG_BG_SYSTEM_ALLIANCE : CHAT_MSG_BG_SYSTEM_HORDE;

	BG_AV_Nodes[node].RespawnTimer = BG_AV_BANNER_RESPAWN_TIMER;
	BG_AV_Nodes[node].StateTimer = BG_AV_CAPTIME;

	UpdateWorldState(BG_AV_Nodes[node].WStates[BG_AV_Nodes[node].State],0);


	if(BG_AV_Nodes[node].State == 0)           // if node is neutral
        BG_AV_Nodes[node].State=teamIndex+3; // set state to: alliance=3, horde =4
	else 
        BG_AV_Nodes[node].State=5-BG_AV_Nodes[node].State; // if node already captured: alliance=4, horde=3

    // neutral graveyard
	if(BG_AV_Nodes[node]._WasNeutral) // node is neutral
        BG_AV_Nodes[node].State=teamIndex+3; // set state to: alliance=3, horde=4
    // if node=tower
	if(BG_AV_Nodes[node]._IsTower)
	{
        // if node is attacked (ally/horde: 3/4 - 4/3)
		if(BG_AV_Nodes[node].State>2)
		{
			UpdatePlayerScore(source,SCORE_TOWERS_ASSAULTED,1);
			sprintf(buf, LANG_BG_AV_TOWER_ASSAULTED, _GetNodeName(node), (teamIndex == 0) ? LANG_BG_AV_ALLY : LANG_BG_AV_HORDE);
		}
		else
		{
			UpdatePlayerScore(source,SCORE_TOWERS_DEFENDED,1);
			sprintf(buf, LANG_BG_AV_GRAVE_DEFENDED, _GetNodeName(node));
		}
	}
    // graveyards
	else
	{
        // neutral graveyard
		if(BG_AV_Nodes[node]._WasNeutral)
		{
			sprintf(buf, LANG_BG_AV_GRAVE_ASSAULTED, _GetNodeName(node), (teamIndex == 0) ? LANG_BG_AV_ALLY : LANG_BG_AV_HORDE);
			UpdatePlayerScore(source,SCORE_GRAVEYARDS_ASSAULTED,1);
		}
		else // graveyard already occupied now: under change!
		{
            // its attacked
			if(BG_AV_Nodes[node].State>2)
			{
				UpdatePlayerScore(source,SCORE_GRAVEYARDS_ASSAULTED,1);
				sprintf(buf, LANG_BG_AV_GRAVE_ASSAULTED, _GetNodeName(node), (teamIndex == 0) ? LANG_BG_AB_ALLY : LANG_BG_AB_HORDE);
				m_Nodestatus[node]=teamIndex+1;
				_UpdateGYNode(node);
			}
            // its defended
			else
			{
				UpdatePlayerScore(source,SCORE_GRAVEYARDS_DEFENDED,1);
				sprintf(buf, LANG_BG_AV_GRAVE_DEFENDED, _GetNodeName(node));
				m_Nodestatus[node]=teamIndex+3;
				_UpdateGYNode(node);
			}
		}
	}
	UpdateWorldState(BG_AV_Nodes[node].WStates[BG_AV_Nodes[node].State],1);
	WorldPacket data;
	ChatHandler::FillMessageData(&data, source->GetSession(), type, LANG_UNIVERSAL, NULL, source->GetGUID(), buf, NULL);
	SendPacketToAll(&data);
	UpdateScore();
	_CreateBanner(node);
}

void BattleGroundAV::_UpdateGYNode(uint32 GYid)
{
    if(GYid>BG_AV_OBJECT_GATE_H)
    {
        sLog.outError("There is no such node: %u",GYid);
        return;
    }
    std::cout << "GYid: " << GYid << std::endl;
    // 0=neutral 1= ally 2= horde
	uint32 gystate=m_Nodestatus[GYid];
	sLog.outDebug("Alterac Valley: GY %u UPDATE = %u",GYid,gystate);
    std::cout << "gystate: " << gystate << std::endl;
	if(gystate>0) //to prevent double freeing
	{
		
		if(gystate<3)
		{
			//changing from owned to free
            std::cout << "gystate: " << gystate << std::endl;
			sLog.outDebug("Alterac Valley: GY %u FREE",GYid);
			// Those who are waiting to resurrect at this node are taken to the closest own node's graveyard
			std::vector<uint64> ghost_list = m_ReviveQueue[m_spiritGuides[GYid]->GetGUID()];
            std::cout << "ghost_list initialized" << std::endl;
			if (!ghost_list.empty())
			{
                std::cout << "ghostlist NOT empty! sending players to different grave" << std::endl;
				WorldSafeLocsEntry const *ClosestGrave = NULL;
				Player *plr;
				for (std::vector<uint64>::iterator itr = ghost_list.begin(); itr != ghost_list.end(); ++itr)
				{
                    std::cout << "we are within gy list" << std::endl;
					plr = objmgr.GetPlayer(*ghost_list.begin());
					if (!plr)
						continue;
					if (!ClosestGrave)
                    {
                        std::cout << "sending player to different grave" << std::endl;
						ClosestGrave = SelectGraveYard(plr);
                        std::cout << "searching new closestrave " << std::endl;
                    }
                    if(ClosestGrave)
                    {
                        std::cout << "found new closestgrave: " << ClosestGrave->ID << "teleporting player" << std::endl;
					    plr->TeleportTo(GetMapId(), ClosestGrave->x, ClosestGrave->y, ClosestGrave->z, plr->GetOrientation());
                    }
                    else
                        sLog.outError("No graveyard found for player %u, faction %s",plr->GetGUIDLow(),(plr->GetTeam()==BG_TEAM_ALLIANCE) ? LANG_BG_AV_ALLY : LANG_BG_AV_HORDE);
				}
			}
            std::cout << "ghost-listing done" << std::endl;

			m_spiritGuides[GYid]->CleanupsBeforeDelete();
            std::cout << "Cleanup done, adding spiritguide to removelist" << std::endl;
			ObjectAccessor::Instance().AddObjectToRemoveList(m_spiritGuides[GYid]);
            std::cout << "its on removelist" << std::endl;
			m_spiritGuides[GYid] = NULL;
			m_Nodestatus[GYid]=0;
            std::cout << "everything is done: node is neutral" << std::endl;
		}
		else
		{
			//changing from free to owned
            std::cout << "node is now owned by different faction" << std::endl;
			if (m_spiritGuides[GYid])
				return;
            std::cout << "currently no spiritguide here" << std::endl;
			m_spiritGuides[GYid] = new Creature(NULL);
			sLog.outDebug("Alterac Valley: GY %u NEW SG",GYid);
            //get graveyardid for current node
			WorldSafeLocsEntry const* entry = sWorldSafeLocsStore.LookupEntry( BG_AV_GraveyardIds[GYid] );
            std::cout << "found graveyard id: " << GYid << std::endl;
            // create spiritguide
			if (!m_spiritGuides[GYid]->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), entry->map_id, entry->x, entry->y, entry->z, 1, BG_AV_SpiritGuideId[gystate-3],BG_AV_SpiritGuideTeamId[gystate-3] ))
                sLog.outError("Alterac Valley: Spiritguide could not be spawned for graveyard: %u", BG_AV_GraveyardIds[GYid]);
			m_spiritGuides[GYid]->setDeathState(DEAD);
			m_spiritGuides[GYid]->AIM_Initialize();
			sLog.outDebug("Alterac Valley: GY %u ADD = %u",GYid,m_spiritGuides[GYid]->GetEntry());
            // add to map
			MapManager::Instance().GetMap(GetMapId(), m_spiritGuides[GYid])->Add(m_spiritGuides[GYid]);
			m_spiritGuides[GYid]->CastSpell(m_spiritGuides[GYid], SPELL_SPIRIT_HEAL_CHANNEL, true);
			sLog.outDebug("Alterac Valley: GY %u DONE",GYid);
		}
	}
}

WorldSafeLocsEntry const* BattleGroundAV::SelectGraveYard(Player* player)
{
    uint8 teamIndex = GetTeamIndexByTeamId(player->GetTeam());

    // Are there any occupied nodes for this team?
    std::vector<uint8> nodes;
    for (uint8 i = 0; i < BG_AV_SPIRITHEALER_COUNT; ++i)
        if (m_Nodestatus[i] == teamIndex+3)
            nodes.push_back(i);

    WorldSafeLocsEntry const* good_entry = NULL;
    // If so, select the closest node to send ghost to
    if (!nodes.empty())
    {
        float x = player->GetPositionX();
        float y = player->GetPositionY();    // dont mind about z coordinate
        float mindist = 999999.0f;
        for (uint8 i = 0; i < nodes.size(); ++i)
        {
            WorldSafeLocsEntry const*entry = sWorldSafeLocsStore.LookupEntry( BG_AV_GraveyardIds[nodes[i]] );
            if(!entry) continue;
            float dist = (entry->x - x)*(entry->x - x)+(entry->y - y)*(entry->y - y);
            if (mindist > dist)
            {
                mindist = dist;
                good_entry = entry;
            }
        }
        nodes.clear();
    }
    // If not, send ghost to starting location
    if(!good_entry)
        good_entry = sWorldSafeLocsStore.LookupEntry( BG_AV_GraveyardIds[teamIndex+8] );

    return good_entry;
}

bool BattleGroundAV::SetupBattleGround()
{
	// Initialize objects table
	for (int i = 0; i < BG_AV_OBJECT_MAX; ++i)
		m_bgobjects[i] = NULL;
	for (int i = 0; i < BG_AV_SPIRITHEALER_COUNT; ++i)
		m_spiritGuides[i] = NULL;
    for (int i = 0; i < BG_AV_CREATURE_COUNT; i++)
        m_bgcreatures[i] = NULL;

	//for (int i = BG_AV_AURA; i < BG_AV_AURA+15; ++i)
	//	m_bgobjects[i]= new GameObject(NULL);
	AScore=BG_AV_SCORE_INITIAL_POINTS;
	HScore=BG_AV_SCORE_INITIAL_POINTS;
    //Alliance stats
    for(uint8 i=0; i<2; i++)
    {
        rew.m_CaptainsAlive[i] = 2;
        rew.m_CaptainsKilled[i] = 0;
        rew.m_TowersControlled[i] = 8;
        rew.m_TowersDestroyed[i] = 0;
        rew.m_MinesControlled[i] = 0;
        rew.m_GraveYardsControlled[i] = 3;
    }
    // Create starting objects

	// Starting gates
	m_bgobjects[BG_AV_OBJECT_GATE_A] = new GameObject(NULL);
	if(!m_bgobjects[BG_AV_OBJECT_GATE_A]->Create(objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT), BG_AV_OBJECTID_GATE_A, GetMapId(), BG_AV_DoorPositions[0][0], BG_AV_DoorPositions[0][1], BG_AV_DoorPositions[0][2], BG_AV_DoorPositions[0][3], BG_AV_DoorPositions[0][4], BG_AV_DoorPositions[0][5], BG_AV_DoorPositions[0][6], BG_AV_DoorPositions[0][7], 100, 1))
		return false;
	m_bgobjects[BG_AV_OBJECT_GATE_H] = new GameObject(NULL);
	if(!m_bgobjects[BG_AV_OBJECT_GATE_H]->Create(objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT), BG_AV_OBJECTID_GATE_H, GetMapId(), BG_AV_DoorPositions[1][0], BG_AV_DoorPositions[1][1], BG_AV_DoorPositions[1][2], BG_AV_DoorPositions[1][3], BG_AV_DoorPositions[1][4], BG_AV_DoorPositions[1][5], BG_AV_DoorPositions[1][6], BG_AV_DoorPositions[1][7], 100, 1))
		return false;

	WorldSafeLocsEntry const *sg = NULL;
	for(uint8 i=BG_AV_OBJECT_FIRSTAID_STATION; i<BG_AV_OBJECT_IRONDEEP_MINE; i++)
	{
		//m_bgobjects[i]= new GameObject(NULL);
		BG_AV_Nodes[i].RespawnTimer=0;
		BG_AV_Nodes[i].State=0; // neutral node
		BG_AV_Nodes[i].StateTimer=0;
		BG_AV_Nodes[i]._IsTower=true;
        BG_AV_Nodes[i]._IsMine=false;

        //check for node=graveyard
		if(BG_AV_NodePositions[i][8]==1)
            BG_AV_Nodes[i]._IsTower=false;

        // Check for node=mine
        if(BG_AV_NodePositions[i][8]==2)
        {
            BG_AV_Nodes[i]._IsMine=true;
            BG_AV_Nodes[i]._IsTower=false;
        }

		if(i<7)BG_AV_Nodes[i].State=1; // alliance node
		if(i>7)BG_AV_Nodes[i].State=2; // horde node

		BG_AV_Nodes[i].x=BG_AV_NodePositions[i][0];
		BG_AV_Nodes[i].y=BG_AV_NodePositions[i][1];
		BG_AV_Nodes[i].z=BG_AV_NodePositions[i][2];
		BG_AV_Nodes[i].a=BG_AV_NodePositions[i][3];
		BG_AV_Nodes[i].r0=BG_AV_NodePositions[i][4];
		BG_AV_Nodes[i].r1=BG_AV_NodePositions[i][5];
		BG_AV_Nodes[i].r2=BG_AV_NodePositions[i][6];
		BG_AV_Nodes[i].r3=BG_AV_NodePositions[i][7];

		for(uint8 k=0;k<5;k++)
			BG_AV_Nodes[i].GO_ids[k]=BG_AV_Node_GO[i][k];
		for(uint8 k=0;k<5;k++)
			BG_AV_Nodes[i].WStates[k]=BG_AV_Node_StateIcons[i][k];
	}

	return true;
}

void BattleGroundAV::AtEndBG(uint32 winner,Player* plr)
{
    uint32 faction = 0;
    uint32 rep = 0;
    rep =  rew.m_CaptainsAlive[plr->GetTeam()] * 125;
    rep += rew.m_CaptainsKilled[plr->GetTeam()] * 36;
    rep += rew.m_GraveYardsControlled[plr->GetTeam()] * 12;
    rep += rew.m_MinesControlled[plr->GetTeam()] * 12;
    rep += rew.m_TowersControlled[plr->GetTeam()] * 12;
    rep += rew.m_TowersDestroyed[plr->GetTeam()] * 24;

    faction = (plr->GetTeam() == ALLIANCE) ? faction=730 : faction=729;
    plr->ModifyFactionReputation(faction,rep);
}

const char* BattleGroundAV::_GetNodeName(uint8 node)
{
    switch (node)
    {
	case BG_AV_OBJECT_FIRSTAID_STATION: return "Stormpike Aid Station";
	case BG_AV_OBJECT_DUNBALDAR_SHOUTH: return "The Dun Baldar South Bunker";
	case BG_AV_OBJECT_DUNBALDAR_NORTH: return "The Dun Baldar North Bunker";
	case BG_AV_OBJECT_STORMPIKE_GRAVE: return "Stormpike Graveyard";
	case BG_AV_OBJECT_ICEWING_BUNKER: return "The Icewing Bunker";
	case BG_AV_OBJECT_STONEHEART_GRAVE: return "Stonehearth Graveyard";
	case BG_AV_OBJECT_STONEHEART_BUNKER: return "The Stonehearth Bunker";
	case BG_AV_OBJECT_SNOWFALL_GRAVE: return "Snowfall Graveyard";
	case BG_AV_OBJECT_ICEBLOOD_TOWER: return "Iceblood Tower";
	case BG_AV_OBJECT_ICEBLOOD_GRAVE: return "Iceblood Graveyard";
	case BG_AV_OBJECT_TOWER_POINT: return "Tower Point";
	case BG_AV_OBJECT_FROSTWOLF_GRAVE: return "Frostwolf Graveyard";
	case BG_AV_OBJECT_FROSTWOLF_ETOWER: return "The East Frostwolf Tower"; 
	case BG_AV_OBJECT_FROSTWOLF_WTOWER: return "The West Frostwolf Tower";
	case BG_AV_OBJECT_FROSTWOLF_HUT: return "Frostwolf Relief Hut";
    case BG_AV_OBJECT_IRONDEEP_MINE: return "Irondeep Mine";
    case BG_AV_OBJECT_COLDTOOTH_MINE: return "Coldtooth Mine";
        default:
            return "Unknown Node";
    }
    return "";
}

void BattleGroundAV::ResetBGSubclass()
{
	AScore=BG_AV_SCORE_INITIAL_POINTS;
	HScore=BG_AV_SCORE_INITIAL_POINTS;
}