/***************************************************************************
 *   Copyright (C) 2005 by yunfan                                          *
 *   yunfan_zg@163.com                                                     *
 *                                                                         *
 *   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 "evagroup.h"
#include "evadefines.h"
#include <stdio.h>
#include <arpa/inet.h>

GroupNameOpPacket::GroupNameOpPacket( )
	: OutPacket(QQ_CMD_GROUP_NAME_OP, true),
	type(QQ_UPLOAD_GROUP_NAME)
{
} 

GroupNameOpPacket::GroupNameOpPacket(const char cmdType)
	: OutPacket(QQ_CMD_GROUP_NAME_OP, true),
	type(cmdType)
{
}

GroupNameOpPacket::GroupNameOpPacket(const GroupNameOpPacket &rhs)
	: OutPacket(rhs)
{
	groups = rhs.getGroups();
	type = rhs.getType();
}

GroupNameOpPacket &GroupNameOpPacket::operator=(const GroupNameOpPacket &rhs)
{
	*((OutPacket*)this) = (OutPacket)rhs;
	groups = rhs.getGroups();
	type = rhs.getType();
	return *this;
}

int GroupNameOpPacket::putBody( unsigned char * buf )
{
    int pos = 0;
    buf[pos++] = type;
    if(type == QQ_UPLOAD_GROUP_NAME) {
            unsigned char groupIndex = 0x00;
	    std::list<std::string>::iterator iter = groups.begin();
	    for(++iter; iter != groups.end(); ++iter){  // we should ignore the first group name(default fixed string)
                    buf[pos++]=(unsigned char)(++groupIndex);
                    if(iter->length() > (uint)QQ_MAX_GROUP_NAME_BYTE){
                            memcpy(buf+pos, iter->c_str(), QQ_MAX_GROUP_NAME_BYTE);					
                            pos+=QQ_MAX_GROUP_NAME_BYTE;
                    }else {
                            memcpy(buf+pos, iter->c_str(), iter->length());
                            pos+=iter->length();
                            int j = QQ_MAX_GROUP_NAME_BYTE - iter->length();
                            while(j-- > 0)
                                    buf[pos++]=0x00;
                    }
            }
    } else {
            buf[pos++]=0x02;
            bzero(buf+pos,4);
            pos+=4;
    }
    return pos;
}

/* =========================================================== */

GroupNameOpReplyPacket::GroupNameOpReplyPacket(unsigned char* buf, int len)
	: InPacket(buf, len),
	type(QQ_DOWNLOAD_GROUP_NAME)
{
}

GroupNameOpReplyPacket::GroupNameOpReplyPacket(const GroupNameOpReplyPacket &rhs)
	: InPacket(rhs)
{
	type = rhs.getType();
	groupNames = rhs.getGroupNames();
}

GroupNameOpReplyPacket &GroupNameOpReplyPacket::operator=( const GroupNameOpReplyPacket &rhs )
{
	*((InPacket *)this) = (InPacket)rhs;
	type = rhs.getType();
	groupNames = rhs.getGroupNames();
	return *this;	
}

void GroupNameOpReplyPacket::parseBody()
{
	groupNames.clear();	
	type = decryptedBuf[0];
	if(type == QQ_DOWNLOAD_GROUP_NAME) {
		int offset=7;
		while(bodyLength>offset) {
			std::string name((char*)(decryptedBuf+offset));
			groupNames.push_back(name);
			offset += 17;
		}
	}
}

const bool GroupNameOpReplyPacket::isDownloadReply() const 
{ 
	return type == QQ_DOWNLOAD_GROUP_NAME; 
} 

/* =========================================================== */

DownloadFriendEntry::DownloadFriendEntry(const char *buf)
{
	readData(buf);
}

DownloadFriendEntry::DownloadFriendEntry(const DownloadFriendEntry &rhs)
{
	*this = rhs;
}

DownloadFriendEntry &DownloadFriendEntry::operator=(const DownloadFriendEntry &rhs)
{
	qqNum = rhs.getQQ();
	type = rhs.getType();
	groupID = rhs.getGroupID();
	return *this;	
}

const int DownloadFriendEntry::readData(const char *buf)
{
	int tmp4;
	memcpy(&tmp4, buf, 4);  
	qqNum = ntohl(tmp4);
	type = buf[4];
	groupID = ( buf[5] >> 2) & 0x3f;  
	return 6;
}

const bool DownloadFriendEntry::isQun() const
{
	return type == QQ_ID_IS_CLUSTER;
}

