#include "StdAfx.h"
#ifdef ENABLE_IKASHOP_RENEWAL
#include "PythonNetworkStream.h"
#include "Packet.h"
#include "PythonIkarusShop.h"

bool CPythonNetworkStream::RecvOfflineshopPacket()
{
	TPacketGCNewOfflineshop pack;
	if(!Recv(sizeof(pack), &pack))
		return false;

	switch (pack.subheader)
	{
		case ikashop::SUBHEADER_GC_SHOP_OPEN:
			return RecvOfflineshopShopOpen();

		case ikashop::SUBHEADER_GC_SHOP_OPEN_OWNER:
			return RecvOfflineshopShopOpenOwner();

		case ikashop::SUBHEADER_GC_SHOP_OPEN_OWNER_NO_SHOP:
			return RecvOfflineshopShopOpenOwnerNoShop();

		case ikashop::SUBHEADER_GC_SHOP_EXPIRED_GUESTING:
			return RecvOfflineshopShopExpiredGuesting();

		case ikashop::SUBHEADER_GC_SHOP_REMOVE_ITEM_OWNER:
			return RecvOfflineshopShopRemoveItem(true);

		case ikashop::SUBHEADER_GC_SHOP_REMOVE_ITEM_GUEST:
			return RecvOfflineshopShopRemoveItem(false);

		case ikashop::SUBHEADER_GC_SHOP_EDIT_ITEM_GUEST:
			return RecvOfflineshopShopGuestEditItem();

		case ikashop::SUBHEADER_GC_SHOP_EDIT_ITEM_OWNER:
			return RecvOfflineshopShopOwnerEditItem();

		case ikashop::SUBHEADER_GC_SHOP_FILTER_RESULT:
			return RecvOfflineshopShopFilterResult();

		case ikashop::SUBHEADER_GC_OFFER_LIST:
			return RecvOfflineshopOfferList();

		case ikashop::SUBHEADER_GC_SHOP_SAFEBOX_REFRESH:
			return RecvOfflineshopShopSafeboxRefresh();

		case ikashop::SUBHEADER_GC_SHOP_SAFEBOX_REMOVE_ITEM:
			return RecvOfflineshopShopSafeboxRemoveItem();

		case ikashop::SUBHEADER_GC_SHOP_SAFEBOX_ADD_ITEM:
			return RecvOfflineshopShopSafeboxAddItem();

		case ikashop::SUBHEADER_GC_AUCTION_LIST:
			return RecvOfflineshopAuctionList();

		case ikashop::SUBHEADER_GC_OPEN_MY_AUCTION:
			return RecvOfflineshopOpenMyAuction();

		case ikashop::SUBHEADER_GC_OPEN_MY_AUCTION_NO_AUCTION:
			return RecvOfflineshopOpenMyAuctionNoAuction();

		case ikashop::SUBHEADER_GC_OPEN_AUCTION:
			return RecvOfflineshopOpenAuction();

		case ikashop::SUBHEDAER_GC_POPUP_MESSAGE:
			return RecvOfflineshopPopupMessage();

#ifdef ENABLE_IKASHOP_ENTITIES
		case ikashop::SUBHEADER_GC_INSERT_SHOP_ENTITY:
			return RecvOfflineshopInsertEntity();

		case ikashop::SUBHEADER_GC_REMOVE_SHOP_ENTITY:
			return RecvOfflineshopRemoveEntity();
#endif

		case ikashop::SUBHEADER_GC_BOARD_COUNTERS:
			return RecvOfflineshopBoardCounters();

#ifdef EXTEND_IKASHOP_PRO
		case ikashop::SUBHEADER_GC_NOTIFICATION_LIST:
			return RecvOfflineshopNotificationList();
#endif
#ifdef EXTEND_IKASHOP_ULTIMATE
		case ikashop::SUBHEADER_GC_PRICE_AVERAGE_RESPONSE:
			return RecvOfflineshopPriceAverageResponse();
#endif

		case ikashop::SUBHEADER_GC_SEARCH_RESULT_DELETE:
			return RecvOfflineshopSearchResultDelete();

		default:
			TraceError("UNKNOWN OFFLINESHOP SUBHEADER : %d ",pack.subheader);
			return false;
	}
}

