#pragma once

#include "SafeUDPpacket.h"

class SafeUDPpacketV
{
	std::vector<SafeUDPpacket> m_packetV;
	public:
		SafeUDPpacketV (const void*, const int, const int mtu = 1450);
		SafeUDPpacketV (int howmany, int size)
		{
			UDPpacket** p;
			m_packetV.reserve (howmany);
			if (NULL == (p = SDLNet_AllocPacketV (howmany, size)))
			{
				throw "SDLNet_AllocPacketV: " + std::string (SDLNet_GetError ());
			}
			else
			{
				for (; (p != NULL) && (*p != NULL); p++)
				{
					m_packetV.push_back (SafeUDPpacket (*p));
				}
				SDL_assert ((m_packetV.size () > 0) && (howmany == (int)m_packetV.size ()));
				/*
				 * SDLNet_FreePacketV just calls SDLNet_FreePacket on each packet.
				 * The "packetV" itself is just something allocated on the heap.
				 * We don't need this any longer.
				 */
				SDL_free (p);
			}
		}
		int Send (UDPsocket sock)
		{
			size_t size;
			int numsent;
			UDPpacket** pV;
			size = m_packetV.size ();
			if (NULL != (pV = (UDPpacket**)SDL_malloc (sizeof (UDPpacket*) * size)))
			{
				for (size_t i = 0; i < size; i++)
					pV[i] = m_packetV[i].get ();
				numsent = SDLNet_UDP_SendV (sock, pV, size);
				SDL_free (pV);
			}
			return numsent;
		}

		size_t size (void) const              { return m_packetV.size (); }
		const SafeUDPpacket& get (size_t idx) { return m_packetV.at (idx); }

		void channel (int channel)       { for (auto& p : m_packetV) { p.channel (channel); } }
		void len (int len)               { for (auto& p : m_packetV) { p.len (len); } }
		void maxlen (int maxlen)         { for (auto& p : m_packetV) { p.maxlen (maxlen); } }
		void status (int status)         { for (auto& p : m_packetV) { p.status (status); } }
		void address (IPaddress address) { for (auto& p : m_packetV) { p.address (address); } }

		std::string toString (void);
};