/*
   Copyright (C) 2003 - 2017 by David White <dave@whitevine.net>
   Part of the Battle for Wesnoth Project http://www.wesnoth.org/

   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.

   See the COPYING file for more details.
*/

#include "help/help_topic_generators.hpp"

#include "font/sdl_ttf.hpp"             // for line_width
#include "game_config.hpp"              // for debug, menu_contract, etc
#include "preferences/game.hpp"         // for encountered_terrains, etc
#include "gettext.hpp"                  // for _, gettext, N_
#include "language.hpp"                 // for string_table, symbol_table
#include "log.hpp"                      // for LOG_STREAM, logger, etc
#include "movetype.hpp"                 // for movetype, movetype::effects, etc
#include "units/race.hpp"               // for unit_race, etc
#include "terrain/terrain.hpp"          // for terrain_type
#include "terrain/translation.hpp"      // for operator==, ter_list, etc
#include "terrain/type_data.hpp"        // for terrain_type_data, etc
#include "tstring.hpp"                  // for t_string, operator<<
#include "units/helper.hpp"             // for resistance_color
#include "units/types.hpp"              // for unit_type, unit_type_data, etc
#include "video.hpp"                    // fore current_resolution

#include <boost/optional.hpp>  // for optional
#include <iostream>                     // for operator<<, basic_ostream, etc
#include <map>                          // for map, etc
#include <set>
#include <SDL.h>

static lg::log_domain log_help("help");
#define WRN_HP LOG_STREAM(warn, log_help)
#define DBG_HP LOG_STREAM(debug, log_help)

