#include "../../base_media_base.h"

#include "../../ai/ai.hpp"

#include "../../game/game.hpp"

#include "../../fios.h"

#include "tcp_content.h"

#include "../../safeguards.h"

/** Clear everything in the struct */

ContentInfo::ContentInfo()

	: /* Temporary... will be removed later in the PR. */

	type((ContentType)0), id((ContentID)0), filesize(0), filename(""), name(""), version(""),

	state((State)0), upgrade(false)

{

}

/** Free everything allocated */

ContentInfo::~ContentInfo()

{

}

/**

 * Copy data from other #ContentInfo and take ownership of allocated stuff.

 * @param other Source to copy from. #dependencies and #tags will be NULLed.

 */

void ContentInfo::TransferFrom(ContentInfo *other)

{

	if (other != this) {

		*this = *other;

		other->tags.clear();

	}

}

/**

 * Is the state either selected or autoselected?

 * @return true iff that's the case

 */

bool ContentInfo::IsSelected() const

{

	switch (this->state) {

		case ContentInfo::SELECTED:

	};

	ContentType type;        ///< Type of content

	ContentID id;            ///< Unique (server side) ID for the content

	uint32 filesize;         ///< Size of the file

	char filename[48];       ///< Filename (for the .tar.gz; only valid on download)

	char name[32];           ///< Name of the content

	char version[16];        ///< Version of the content

	char url[96];            ///< URL related to the content

	char description[512];   ///< Description of the content

	uint32 unique_id;        ///< Unique ID; either GRF ID or shortname

	byte md5sum[16];         ///< The MD5 checksum

	StringList tags;         ///< Tags associated with the content

	State state;             ///< Whether the content info is selected (for download)

	bool upgrade;            ///< This item is an upgrade

	ContentInfo();

	~ContentInfo();

	void TransferFrom(ContentInfo *other);

	bool IsSelected() const;

	bool IsValid() const;

	const char *GetTextfile(TextfileType type) const;

	ci->filesize = p->Recv_uint32();

	p->Recv_string(ci->name, lengthof(ci->name));

	p->Recv_string(ci->version, lengthof(ci->version));

	p->Recv_string(ci->url, lengthof(ci->url));

	p->Recv_string(ci->description, lengthof(ci->description), SVS_REPLACE_WITH_QUESTION_MARK | SVS_ALLOW_NEWLINE);

	ci->unique_id = p->Recv_uint32();

	for (uint j = 0; j < sizeof(ci->md5sum); j++) {

		ci->md5sum[j] = p->Recv_uint8();

	}

	uint tag_count = p->Recv_uint8();

	ci->tags.reserve(tag_count);

	for (uint i = 0; i < tag_count; i++) ci->tags.push_back(p->Recv_string(NETWORK_CONTENT_TAG_LENGTH));

	if (!ci->IsValid()) {

		delete ci;

		this->CloseConnection();

		return false;

	}

	/* Find the appropriate check function */

}

/**

 * Reverse lookup the dependencies of (direct) parents over a given child.

 * @param parents list to store all parents in (is not cleared)

 * @param child   the child to search the parents' dependencies for

 */

void ClientNetworkContentSocketHandler::ReverseLookupDependency(ConstContentVector &parents, const ContentInfo *child) const

{

	for (const ContentInfo *ci : this->infos) {

		if (ci == child) continue;

				parents.push_back(ci);

				break;

			}

		}

	}

}

/**

 * Reverse lookup the dependencies of all parents over a given child.

 * @param tree  list to store all parents in (is not cleared)

 * @param child the child to search the parents' dependencies for

 */

}

/**

 * Check the dependencies (recursively) of this content info

 * @param ci the content info to check the dependencies of

 */

void ClientNetworkContentSocketHandler::CheckDependencyState(ContentInfo *ci)

{

	if (ci->IsSelected() || ci->state == ContentInfo::ALREADY_HERE) {

		/* Selection is easy; just walk all children and set the

		 * autoselected state. That way we can see what we automatically

		 * selected and thus can unselect when a dependency is removed. */

			if (c == nullptr) {

			} else if (c->state == ContentInfo::UNSELECTED) {

				c->state = ContentInfo::AUTOSELECTED;

				this->CheckDependencyState(c);

			}

		}

		return;

	}

	if (ci->state != ContentInfo::UNSELECTED) return;

	/* For unselection we need to find the parents of us. We need to

	 * unselect them. After that we unselect all children that we

	 * depend on and are not used as dependency for us, but only when

	 * we automatically selected them. */

	ConstContentVector parents;

	this->ReverseLookupDependency(parents, ci);

	for (const ContentInfo *c : parents) {

		if (!c->IsSelected()) continue;

		this->Unselect(c->id);

	}

		if (c == nullptr) {

			continue;

		}

		if (c->state != ContentInfo::AUTOSELECTED) continue;

		/* Only unselect when WE are the only parent. */

		parents.clear();

		this->ReverseLookupDependency(parents, c);

		/* First check whether anything depends on us */

		int sel_count = 0;

		bool force_selection = false;

		for (const ContentInfo *parent_ci : parents) {

		if (!StrEmpty(this->selected->url)) {

			SetDParamStr(0, this->selected->url);

			y = DrawStringMultiLine(r.left + DETAIL_LEFT, r.right - DETAIL_RIGHT, y, max_y, STR_CONTENT_DETAIL_URL);

		}

		SetDParam(0, STR_CONTENT_TYPE_BASE_GRAPHICS + this->selected->type - CONTENT_TYPE_BASE_GRAPHICS);

		y = DrawStringMultiLine(r.left + DETAIL_LEFT, r.right - DETAIL_RIGHT, y, max_y, STR_CONTENT_DETAIL_TYPE);

		y += WD_PAR_VSEP_WIDE;

		SetDParam(0, this->selected->filesize);

		y = DrawStringMultiLine(r.left + DETAIL_LEFT, r.right - DETAIL_RIGHT, y, max_y, STR_CONTENT_DETAIL_FILESIZE);

			/* List dependencies */

			char buf[DRAW_STRING_BUFFER] = "";

			char *p = buf;

				/* Try to find the dependency */

				ConstContentIterator iter = _network_content_client.Begin();

				for (; iter != _network_content_client.End(); iter++) {

					const ContentInfo *ci = *iter;

					if (ci->id != cid) continue;

					p += seprintf(p, lastof(buf), p == buf ? "%s" : ", %s", (*iter)->name);

					break;

				}

			}

			SetDParamStr(0, buf);

			y = DrawStringMultiLine(r.left + DETAIL_LEFT, r.right - DETAIL_RIGHT, y, max_y, STR_CONTENT_DETAIL_DEPENDENCIES);