/* =========================================================== */

DownloadGroupFriendPacket::DownloadGroupFriendPacket()
	: OutPacket(QQ_CMD_DOWNLOAD_GROUP_FRIEND, true),
	startID(0)
{
}

DownloadGroupFriendPacket::DownloadGroupFriendPacket(const int start)
	: OutPacket(QQ_CMD_DOWNLOAD_GROUP_FRIEND, true),
	startID(start)
{
}

DownloadGroupFriendPacket::DownloadGroupFriendPacket(const DownloadGroupFriendPacket &rhs)
	: OutPacket(rhs)
{
	startID = rhs.getStartID();
}

DownloadGroupFriendPacket &DownloadGroupFriendPacket::operator=(const DownloadGroupFriendPacket &rhs)
{
	*( (OutPacket *)this) = (OutPacket)rhs;
	startID = rhs.getStartID();
	return *this;
}

int DownloadGroupFriendPacket::putBody(unsigned char* buf)
{
	buf[0]=0x01;
	buf[1]=0x02;
	bzero(buf+2,4); 
	int tmp4 = htonl(startID);
	memcpy(buf+6, &tmp4, 4);
	return 10;
}

/* =========================================================== */

DownloadGroupFriendReplyPacket::DownloadGroupFriendReplyPacket(unsigned char* buf, int len)
	: InPacket(buf, len)
{	
}

DownloadGroupFriendReplyPacket::DownloadGroupFriendReplyPacket( const DownloadGroupFriendReplyPacket &rhs)
	: InPacket(rhs)
{
	nextStartID = rhs.getNextStartID();
	friends = rhs.getGroupedFriends();
}

DownloadGroupFriendReplyPacket &DownloadGroupFriendReplyPacket::operator=( const DownloadGroupFriendReplyPacket &rhs)
{
	*((InPacket *)this) = (InPacket)rhs;
	nextStartID = rhs.getNextStartID();
	friends = rhs.getGroupedFriends();
	return *this;
}

void DownloadGroupFriendReplyPacket::parseBody()
{
	friends.clear();
	int offset = 6;
	int tmp4;
	memcpy(&tmp4, decryptedBuf +offset, 4);
	offset+=4;
	nextStartID = ntohl(tmp4);
	while(bodyLength>offset) {
		DownloadFriendEntry f((char *)(decryptedBuf+offset));
		friends.push_back(f);	
		offset+=f.numberOfBytesRead();      
	}
}

/* =========================================================== */

UploadGroupFriendPacket::UploadGroupFriendPacket()
	: OutPacket(QQ_CMD_UPLOAD_GROUP_FRIEND, true)
{
}

UploadGroupFriendPacket::UploadGroupFriendPacket(const UploadGroupFriendPacket &rhs)
	: OutPacket(rhs)
{
	privateList = rhs.getGroupedFriends();
}

UploadGroupFriendPacket::~UploadGroupFriendPacket()
{
}

UploadGroupFriendPacket &UploadGroupFriendPacket::operator=( const UploadGroupFriendPacket &rhs)
{
	*( (OutPacket *)this) = (OutPacket)rhs;
	privateList = rhs.getGroupedFriends();
	return *this;
}

int UploadGroupFriendPacket::putBody(unsigned char* buf)
{
        std::map<int, int>::iterator iter;
	int tmp4;
	int pos = 0;
	for(iter =privateList.begin(); iter != privateList.end(); ++iter){
		tmp4 = htonl(iter->first);
		memcpy(buf+pos, &tmp4, 4);
		pos+=4;
		buf[pos++] = (unsigned char)(iter->second);
	}
	return pos;
}

/* =========================================================== */

UploadGroupFriendReplyPacket::UploadGroupFriendReplyPacket(unsigned char* buf, int len)
	: InPacket(buf, len)
{
}

UploadGroupFriendReplyPacket::UploadGroupFriendReplyPacket(const UploadGroupFriendReplyPacket &rhs)
	: InPacket(rhs)
{
	replyCode = rhs.getReplyCode();
}

UploadGroupFriendReplyPacket::~UploadGroupFriendReplyPacket()
{
}

UploadGroupFriendReplyPacket &UploadGroupFriendReplyPacket::operator=(const UploadGroupFriendReplyPacket &rhs)
{
	*((InPacket *)this) = (InPacket)rhs;
	replyCode = rhs.getReplyCode();
	return *this;
}

void UploadGroupFriendReplyPacket::parseBody()
{
	replyCode = decryptedBuf[0];
}








