GUILD_CRAP_EOCLIENT

###################Client recieves these from server#####################

////main packet when dealing with guilds 1st byte shows how to deal with reply
void guild_reply(void *my_void,PacketReader reader)
{
    Console::Out("guild reply");
    World *world(static_cast<World *>(my_void));

    int packet_length = reader.Remaining();
    GuildReply guild_reply = GUILD_NULL_REPLY;//null reply

    if(packet_length == 1)
    {
        guild_reply = static_cast<GuildReply>(reader.GetChar());
    }
    else
    {
        guild_reply = static_cast<GuildReply>(reader.GetShort());
    }

    switch(guild_reply)
    {
        case GUILD_CREATE_BEGIN:
        {
            //should possibly do a waitfor guild,request but it will get handled in its own function
        }
        break;

        case GUILD_CREATE_ADD_CONFIRM:
        {
            // i think this is when guild gets confirmed
            std::string char_name = reader.GetEndString(); // in first request this is a blank string if no members are rquired to create guild
        }
        break;

        case GUILD_NOT_APPROVED:
        {
            // thats it guild was not approved nothing else to process?
        }
        break;

        case GUILD_EXISTS:
        {
            // thats it guild already exists not approved nothing else to process?
        }
        break;

        case GUILD_CREATE_ADD:
        {

            std::string char_name = reader.GetEndString();
        }
        break;

        case GUILD_UPDATED:
        {

        }
        break;

        case GUILD_RANKS_UPDATED:
        {

        }
        break;

        case GUILD_JOIN_REQUEST:
        {
            int char_pid = reader.GetShort();
            std::string char_name = reader.GetEndString();
        }
        break;

        case GUILD_NOT_RECRUITER:
        {

        }
        break;

        case GUILD_RECRUITER_WRONG_GUILD:
        {

        }
        break;

        case GUILD_RECRUITER_NOT_HERE:
        {

        }
        break;

        case GUILD_RECRUITER_OFFLINE:
        {

        }
        break;

        case GUILD_ACCEPTED:
        {

        }
        break;

        case GUILD_ACCOUNT_LOW:
        {

        }
        break;

        case GUILD_NOT_FOUND:
        {

        }
        break;

        case GUILD_REMOVED:
        {

        }
        break;

        case GUILD_REMOVE_LEADER:
        {

        }
        break;

        case GUILD_REMOVE_NOT_MEMBER:
        {

        }
        break;

        case GUILD_RANKING_LEADER:
        {

        }
        break;

        case GUILD_RANKING_NOT_MEMBER:
        {

        }
        break;

        //Created this to initalize
        case GUILD_NULL_REPLY:
        //unhandled replies
        case GUILD_BUSY:
        case GUILD_ALREADY_MEMBER:
        case GUILD_NO_CANDIDATES:
        case GUILD_NOT_PRESENT:
        break;

    }


}

//invite sent to create
void guild_request(void *my_void,PacketReader reader)
{
    Console::Out("guild request");
    World *world(static_cast<World *>(my_void));

    int leader_pid = reader.GetShort();
    std::string guild_name_and_tag = reader.GetEndString();

}

void guild_take(void *my_void,PacketReader reader)
{
    Console::Out("guild take");
    World *world(static_cast<World *>(my_void));

    std::string description = reader.GetEndString();
}

//guild add member server to client
void guild_agree(void *my_void,PacketReader reader)
{
    Console::Out("guild agree");
    World *world(static_cast<World *>(my_void));

    int recruiter_pid = reader.GetShort();
    reader.GetByte();//255
    std::string tag = reader.GetBreakString();
    std::string guild_name = reader.GetBreakString();
    std::string guild_rank_string = reader.GetBreakString();
    reader.GetByte();//255

}

void guild_create(void *my_void,PacketReader reader)
{
    Console::Out("guild create");
    World *world(static_cast<World *>(my_void));

    int leader_pid = reader.GetShort();
    reader.GetByte();//255
    std::string guild_tag = reader.GetBreakString();
    std::string guild_name = reader.GetBreakString();
    std::string rank_str = reader.GetBreakString();
    int has_item = reader.GetInt();
}

void guild_rank(void *my_void,PacketReader reader)
{
    Console::Out("guild rank");
    World *world(static_cast<World *>(my_void));

    //need to figure this loop out i think total ranks is 9
    std::string ranks[9] = {""};
    for (std::size_t i = 0; i < 9; ++i)
    {
        ranks[i] = reader.GetBreakString();
    }
}

void guild_sell(void *my_void,PacketReader reader)
{
    Console::Out("guild sell");
    World *world(static_cast<World *>(my_void));

    int bank = reader.GetInt();
}

void guild_buy(void *my_void,PacketReader reader)
{
    Console::Out("guild buy");
    World *world(static_cast<World *>(my_void));

    int has_gold = reader.GetInt();
}

void guild_open(void *my_void,PacketReader reader)
{
    Console::Out("guild open");
    World *world(static_cast<World *>(my_void));

    int session = reader.GetThree(); // Session token
}

void guild_tell(void *my_void,PacketReader reader)
{
    Console::Out("guild tell");
    World *world(static_cast<World *>(my_void));

    int total_members = reader.GetShort();
    reader.GetByte();//255

    for(int i = 0; i < total_members;++i)
    {
        int rank = reader.GetChar(member->rank);
        reader.GetByte();//255
        std::string member_name = reader.GetBreakString();
        std::string rank_str = reader.GetBreakString();
    }
}