namespace help {

static std::string best_str(bool best) {
	std::string lang_policy = (best ? _("Best of") : _("Worst of"));
	std::string color_policy = (best ? "green": "red");

	return "<format>color='" + color_policy + "' text='" + lang_policy + "'</format>";
}

typedef t_translation::ter_list::const_iterator ter_iter;
// Gets an english desription of a terrain ter_list alias behavior: "Best of cave, hills", "Worst of Swamp, Forest" etc.
static std::string print_behavior_description(ter_iter start, ter_iter end, const ter_data_cache & tdata, bool first_level = true, bool begin_best = true)
{

	if (start == end) return "";
	if (*start == t_translation::MINUS || *start == t_translation::PLUS) return print_behavior_description(start+1, end, tdata, first_level, *start == t_translation::PLUS); //absorb any leading mode changes by calling again, with a new default value begin_best.

	boost::optional<ter_iter> last_change_pos;

	bool best = begin_best;
	for (ter_iter i = start; i != end; ++i) {
		if ((best && *i == t_translation::MINUS) || (!best && *i == t_translation::PLUS)) {
			best = !best;
			last_change_pos = i;
		}
	}

	std::stringstream ss;

	if (!last_change_pos) {
		std::vector<std::string> names;
		for (ter_iter i = start; i != end; ++i) {
			const terrain_type tt = tdata->get_terrain_info(*i);
			if (!tt.editor_name().empty())
				names.push_back(tt.editor_name());
		}

		if (names.empty()) return "";
		if (names.size() == 1) return names.at(0);

		ss << best_str(best) << " ";
		if (!first_level) ss << "( ";
		ss << names.at(0);

		for (size_t i = 1; i < names.size(); i++) {
			ss << ", " << names.at(i);
		}

		if (!first_level) ss << " )";
	} else {
		std::vector<std::string> names;
		for (ter_iter i = *last_change_pos+1; i != end; ++i) {
			const terrain_type tt = tdata->get_terrain_info(*i);
			if (!tt.editor_name().empty())
				names.push_back(tt.editor_name());
		}

		if (names.empty()) { //This alias list is apparently padded with junk at the end, so truncate it without adding more parens
			return print_behavior_description(start, *last_change_pos, tdata, first_level, begin_best);
		}

		ss << best_str(best) << " ";
		if (!first_level) ss << "( ";
		ss << print_behavior_description(start, *last_change_pos-1, tdata, false, begin_best);
		// Printed the (parenthesized) leading part from before the change, now print the remaining names in this group.
		for (const std::string & s : names) {
			ss << ", " << s;
		}
		if (!first_level) ss << " )";
	}
	return ss.str();
}

std::string terrain_topic_generator::operator()() const {
	std::stringstream ss;

	if (!type_.icon_image().empty())
		ss << "<img>src='images/buttons/icon-base-32.png~RC(magenta>" << type_.id()
			<< ")~BLIT("<< "terrain/" << type_.icon_image() << "_30.png)" << "'</img> ";

	if (!type_.editor_image().empty())
		ss << "<img>src='" << type_.editor_image() << "'</img> ";

	if (!type_.help_topic_text().empty())
		ss << "\n\n" << type_.help_topic_text().str() << "\n";
	else
		ss << "\n";

	ter_data_cache tdata = load_terrain_types_data();

	if (!tdata) {
		WRN_HP << "When building terrain help topics, we couldn't acquire any terrain types data\n";
		return ss.str();
	}

	if (!(type_.union_type().size() == 1 && type_.union_type()[0] == type_.number() && type_.is_nonnull())) {

		const t_translation::ter_list& underlying_mvt_terrains = tdata->underlying_mvt_terrain(type_.number());

		ss << "\n" << _("Base Terrain: ");

		bool first = true;
		for (const t_translation::terrain_code& underlying_terrain : underlying_mvt_terrains) {
			const terrain_type& mvt_base = tdata->get_terrain_info(underlying_terrain);

			if (mvt_base.editor_name().empty()) continue;

			if (!first) {
				ss << ", ";
			} else {
				first = false;
			}

			ss << make_link(mvt_base.editor_name(), ".." + terrain_prefix + mvt_base.id());
		}

		ss << "\n";

		ss << "\n" << _("Movement properties: ");
		ss << print_behavior_description(underlying_mvt_terrains.begin(), underlying_mvt_terrains.end(), tdata) << "\n";

		const t_translation::ter_list& underlying_def_terrains = tdata->underlying_def_terrain(type_.number());
		ss << "\n" << _("Defense properties: ");
		ss << print_behavior_description(underlying_def_terrains.begin(), underlying_def_terrains.end(), tdata) << "\n";
	}

	if (game_config::debug) {

		ss << "\n";
		ss << "ID: "          << type_.id() << "\n";

		ss << "Village: "     << (type_.is_village()   ? "Yes" : "No") << "\n";
		ss << "Gives Healing: " << type_.gives_healing() << "\n";

		ss << "Keep: "        << (type_.is_keep()      ? "Yes" : "No") << "\n";
		ss << "Castle: "      << (type_.is_castle()    ? "Yes" : "No") << "\n";

		ss << "Overlay: "     << (type_.is_overlay()   ? "Yes" : "No") << "\n";
		ss << "Combined: "    << (type_.is_combined()  ? "Yes" : "No") << "\n";
		ss << "Nonnull: "     << (type_.is_nonnull()   ? "Yes" : "No") << "\n";

		ss << "Terrain string:"  << type_.number() << "\n";

		ss << "Hide in Editor: " << (type_.hide_in_editor() ? "Yes" : "No") << "\n";
		ss << "Hide Help: "      << (type_.hide_help() ? "Yes" : "No") << "\n";
		ss << "Editor Group: "   << type_.editor_group() << "\n";

		ss << "Light Bonus: "   << type_.light_bonus(0) << "\n";

		ss << type_.income_description();

		if (type_.editor_image().empty()) { // Note: this is purely temporary to help make a different help entry
			ss << "\nEditor Image: Empty\n";
		} else {
			ss << "\nEditor Image: " << type_.editor_image() << "\n";
		}

		const t_translation::ter_list& underlying_mvt_terrains = tdata->underlying_mvt_terrain(type_.number());
		ss << "\nDebug Mvt Description String:";
		for (const t_translation::terrain_code & t : underlying_mvt_terrains) {
			ss << " " << t;
		}

		const t_translation::ter_list& underlying_def_terrains = tdata->underlying_def_terrain(type_.number());
		ss << "\nDebug Def Description String:";
		for (const t_translation::terrain_code & t : underlying_def_terrains) {
			ss << " " << t;
		}

	}

	return ss.str();
}


//Typedef to help with formatting list of traits
typedef std::pair<std::string, std::string> trait_data;

//Helper function for printing a list of trait data
static void print_trait_list(std::stringstream & ss, const std::vector<trait_data> & l)
{
	size_t i = 0;
	ss << make_link(l[i].first, l[i].second);

	// This doesn't skip traits with empty names
	for(i++; i < l.size(); i++) {
		ss << ", " << make_link(l[i].first,l[i].second);
	}
}

std::string unit_topic_generator::operator()() const {
	// Force the lazy loading to build this unit.
	unit_types.build_unit_type(type_, unit_type::FULL);

	std::stringstream ss;
	std::string clear_stringstream;
	const std::string detailed_description = type_.unit_description();
	const unit_type& female_type = type_.get_gender_unit_type(unit_race::FEMALE);
	const unit_type& male_type = type_.get_gender_unit_type(unit_race::MALE);

	const int screen_width = CVideo::get_singleton().getx();

	ss << "Level " << type_.level();
	ss << "\n\n";

	ss << "<img>src='" << male_type.image();
	ss << "~RC(" << male_type.flag_rgb() << ">red)";
	if (screen_width >= 1200) ss << "~XBRZ(2)";
	ss << "' box='no'</img> ";


	if (&female_type != &male_type) {
		ss << "<img>src='" << female_type.image();
		ss << "~RC(" << female_type.flag_rgb() << ">red)";
		if (screen_width >= 1200) ss << "~XBRZ(2)";
		ss << "' box='no'</img> ";
	}

	const std::string &male_portrait = male_type.small_profile().empty() ?
		male_type.big_profile() : male_type.small_profile();
	const std::string &female_portrait = female_type.small_profile().empty() ?
		female_type.big_profile() : female_type.small_profile();

	const bool has_male_portrait = !male_portrait.empty() && male_portrait != male_type.image() && male_portrait != "unit_image";
	const bool has_female_portrait = !female_portrait.empty() && female_portrait != male_portrait && female_portrait != female_type.image() && female_portrait != "unit_image";

	int sz = (has_male_portrait && has_female_portrait ? 300 : 400);
	if (screen_width <= 1366) {
		sz = (has_male_portrait && has_female_portrait ? 200 : 300);
	} else if (screen_width >= 1920) {
		sz = 400;
	}

	// TODO: figure out why the second checks don't match but the last does
	if (has_male_portrait) {
		ss << "<img>src='" << male_portrait << "~FL(horiz)~SCALE_INTO(" << sz << ',' << sz << ")' box='no' align='right' float='yes'</img> ";
	}


	if (has_female_portrait) {
		ss << "<img>src='" << female_portrait << "~FL(horiz)~SCALE_INTO(" << sz << ',' << sz << ")' box='no' align='right' float='yes'</img> ";
	}

	ss << "\n";

	// Print cross-references to units that this unit advances from/to.
	// Cross reference to the topics containing information about those units.
	const bool first_reverse_value = true;
	bool reverse = first_reverse_value;
	if (variation_.empty()) {
		do {
			std::vector<std::string> adv_units =
				reverse ? type_.advances_from() : type_.advances_to();
			bool first = true;

			for (const std::string &adv : adv_units) {
				const unit_type *type = unit_types.find(adv, unit_type::HELP_INDEXED);
				if (!type || type->hide_help()) {
					continue;
				}

				if (first) {
					if (reverse) {
						ss << _("Advances from: ");
					} else {
						ss << _("Advances to: ");
					}
					first = false;
				} else {
					ss << ", ";
				}

				std::string lang_unit = type->type_name();
				std::string ref_id;
				if (description_type(*type) == FULL_DESCRIPTION) {
					const std::string section_prefix = type->show_variations_in_help() ? ".." : "";
					ref_id = section_prefix + unit_prefix + type->id();
				} else {
					ref_id = unknown_unit_topic;
					lang_unit += " (?)";
				}
				ss << make_link(lang_unit, ref_id);
			}
			if (!first) {
				ss << "\n";
			}

			reverse = !reverse; //switch direction
		} while(reverse != first_reverse_value); // don't restart
	}

	const unit_type* parent = variation_.empty() ? &type_ :
		unit_types.find(type_.id(), unit_type::HELP_INDEXED);
	if (!variation_.empty()) {
		ss << _("Base unit: ") << make_link(parent->type_name(), ".." + unit_prefix + type_.id()) << "\n";
	} else {
		bool first = true;
		for (const std::string& base_id : utils::split(type_.get_cfg()["base_ids"])) {
			if (first) {
				ss << _("Base units: ");
				first = false;
			}
			const unit_type* base_type = unit_types.find(base_id, unit_type::HELP_INDEXED);
			const std::string section_prefix = base_type->show_variations_in_help() ? ".." : "";
			ss << make_link(base_type->type_name(), section_prefix + unit_prefix + base_id) << "\n";
		}
	}

	bool first = true;
	for (const std::string &var_id : parent->variations()) {
		const unit_type &type = parent->get_variation(var_id);

		if(type.hide_help()) {
			continue;
		}

		if (first) {
			ss << _("Variations: ");
			first = false;
		} else {
			ss << ", ";
		}

		std::string ref_id;

		std::string var_name = type.variation_name();
		if (description_type(type) == FULL_DESCRIPTION) {
			ref_id = variation_prefix + type.id() + "_" + var_id;
		} else {
			ref_id = unknown_unit_topic;
			var_name += " (?)";
		}

		ss << make_link(var_name, ref_id);
	}
	ss << "\n"; //added even if empty, to avoid shifting

	// Print the race of the unit, cross-reference it to the respective topic.
	const std::string race_id = type_.race_id();
	std::string race_name = type_.race()->plural_name();
	if (race_name.empty()) {
		race_name = _ ("race^Miscellaneous");
	}
	ss << _("Race: ");
	ss << make_link(race_name, "..race_" + race_id);
	ss << "\n\n";

	// Print the possible traits of the unit, cross-reference them
	// to their respective topics.
	if (config::const_child_itors traits = type_.possible_traits()) {
		std::vector<trait_data> must_have_traits;
		std::vector<trait_data> random_traits;
		int must_have_nameless_traits = 0;

		for (const config & trait : traits) {
			const std::string trait_name = trait["male_name"];
			std::string lang_trait_name = translation::gettext(trait_name.c_str());
			if (lang_trait_name.empty() && trait["availability"].str() == "musthave") {
				++must_have_nameless_traits;
				continue;
			}
			const std::string ref_id = "traits_"+trait["id"].str();
			((trait["availability"].str() == "musthave") ? must_have_traits : random_traits).emplace_back(lang_trait_name, ref_id);
		}

		bool line1 = !must_have_traits.empty();
		bool line2 = !random_traits.empty() && type_.num_traits() > must_have_traits.size();

		if (line1) {
			std::string traits_label = _("Traits");
			ss << traits_label;
			if (line2) {
				std::stringstream must_have_count;
				must_have_count << " (" << must_have_traits.size() << ") : ";
				std::stringstream random_count;
				random_count << " (" << (type_.num_traits() - must_have_traits.size() - must_have_nameless_traits) << ") : ";

				int second_line_whitespace = font::line_width(traits_label+must_have_count.str(), normal_font_size)
					- font::line_width(random_count.str(), normal_font_size);
				// This ensures that the second line is justified so that the ':' characters are aligned.

				ss << must_have_count.str();
				print_trait_list(ss, must_have_traits);
				ss << "\n" << jump(second_line_whitespace) << random_count.str();
				print_trait_list(ss, random_traits);
			} else {
				ss << ": ";
				print_trait_list(ss, must_have_traits);
			}
			ss << "\n\n";
		} else {
			if (line2) {
				ss << _("Traits") << " (" << (type_.num_traits() - must_have_nameless_traits) << ") : ";
				print_trait_list(ss, random_traits);
				ss << "\n\n";
			}
		}
	}

	// Print the abilities the units has, cross-reference them
	// to their respective topics. TODO: Update this according to musthave trait effects, similar to movetype below
	if (!type_.abilities().empty()) {
		ss << _("Abilities: ");
		for(std::vector<t_string>::const_iterator ability_it = type_.abilities().begin(),
			ability_end = type_.abilities().end();
			ability_it != ability_end; ++ability_it) {
			const std::string ref_id = "ability_" + ability_it->base_str();
			std::string lang_ability = translation::gettext(ability_it->c_str());
			ss << make_link(lang_ability, ref_id);
			if (ability_it + 1 != ability_end) {
				ss << ", ";
			}
		}
		ss << "\n\n";
	}

	// Print the extra AMLA upgrade abilities, cross-reference them to their respective topics.
	if (!type_.adv_abilities().empty()) {
		ss << _("Ability Upgrades: ");
		for(std::vector<t_string>::const_iterator ability_it = type_.adv_abilities().begin(),
				ability_end = type_.adv_abilities().end();
				ability_it != ability_end; ++ability_it) {
			const std::string ref_id = "ability_" + ability_it->base_str();
			std::string lang_ability = translation::gettext(ability_it->c_str());
			ss << make_link(lang_ability, ref_id);
			if (ability_it + 1 != ability_end) {
				ss << ", ";
			}
		}
		ss << "\n\n";
	}

	// Print some basic information such as HP and movement points.
	// TODO: Make this info update according to musthave traits, similar to movetype below.
	ss << _("HP: ") << type_.hitpoints() << jump(30)
		<< _("Moves: ") << type_.movement() << jump(30);
	if (type_.vision() != type_.movement()) {
		ss << _("Vision: ") << type_.vision() << jump(30);
	}
	if (type_.jamming() > 0) {
		ss << _("Jamming: ") << type_.jamming() << jump(30);
	}
	ss << _("Cost: ") << type_.cost() << jump(30)
		<< _("Alignment: ")
		<< make_link(type_.alignment_description(type_.alignment(), type_.genders().front()), "time_of_day")
		<< jump(30);
	if (type_.can_advance()) {
		ss << _("Required XP: ") << type_.experience_needed();
	}

	// Print the detailed description about the unit.
		ss << "\n\n" << detailed_description;

	// Print the different attacks a unit has, if it has any.
	if (!type_.attacks().empty()) {
		// Print headers for the table.
		ss << "\n\n<header>text='" << escape(_("unit help^Attacks"))
			<< "'</header>\n\n";
		table_spec table;

		std::vector<item> first_row;
		// Dummy element, icons are below.
		first_row.push_back(item("", 0));
		push_header(first_row, _("unit help^Name"));
		push_header(first_row, _("Type"));
		push_header(first_row, _("Strikes"));
		push_header(first_row, _("Range"));
		push_header(first_row, _("Special"));
		table.push_back(first_row);
		// Print information about every attack.
		for(const attack_type& attack : type_.attacks()) {
			std::string lang_weapon = attack.name();
			std::string lang_type = string_table["type_" + attack.type()];
			std::vector<item> row;
			std::stringstream attack_ss;
			attack_ss << "<img>src='" << attack.icon() << "'</img>";
			row.emplace_back(attack_ss.str(),image_width(attack.icon()));
			push_tab_pair(row, lang_weapon);
			push_tab_pair(row, lang_type);
			attack_ss.str(clear_stringstream);
			attack_ss << attack.damage() << font::unicode_en_dash << attack.num_attacks()
				<< " " << attack.accuracy_parry_description();
			push_tab_pair(row, attack_ss.str());
			attack_ss.str(clear_stringstream);
			if (attack.min_range() > 1 || attack.max_range() > 1) {
				attack_ss << attack.min_range() << "-" << attack.max_range() << ' ';
			}
			attack_ss << string_table["range_" + attack.range()];
			push_tab_pair(row, attack_ss.str());
			attack_ss.str(clear_stringstream);
			// Show this attack's special, if it has any. Cross
			// reference it to the section describing the special.
			std::vector<std::pair<t_string, t_string> > specials = attack.special_tooltips();
			if (!specials.empty()) {
				std::string lang_special = "";
				const size_t specials_size = specials.size();
				for (size_t i = 0; i != specials_size; ++i) {
					const std::string ref_id = std::string("weaponspecial_")
						+ specials[i].first.base_str();
					lang_special = (specials[i].first);
					attack_ss << make_link(lang_special, ref_id);
					if (i+1 != specials_size) {
						attack_ss << ", "; //comma placed before next special
					}
				}
				row.emplace_back(attack_ss.str(), font::line_width(lang_special, normal_font_size));
			}
			table.push_back(row);
		}
		ss << generate_table(table);
	}

	// Generate the movement type of the unit, with resistance, defense, movement, jamming and vision data updated according to any 'musthave' traits which always apply
	movetype movement_type = type_.movement_type();
	config::const_child_itors traits = type_.possible_traits();
	if (!traits.empty() && type_.num_traits() > 0) {
		for (const config & t : traits) {
			if (t["availability"].str() == "musthave") {
				for (const config & effect : t.child_range("effect")) {
					if (!effect.child("filter") // If this is musthave but has a unit filter, it might not always apply, so don't apply it in the help.
							&& movetype::effects.find(effect["apply_to"].str()) != movetype::effects.end()) {
						movement_type.merge(effect, effect["replace"].to_bool());
					}
				}
			}
		}
	}

	// Print the resistance table of the unit.
	ss << "\n\n<header>text='" << escape(_("Resistances"))
		<< "'</header>\n\n";
	table_spec resistance_table;
	std::vector<item> first_res_row;
	push_header(first_res_row, _("Attack Type"));
	push_header(first_res_row, _("Resistance"));
	resistance_table.push_back(first_res_row);
	utils::string_map dam_tab = movement_type.damage_table();
	for(std::pair<std::string, std::string> dam_it : dam_tab) {
		std::vector<item> row;
		int resistance = 100;
		try {
			resistance -= std::stoi(dam_it.second);
		} catch(std::invalid_argument) {}
		std::string resist = std::to_string(resistance) + '%';
		const size_t pos = resist.find('-');
		if (pos != std::string::npos) {
			resist.replace(pos, 1, font::unicode_minus);
		}
		std::string color = unit_helper::resistance_color(resistance);
		std::string lang_weapon = string_table["type_" + dam_it.first];
		push_tab_pair(row, lang_weapon);
		std::stringstream str;
		str << "<format>color=\"" << color << "\" text='"<< resist << "'</format>";
		const std::string markup = str.str();
		str.str(clear_stringstream);
		str << resist;
		row.emplace_back(markup, font::line_width(str.str(), normal_font_size));
		resistance_table.push_back(row);
	}
	ss << generate_table(resistance_table);

	if (ter_data_cache tdata = load_terrain_types_data()) {
		// Print the terrain modifier table of the unit.
		ss << "\n\n<header>text='" << escape(_("Terrain Modifiers"))
			<< "'</header>\n\n";
		std::vector<item> first_row;
		table_spec table;
		push_header(first_row, _("Terrain"));
		push_header(first_row, _("Defense"));
		push_header(first_row, _("Movement Cost"));

		const bool has_terrain_defense_caps = movement_type.has_terrain_defense_caps(preferences::encountered_terrains());
		if (has_terrain_defense_caps) {
			push_header(first_row, _("Defense Cap"));
		}

		const bool has_vision = type_.movement_type().has_vision_data();
		if (has_vision) {
			push_header(first_row, _("Vision Cost"));
		}
		const bool has_jamming = type_.movement_type().has_jamming_data();
		if (has_jamming) {
			push_header(first_row, _("Jamming Cost"));
		}

		table.push_back(first_row);
		std::set<t_translation::terrain_code>::const_iterator terrain_it =
			preferences::encountered_terrains().begin();

		for (; terrain_it != preferences::encountered_terrains().end();
			 	++terrain_it) {
			const t_translation::terrain_code terrain = *terrain_it;
			if (terrain == t_translation::FOGGED || terrain == t_translation::VOID_TERRAIN || t_translation::terrain_matches(terrain, t_translation::ALL_OFF_MAP)) {
				continue;
			}
			const terrain_type& info = tdata->get_terrain_info(terrain);

			if (info.union_type().size() == 1 && info.union_type()[0] == info.number() && info.is_nonnull()) {
				std::vector<item> row;
				const std::string& name = info.name();
				const std::string& id = info.id();
				const int moves = movement_type.movement_cost(terrain);
				const int views = movement_type.vision_cost(terrain);
				const int jams  = movement_type.jamming_cost(terrain);

				bool high_res = false;
				const std::string tc_base = high_res ? "images/buttons/icon-base-32.png" : "images/buttons/icon-base-16.png";
				const std::string terrain_image = "icons/terrain/terrain_type_" + id + (high_res ? "_30.png" : ".png");

				const std::string final_image = tc_base + "~RC(magenta>" + id + ")~BLIT(" + terrain_image + ")";

				row.emplace_back("<img>src='" + final_image + "'</img> " +
						make_link(name, "..terrain_" + id),
					font::line_width(name, normal_font_size) + (high_res ? 32 : 16) );

				//defense  -  range: +10 % .. +70 %
				const int defense = 100 - movement_type.defense_modifier(terrain);
				std::string color;
				if (defense <= 10) {
					color = "red";
				} else if (defense <= 30) {
					color = "yellow";
				} else if (defense <= 50) {
					color = "white";
				} else {
					color = "green";
				}

				std::stringstream str;
				str << "<format>color=" << color << " text='"<< defense << "%'</format>";
				std::string markup = str.str();
				str.str(clear_stringstream);
				str << defense << "%";
				row.emplace_back(markup, font::line_width(str.str(), normal_font_size));

				//movement  -  range: 1 .. 5, movetype::UNREACHABLE=impassable
				str.str(clear_stringstream);
				const bool cannot_move = moves > type_.movement();
				if (cannot_move) {		// cannot move in this terrain
					color = "red";
				} else if (moves > 1) {
					color = "yellow";
				} else {
					color = "white";
				}
				str << "<format>color=" << color << " text='";
				// A 5 MP margin; if the movement costs go above
				// the unit's max moves + 5, we replace it with dashes.
				if(cannot_move && (moves > type_.movement() + 5)) {
					str << font::unicode_figure_dash;
				} else {
					str << moves;
				}
				str << "'</format>";
				markup = str.str();
				str.str(clear_stringstream);
				str << moves;
				row.emplace_back(markup, font::line_width(str.str(), normal_font_size));

				//defense cap
				if (has_terrain_defense_caps) {
					str.str(clear_stringstream);
					const bool has_cap = movement_type.get_defense().capped(terrain);
					if (has_cap) {
						str << "<format>color='"<< color <<"' text='" << defense << "%'</format>";
					} else {
						str << "<format>color=white text='" << font::unicode_figure_dash << "'</format>";
					}
					markup = str.str();
					str.str(clear_stringstream);
					if (has_cap) {
						str << defense << '%';
					} else {
						str << font::unicode_figure_dash;
					}
					row.emplace_back(markup, font::line_width(str.str(), normal_font_size));
				}

				//vision
					if (has_vision) {
						str.str(clear_stringstream);
						const bool cannot_view = views > type_.vision();
						if (cannot_view) {		// cannot view in this terrain
							color = "red";
						} else if (views > moves) {
							color = "yellow";
						} else if (views == moves) {
							color = "white";
						} else {
							color = "green";
						}
						str << "<format>color=" << color << " text='";
						// A 5 MP margin; if the vision costs go above
						// the unit's vision + 5, we replace it with dashes.
						if(cannot_view && (views > type_.vision() + 5)) {
							str << font::unicode_figure_dash;
						} else {
							str << views;
						}
						str << "'</format>";
						markup = str.str();
						str.str(clear_stringstream);
						str << views;
						row.emplace_back(markup, font::line_width(str.str(), normal_font_size));
					}

				//jamming
				if (has_jamming) {
					str.str(clear_stringstream);
					const bool cannot_jam = jams > type_.jamming();
					if (cannot_jam) {		// cannot jamm in this terrain
						color = "red";
					} else if (jams > views) {
						color = "yellow";
					} else if (jams == views) {
						color = "white";
					} else {
						color = "green";
					}
					str << "<format>color=" << color << " text='";
					// A 5 MP margin; if the jamming costs go above
					// the unit's jamming + 5, we replace it with dashes.
					if ( cannot_jam  &&  jams > type_.jamming() + 5 ) {
						str << font::unicode_figure_dash;
					} else {
						str << jams;
					}
					str << "'</format>";

					push_tab_pair(row, str.str());
				}

				table.push_back(row);
			}
		}

		ss << generate_table(table);
	} else {
		WRN_HP << "When building unit help topics, the display object was null and we couldn't get the terrain info we need.\n";
	}
	return ss.str();
}

void unit_topic_generator::push_header(std::vector< item > &row,  const std::string& name) const {
	row.emplace_back(bold(name), font::line_width(name, normal_font_size, TTF_STYLE_BOLD));
}

} // end namespace help