bool CPythonNetworkStream::RecvOfflineshopShopOpen()
{
	ikashop::TSubPacketGCShopOpen subpack;
	if(!Recv(sizeof(subpack) , &subpack))
		return false;

#ifdef EXTEND_IKASHOP_ULTIMATE
	std::vector<ikashop::TShopItemView> items;
#else
	std::vector<ikashop::TShopItem> items;
#endif

	items.resize(subpack.shop.count);
	if(subpack.shop.count > 0)
		if(!Recv(sizeof(items[0])*items.size(), items.data()))
			return false;

	CPythonIkarusShop::Instance().OpenShop(subpack.shop, items);
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopShopOpenOwner()
{
	ikashop::TSubPacketGCShopOpenOwner subpack;
	if(!Recv(sizeof(subpack) , &subpack))
		return false;

#ifdef EXTEND_IKASHOP_ULTIMATE
	std::vector<ikashop::TShopItemView> items;
#else
	std::vector<ikashop::TShopItem> items;
#endif
	items.resize(subpack.shop.count);
	
	if(subpack.shop.count!=0)
		if(!Recv(sizeof(items[0]) * subpack.shop.count, items.data()))
			return false;

	CPythonIkarusShop::Instance().OpenShopOwner(subpack.shop, items);
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopShopOpenOwnerNoShop()
{
	CPythonIkarusShop::instance().OpenShopOwnerNoShop();
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopShopExpiredGuesting()
{
	ikashop::TSubPacketGCShopExpiredGuesting subpack;
	if(!Recv(sizeof(subpack), &subpack))
		return false;

	CPythonIkarusShop::instance().ShopExpiredGuesting(subpack.ownerid);
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopShopRemoveItem(bool owner)
{
	ikashop::TSubPacketGCShopRemoveItem subpack;
	if(!Recv(sizeof(subpack), &subpack))
		return false;

	CPythonIkarusShop::instance().ShopRemoveItem(owner, subpack.itemid);
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopShopGuestEditItem()
{
	ikashop::TSubPacketGCShopEditItem subpack;
	if (!Recv(sizeof(subpack), &subpack))
		return false;

	CPythonIkarusShop::instance().ShopGuestEditItem(subpack.itemid, subpack.price);
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopShopOwnerEditItem()
{
	ikashop::TSubPacketGCShopEditItem subpack;
	if (!Recv(sizeof(subpack), &subpack))
		return false;

	CPythonIkarusShop::instance().ShopOwnerEditItem(subpack.itemid, subpack.price);
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopShopFilterResult()
{
	ikashop::TSubPacketGCShopFilterResult subpack;
	if(!Recv(sizeof(subpack) , &subpack))
		return false;

	std::vector<ikashop::TSearchResultInfo> items(static_cast<size_t>(subpack.count));
	if(subpack.count != 0)
		if(!Recv(items.size() * sizeof(items[0]), items.data()))
			return false;

	CPythonIkarusShop::Instance().ShopFilterResult(items);
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopOfferList() //offlineshop-updated 03/08/19
{
	ikashop::TSubPacketGCShopOfferList subpack;
	if(!Recv(sizeof(subpack) , &subpack))
		return false;

	
	std::vector<ikashop::TOfferListElement> vec;
	vec.resize(subpack.offercount);

	if (subpack.offercount != 0)
		if (!Recv(sizeof(ikashop::TOfferListElement)*subpack.offercount, &vec[0]))
			return false;

	CPythonIkarusShop::instance().OfferListReceived(vec);
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopShopSafeboxRefresh()
{
	ikashop::TSubPacketGCShopSafeboxRefresh subpack;
	if(!Recv(sizeof(subpack), &subpack))
		return false;

	std::vector<ikashop::TShopPlayerItem> items;
	items.resize(subpack.itemcount);

	if(subpack.itemcount != 0)
		if (!Recv(sizeof(ikashop::TShopPlayerItem) * items.size(), &items[0]))
			return false;

	CPythonIkarusShop::instance().SafeboxRefresh(subpack.valute, items);
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopShopSafeboxRemoveItem()
{
	ikashop::TSubPacketGCShopSafeboxRemoveItem subpack{};
	if(!Recv(sizeof(subpack), &subpack))
		return false;

	CPythonIkarusShop::instance().SafeboxRemoveItem(subpack.itemid);
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopShopSafeboxAddItem()
{
	ikashop::TSubPacketGCShoppingSafeboxAddItem subpack{};
	if (!Recv(sizeof(subpack), &subpack))
		return false;

	CPythonIkarusShop::instance().SafeboxAddItem(subpack.item);
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopAuctionList()
{
	ikashop::TSubPacketGCAuctionList subpack;
	if(!Recv(sizeof(subpack) , &subpack))
		return false;

	std::vector<ikashop::TAuctionListElement> vector;
	vector.resize(subpack.count);

	if(subpack.count!=0)
		if(!Recv(sizeof(vector[0]) * vector.size(), &vector[0]))
			return false;

	CPythonIkarusShop::instance().AuctionList(vector);
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopOpenMyAuction()
{
	ikashop::TSubPacketGCAuctionOpen subpack;
	if(!Recv(sizeof(subpack) , &subpack))
		return false;

	std::vector<ikashop::TAuctionOfferInfo> offers;
	offers.resize(subpack.offercount);

	if(subpack.offercount!= 0)
		if(!Recv(sizeof(offers[0]) * offers.size() , &offers[0]))
			return false;
#ifdef EXTEND_IKASHOP_ULTIMATE
	CPythonIkarusShop::instance().MyAuctionOpen(subpack.auction, offers, subpack.priceavg);
#else
	CPythonIkarusShop::instance().MyAuctionOpen(subpack.auction, offers);
#endif
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopOpenMyAuctionNoAuction()
{
	CPythonIkarusShop::instance().OpenMyAuctionNoAuction();
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopOpenAuction()
{
	ikashop::TSubPacketGCAuctionOpen subpack;
	if(!Recv(sizeof(subpack) , &subpack))
		return false;

	std::vector<ikashop::TAuctionOfferInfo> offers;
	offers.resize(subpack.offercount);

	if(subpack.offercount!= 0)
		if(!Recv(sizeof(offers[0]) * offers.size() , &offers[0]))
			return false;

#ifdef EXTEND_IKASHOP_ULTIMATE
	CPythonIkarusShop::instance().AuctionOpen(subpack.auction, offers, subpack.priceavg);
#else
	CPythonIkarusShop::instance().AuctionOpen(subpack.auction, offers);
#endif
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopPopupMessage()
{
	// receiving string
	ikashop::TSubPacketGCPopupMessage pack;
	if (!Recv(sizeof(pack), &pack))
		return false;

	// safely terminating string
	pack.localeString[pack.MESSAGE_LEN-1] = 0;

	CPythonIkarusShop::instance().PopupMessage(pack.localeString);
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopSearchResultDelete()
{
	// getting itemid
	DWORD itemid = 0;
	if (!Recv(sizeof(itemid), &itemid))
		return false;

	CPythonIkarusShop::instance().DeleteSearchResult(itemid);
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopBoardCounters()
{
	ikashop::TSubPacketGCBoardCounters subpack;
	if (!Recv(sizeof(subpack), &subpack))
		return false;

#ifdef EXTEND_IKASHOP_PRO
	CPythonIkarusShop::Instance().RefreshBoardCounters(subpack.safebox, subpack.auction, subpack.offers, subpack.notification);
#else
	CPythonIkarusShop::Instance().RefreshBoardCounters(subpack.safebox, subpack.auction, subpack.offers);
#endif
	return true;
}

#ifdef EXTEND_IKASHOP_PRO
bool CPythonNetworkStream::RecvOfflineshopNotificationList()
{
	ikashop::TSubPacketGCNotificationList subpack;
	if (!Recv(sizeof(subpack), &subpack))
		return false;

	std::vector<ikashop::TNotificationInfo> notifications;
	notifications.resize(subpack.count);

	if(subpack.count != 0)
		if(!Recv(notifications.size() * sizeof(ikashop::TNotificationInfo), notifications.data()))
			return false;

	CPythonIkarusShop::Instance().SetNotificationList(notifications);
	return true;
}
#endif

#ifdef EXTEND_IKASHOP_ULTIMATE
bool CPythonNetworkStream::RecvOfflineshopPriceAverageResponse()
{
	long long average = 0;
	if(!Recv(sizeof(average), &average))
		return false;

	CPythonIkarusShop::instance().PriceAverageResponse(average);
	return true;
}
#endif

#ifdef ENABLE_IKASHOP_ENTITIES
bool CPythonNetworkStream::RecvOfflineshopInsertEntity()
{
	ikashop::TSubPacketGCInsertShopEntity subpack;
	if(!Recv(sizeof(subpack) , &subpack))
		return false;

	CPythonIkarusShop::Instance().InsertEntity(subpack.vid, subpack.type, subpack.name, subpack.x, subpack.y, subpack.z);
	return true;
}

bool CPythonNetworkStream::RecvOfflineshopRemoveEntity()
{
	ikashop::TSubPacketGCRemoveShopEntity subpack;
	if(!Recv(sizeof(subpack) , &subpack))
		return false;

	CPythonIkarusShop::Instance().RemoveEntity(subpack.vid);
	return true;
}

void CPythonNetworkStream::SendIkarusShopOnClickShopEntity(DWORD dwPickedShopVID)
{
	TPacketCGNewOfflineShop pack;
	pack.header = HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_CLICK_ENTITY;
	pack.size = sizeof(pack) + sizeof(ikashop::TSubPacketCGShopClickEntity);

	ikashop::TSubPacketCGShopClickEntity subpack;
	subpack.vid = dwPickedShopVID;

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}

	if(!Send(subpack))
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - subpack ", pack.subheader);
}

#ifdef EXTEND_IKASHOP_PRO
void CPythonNetworkStream::SendIkarusShopMoveShopEntity()
{
	TPacketCGNewOfflineShop pack;
	pack.header = HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_MOVE_SHOP_ENTITY;
	pack.size = sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack", pack.subheader);
		return;
	}
}
#endif
#endif

void CPythonNetworkStream::SendIkarusShopCreateShop()
{
	TPacketCGNewOfflineShop pack{};
	pack.header = HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_SHOP_CREATE_NEW;
	pack.size = sizeof(pack);

	if (!Send(pack))
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack", pack.subheader);
}

void CPythonNetworkStream::SendIkarusShopForceCloseShop()
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_SHOP_FORCE_CLOSE;
	pack.size		= sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopRequestShopList()
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_SHOP_REQUEST_SHOPLIST;
	pack.size		= sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopOpenShop(DWORD dwOwnerID)
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_SHOP_OPEN;
	pack.size		= sizeof(pack) + sizeof(ikashop::TSubPacketCGShopOpen);

	ikashop::TSubPacketCGShopOpen subpack;
	subpack.ownerid = dwOwnerID;

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}

	if(!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - subpack ",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopOpenShopOwner()
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_SHOP_OPEN_OWNER;
	pack.size		= sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}
}


void CPythonNetworkStream::SendIkarusShopBuyItem(DWORD dwOwnerID, DWORD dwItemID, bool isSearch, long long TotalPriceSeen) //patch seen price check
{
	TPacketCGNewOfflineShop pack;
	pack.header = HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_SHOP_BUY_ITEM;
	pack.size = sizeof(pack) + sizeof(ikashop::TSubPacketCGShopBuyItem);

	ikashop::TSubPacketCGShopBuyItem subpack;
	subpack.itemid = dwItemID;
	subpack.ownerid = dwOwnerID;
	subpack.searching = isSearch;

	//patch seen price check
	subpack.seenprice = TotalPriceSeen;

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack", pack.subheader);
		return;
	}

	if (!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - subpack ", pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopAddItem(ikashop::TShopItemInfo& itemInfo)
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_SHOP_ADD_ITEM;
	pack.size = sizeof(pack) + sizeof(ikashop::TSubPacketCGAddItem);

	ikashop::TSubPacketCGAddItem subpack;
	subpack.pos = itemInfo.pos;
	subpack.price = itemInfo.price;
	subpack.destpos = itemInfo.destpos;

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}

	if(!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - subpack ",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopRemoveItem(DWORD dwItemID)
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_SHOP_REMOVE_ITEM;
	pack.size		= sizeof(pack) + sizeof(ikashop::TSubPacketCGRemoveItem);

	ikashop::TSubPacketCGRemoveItem subpack;
	subpack.itemid	= dwItemID;

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}

	if(!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - subpack ",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendOfflineShopEditItem(DWORD dwItemID, const ikashop::TPriceInfo& price)
{
	TPacketCGNewOfflineShop pack;
	pack.header = HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_SHOP_EDIT_ITEM;
	pack.size = sizeof(pack) + sizeof(ikashop::TSubPacketCGEditItem);

	ikashop::TSubPacketCGEditItem subpack;
	subpack.itemid = dwItemID;
	subpack.price = price;

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}

	if(!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - subpack ",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopFilterRequest(const ikashop::TFilterInfo& filter)
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_SHOP_FILTER_REQUEST;
	pack.size		= sizeof(pack) + sizeof(ikashop::TSubPacketCGFilterRequest);

	ikashop::TSubPacketCGFilterRequest subpack;
	subpack.filter = filter;

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}

	if(!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - subpack ",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopSearchFillRequest()
{
	TPacketCGNewOfflineShop pack;
	pack.header = HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_SHOP_SEARCH_FILL_REQUEST;
	pack.size = sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack", pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopOfferCreate(const ikashop::TOfferInfo& offer)
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_SHOP_OFFER_CREATE;
	pack.size		= sizeof(pack) + sizeof(ikashop::TSubPacketCGOfferCreate);

	ikashop::TSubPacketCGOfferCreate subpack;
	subpack.offer = offer;

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}

	if(!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - subpack ",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopOfferAccept(DWORD dwOfferID)
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_SHOP_OFFER_ACCEPT;
	pack.size		= sizeof(pack) + sizeof(ikashop::TSubPacketCGOfferAccept);

	ikashop::TSubPacketCGOfferAccept subpack;
	subpack.offerid	= dwOfferID;

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}

	if(!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - subpack ",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopOfferCancel(DWORD dwOfferID, DWORD dwOwnerID)
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_SHOP_OFFER_CANCEL;
	pack.size		= sizeof(pack) + sizeof(ikashop::TSubPacketCGOfferCancel);

	ikashop::TSubPacketCGOfferCancel subpack;
	subpack.offerid	= dwOfferID;
	subpack.ownerid	= dwOwnerID;

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}

	if(!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - subpack ",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopOfferListRequest()
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_SHOP_REQUEST_OFFER_LIST;
	pack.size = sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopSafeboxOpen()
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_SHOP_SAFEBOX_OPEN;
	pack.size		= sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopSafeboxGetItem(DWORD dwItemID)
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_SHOP_SAFEBOX_GET_ITEM;
	pack.size = sizeof(pack) + sizeof(ikashop::TSubPacketCGShopSafeboxGetItem);

	ikashop::TSubPacketCGShopSafeboxGetItem subpack;
	subpack.itemid = dwItemID;

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}

	if(!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - subpack ",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopSafeboxGetValutes()
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_SHOP_SAFEBOX_GET_VALUTES;
	pack.size = sizeof(pack);

	if (!Send(pack))
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
}

void CPythonNetworkStream::SendIkarusShopSafeboxClose()
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_SHOP_SAFEBOX_CLOSE;
	pack.size		= sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopAuctionListRequest()
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_AUCTION_LIST_REQUEST;
	pack.size		= sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopAuctionOpen(DWORD dwOwnerID)
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_AUCTION_OPEN_REQUEST;
	pack.size		= sizeof(pack) + sizeof(ikashop::TSubPacketCGAuctionOpenRequest);

	ikashop::TSubPacketCGAuctionOpenRequest subpack;
	subpack.ownerid = dwOwnerID;


	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}
	
	if (!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - subpack",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopAuctionAddOffer(DWORD dwOwnerID, const ikashop::TPriceInfo& price)
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_AUCTION_ADD_OFFER;
	pack.size		= sizeof(pack) + sizeof(ikashop::TSubPacketCGAuctionAddOffer);

	ikashop::TSubPacketCGAuctionAddOffer subpack;
	subpack.ownerid = dwOwnerID;
	subpack.price = price;

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}

	if (!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - subpack",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopAuctionExitFrom(DWORD dwOwnerID)
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_EXIT_FROM_AUCTION;
	pack.size = sizeof(pack) + sizeof(ikashop::TSubPacketCGAuctionExitFrom);

	ikashop::TSubPacketCGAuctionExitFrom subpack;
	subpack.ownerid = dwOwnerID;
	
	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}

	if (!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - subpack",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopAuctionCreate(const TItemPos& pos, const ikashop::TPriceInfo& price)
{
	TPacketCGNewOfflineShop pack;
	pack.header = HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader	= ikashop::SUBHEADER_CG_CREATE_AUCTION;
	pack.size = sizeof(pack) + sizeof(ikashop::TSubPacketCGAuctionCreate);

	ikashop::TSubPacketCGAuctionCreate subpack;
	subpack.pos = pos;
	subpack.startprice = price;

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}

	if (!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - subpack",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopMyAuctionOpen()
{
	TPacketCGNewOfflineShop pack{};
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_MY_AUCTION_OPEN_REQUEST;
	pack.size = sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopMyAuctionClose()
{
	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_MY_AUCTION_CLOSE;
	pack.size = sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusShopMyAuctionCancel()
{
	TPacketCGNewOfflineShop pack;
	pack.header = HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_MY_AUCTION_CANCEL;
	pack.size = sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack", pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusMyShopCloseBoard()
{
	if(m_strPhase != "Game")
		return;

	TPacketCGNewOfflineShop pack;
	pack.header	= HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_CLOSE_MY_SHOP_BOARD;
	pack.size = sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack",pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusOffersListClose()
{
	if (m_strPhase != "Game")
		return;

	TPacketCGNewOfflineShop pack;
	pack.header = HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_CLOSE_OFFER_LIST;
	pack.size = sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack", pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusCloseShopGuestBoard()
{
	if (m_strPhase != "Game")
		return;

	TPacketCGNewOfflineShop pack;
	pack.header = HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_CLOSE_SHOP_GUEST;
	pack.size = sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack", pack.subheader);
		return;
	}
}

#ifdef EXTEND_IKASHOP_PRO
void CPythonNetworkStream::SendIkarusNotificationListRequest()
{
	TPacketCGNewOfflineShop pack;
	pack.header = HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_NOTIFICATION_LIST_REQUEST;
	pack.size = sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack", pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendIkarusNotificationListClose()
{
	TPacketCGNewOfflineShop pack;
	pack.header = HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_NOTIFICATION_LIST_CLOSE;
	pack.size = sizeof(pack);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack", pack.subheader);
		return;
	}
}
#endif

#ifdef EXTEND_IKASHOP_ULTIMATE
void CPythonNetworkStream::SendPriceAverageRequest(DWORD vnum, DWORD count)
{
	TPacketCGNewOfflineShop pack;
	pack.header = HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_PRICE_AVERAGE_REQUEST;
	pack.size = sizeof(pack) + sizeof(ikashop::TSubPacketCGPriceAverageRequest);

	ikashop::TSubPacketCGPriceAverageRequest subpack{};
	subpack.vnum = vnum;
	subpack.count = count;

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack", pack.subheader);
		return;
	}

	if (!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack", pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendShopDecorationUsage(int index)
{
	TPacketCGNewOfflineShop pack;
	pack.header = HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_SHOP_DECORATION_USE;
	pack.size = sizeof(pack) + sizeof(index);

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack", pack.subheader);
		return;
	}

	if (!Send(index))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack", pack.subheader);
		return;
	}
}

void CPythonNetworkStream::SendShopMoveItem(int srcPos, int destPos)
{
	TPacketCGNewOfflineShop pack;
	pack.header = HEADER_CG_NEW_OFFLINESHOP;
	pack.subheader = ikashop::SUBHEADER_CG_SHOP_MOVE_ITEM;
	pack.size = sizeof(pack) + sizeof(ikashop::TSubPacketCGShopMoveItem);

	ikashop::TSubPacketCGShopMoveItem subpack{};
	subpack.srcPos = srcPos;
	subpack.destPos = destPos;

	if (!Send(pack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack", pack.subheader);
		return;
	}

	if (!Send(subpack))
	{
		TraceError("CANNOT SEND OFFLINESHOP PACKET : SUBHEADER %d - pack", pack.subheader);
		return;
	}
}
#endif

#endif