void guild_report(void *my_void,PacketReader reader)
{
    Console::Out("guild report");
    World *world(static_cast<World *>(my_void));

    std::string guild_name = reader.GetBreakString();
    std::string guild_tag = reader.GetBreakString();
    std::string create_date = reader.GetBreakString();
    std::string guild_description = reader.GetBreakString();
    std::string bank_str = reader.GetBreakString();

    // i think rank size is 9
    std::string rank[9] = {""};
    for (std::size_t i = 0; i < 9; ++i)
    {
       rank[i] = reader.GetBreakString();
    }

    //2 loops leaders and recruiters recieved here
    int leaders_recruiters = reader.GetShort();
    reader.GetByte();//255

    //leader loop first
    //for(int i = 0; i < leaders_recruiters;++i)
    while(reader.Remaining() > 0)
    {
        int response = reader.GetChar();
        reader.GetByte();//255

        switch(response)
        {
            case 1:
            {
                std::string leader_info = reader.GetBreakString();
                //leader data need to create container leaders.pushback()
            }
            break;

            case 2:
            {
                //recruiter data
                 std::string recruiter_name = reader.GetBreakString();
            }
            break;
        }
    }
}


###################Client sends these to server#####################
// Requested to create a guild
void Character::GuildRequest(int session,std::string tag,std::string name)
{
    PacketBuilder packet(PACKET_GUILD,PACKET_REQUEST);
    packet.AddInt(session);
    packet.AddByte(1); //need to se what byte is sent from original client to server
    packet.AddBreakString(tag);
    packet.AddBreakString(name);
    this->world->net_->Send(packet);
}

// Accept guild create invite
void Character::GuildAccept()
{
    PacketBuilder packet(PACKET_GUILD,PACKET_ACCEPT);
    packet.AddByte(1); //need to se what byte is sent from original client to server
    this->world->net_->Send(packet);
}

// Left the guild
void Character::GuildRemove()
{
    PacketBuilder packet(PACKET_GUILD,PACKET_REMOVE);
    packet.AddInt(1); //need to se what byte is sent from original client to server
    this->world->net_->Send(packet);
}

// Update guild rank list
void Character::GuildAgree(int session,GuildInfoType info)
{
    PacketBuilder packet(PACKET_GUILD,PACKET_AGREE);
    packet.AddInt(session);
    packet.AddShort((short)info);
    this->world->net_->Send(packet);

}

// Creating a guild
void Character::GuildCreate(int session,std::string tag,std::string name,std::string description)
{
    PacketBuilder packet(PACKET_GUILD,PACKET_CREATE);
    packet.AddInt(session);
    packet.AddByte(1); //need to se what byte is sent from original client to server
    packet.AddBreakString(tag);
    packet.AddBreakString(name);
    packet.AddBreakString(description);
    this->world->net_->Send(packet);
}

// Requested to join a guild
void Character::GuildPlayer(int session,std::string tag,std::string recruiter_name)
{
    PacketBuilder packet(PACKET_GUILD,PACKET_PLAYER);
    packet.AddInt(session);
    packet.AddByte(1); //need to se what byte is sent from original client to server
    packet.AddBreakString(tag);
    packet.AddBreakString(recruiter_name);
    this->world->net_->Send(packet);
}

// Requested guild bank/rank list/description
void Character::GuildTake(int session,GuildInfoType info)
{
    PacketBuilder packet(PACKET_GUILD,PACKET_TAKE);
    packet.AddInt(session);
    packet.AddShort((short)info);
    this->world->net_->Send(packet);
}

// Accepted a join request
void Character::GuildUse()
{
    PacketBuilder packet(PACKET_GUILD,PACKET_USE);
    packet.AddShort(this->player_id);
    this->world->net_->Send(packet);

}

// Deposit gold to the guild bank
void Character::GuildBuy(int session,unsigned int gold)
{
    PacketBuilder packet(PACKET_GUILD,PACKET_BUY);
    packet.AddInt(session);
    packet.AddInt(gold);
    this->world->net_->Send(packet);


}

// Talked to a guild NPC
void Character::GuildOpen(int npc_index )
{
    PacketBuilder packet(PACKET_GUILD,PACKET_OPEN);
    packet.AddShort(npc_index);
    this->world->net_->Send(packet);
}

// Requested member list of a guild
void Character::GuildTell(int session,std::string tag)
{
    PacketBuilder packet(PACKET_GUILD,PACKET_TELL);
    packet.AddInt(session);
    packet.AddBreakString(tag);
    this->world->net_->Send(packet);
}

// Requested information on a guild
void Character::GuildReport(int session,std::string tag)
{
    PacketBuilder packet(PACKET_GUILD,PACKET_REPORT);
    packet.AddInt(session);
    packet.AddBreakString(tag);
    this->world->net_->Send(packet);
}

// Disband guild
void Character::GuildJunk(int session,std::string tag)
{
    PacketBuilder packet(PACKET_GUILD,PACKET_JUNK);
    packet.AddInt(session);
    this->world->net_->Send(packet);
}

//remove member
void Character::GuildKick(int session,std::string name)
{
    PacketBuilder packet(PACKET_GUILD,PACKET_KICK);
    packet.AddInt(session);
    packet.AddBreakString(name);
    this->world->net_->Send(packet);
}

// Set a member's rank
void Character::GuildRank(int session,int rank,std::string name)
{
    PacketBuilder packet(PACKET_GUILD,PACKET_KICK);
    packet.AddInt(session);
    packet.AddChar(rank);
    packet.AddBreakString(name);
    this->world->net_->Send(packet);
}