/**
 *  Copyright (C) 2002-2022   The FreeCol Team
 *
 *  This file is part of FreeCol.
 *
 *  FreeCol 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.
 *
 *  FreeCol 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 FreeCol.  If not, see <http://www.gnu.org/licenses/>.
 */

package net.sf.freecol.common.model;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.ToIntFunction;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Stream;

import javax.xml.stream.XMLStreamException;

import net.sf.freecol.FreeCol;
import net.sf.freecol.common.io.FreeColXMLReader;
import net.sf.freecol.common.io.FreeColXMLWriter;
import static net.sf.freecol.common.model.Constants.*;
import net.sf.freecol.common.option.GameOptions;
import static net.sf.freecol.common.util.CollectionUtils.*;
import net.sf.freecol.common.util.LogBuilder;
import net.sf.freecol.common.util.RandomChoice;


/**
 * Represents a colony. A colony contains {@link Building}s and
 * {@link ColonyTile}s. The latter represents the tiles around the
 * {@code Colony} where working is possible.
 */
public class Colony extends Settlement implements TradeLocation {

    private static final Logger logger = Logger.getLogger(Colony.class.getName());

    /** Class index for colonies. */
    private static final int COLONY_CLASS_INDEX = 20;

    public static final String TAG = "colony";

    public static final String REARRANGE_COLONY = "rearrangeColony";

    public static final int LIBERTY_PER_REBEL = 200;
    public static final int CHANGE_UPPER_BOUND = 10;

    /** The number of turns of advanced warning of starvation. */
    public static final int FAMINE_TURNS = 3;

    /** Number of colonies that a player will trade down to. */
    public static final int TRADE_MARGIN = 5;

    public static enum ColonyChangeEvent {
        POPULATION_CHANGE,
        PRODUCTION_CHANGE,
        BONUS_CHANGE,
        WAREHOUSE_CHANGE,
        BUILD_QUEUE_CHANGE,
        UNIT_TYPE_CHANGE
    }

    /** Reasons for not building a buildable. */
    public static enum NoBuildReason {
        NONE,
        NOT_BUILDING,
        NOT_BUILDABLE,
        POPULATION_TOO_SMALL,
        MISSING_BUILD_ABILITY,
        MISSING_ABILITY,
        WRONG_UPGRADE,
        COASTAL,
        LIMIT_EXCEEDED
    }

    /** Government bonuses/penalties */
    public int GOVERNMENT_VERY_GOOD = 2,
        GOVERNMENT_GOOD = 1,
        GOVERNMENT_ORDINARY = 0,
        GOVERNMENT_BAD = -1,
        GOVERNMENT_VERY_BAD = -2;

    /** A map of Buildings, indexed by the id of their basic type. */
    protected final java.util.Map<String, Building> buildingMap = new HashMap<>();

    /** A list of the ColonyTiles. */
    protected final List<ColonyTile> colonyTiles = new ArrayList<>();

    /** A map of ExportData, indexed by the ids of GoodsTypes. */
    protected final java.util.Map<String, ExportData> exportData = new HashMap<>();

    /**
     * The number of liberty points.  Liberty points are an
     * abstract game concept.  They are generated by but are not
     * identical to bells, and subject to further modification.
     */
    protected int liberty;

    /** The SoL membership this turn (percentage). */
    protected int sonsOfLiberty;

    /** The SoL membership last turn. */
    protected int oldSonsOfLiberty;

    /** The number of tories this turn. */
    protected int tories;

    /** The number of tories last turn. */
    protected int oldTories;

    /** The current production bonus. */
    protected int productionBonus;

    /**
     * The number of immigration points.  Immigration points are an
     * abstract game concept.  They are generated by but are not
     * identical to crosses.
     */
    protected int immigration;

    /** The turn in which this colony was established. */
    protected Turn established = new Turn(0);

    /** A list of items to be built. */
    protected final BuildQueue<BuildableType> buildQueue
            = new BuildQueue<>(this,
                               BuildQueue.CompletionAction.REMOVE_EXCEPT_LAST,
                               Consumer.COLONY_PRIORITY);

    /** The colonists that may be born. */
    protected final BuildQueue<UnitType> populationQueue
            = new BuildQueue<>(this,
                               BuildQueue.CompletionAction.SHUFFLE,
                               Consumer.POPULATION_PRIORITY);

    // Will only be used on enemy colonies:
    protected int displayUnitCount = -1;

    // Do not serialize below.

    /** Contains information about production and consumption. */
    private final ProductionCache productionCache = new ProductionCache(this);

    /** The occupation tracing status.  Do not serialize. */
    private boolean traceOccupation = false;



    /**
     * Constructor for ServerColony.
     *
     * @param game The enclosing {@code Game}.
     * @param owner The {@code Player} owning this {@code Colony}.
     * @param name The name of the new {@code Colony}.
     * @param tile The containing {@code Tile}.
     */
    protected Colony(Game game, Player owner, String name, Tile tile) {
        super(game, owner, name, tile);
    }

    /**
     * Create a new {@code Colony} with the given
     * identifier. The object should later be initialized by calling
     * either {@link #readFromXML(FreeColXMLReader)}.
     *
     * @param game The enclosing {@code Game}.
     * @param id The object identifier.
     */
    public Colony(Game game, String id) {
        super(game, id);
    }


    // Primitive accessors.

    /**
     * Get a list of every {@link Building} in this {@code Colony}.
     *
     * @return A list of {@code Building}s.
     */
    public List<Building> getBuildings() {
        synchronized (this.buildingMap) {
            return new ArrayList<>(this.buildingMap.values());
        }
    }

    /**
     * Get building of the specified general type (note: *not*
     * necessarily the exact building type supplied, but the building
     * present in the colony that is a descendant of the ultimate
     * ancestor of the specified type).
     *
     * @param type The type of the building to get.
     * @return The {@code Building} found.
     */
    public Building getBuilding(BuildingType type) {
        synchronized (this.buildingMap) {
            return this.buildingMap.get(type.getFirstLevel().getId());
        }
    }

    /**
     * Reset the building map.
     *
     * @param buildings The list of buildings to use.
     */
    protected void setBuildingMap(List<Building> buildings) {
        clearBuildingMap();
        for (Building b : buildings) addBuilding(b);
    }

    /**
     * Clear the building map.
     */
    protected void clearBuildingMap() {
        synchronized (this.buildingMap) { this.buildingMap.clear(); }
    }

    /**
     * Gets a {@code List} of every {@link ColonyTile} in this
     * {@code Colony}.
     *
     * @return A list of {@code ColonyTile}s.
     * @see ColonyTile
     */
    public List<ColonyTile> getColonyTiles() {
        synchronized (this.colonyTiles) {
            return new ArrayList<>(this.colonyTiles);
        }
    }

    /**
     * Set the colony tile list.
     *
     * @param colonyTiles The new list of {@code ColonyTile}s.
     */
    protected void setColonyTiles(List<ColonyTile> colonyTiles) {
        synchronized (this.colonyTiles) {
            this.colonyTiles.clear();
            this.colonyTiles.addAll(colonyTiles);
        }
    }
        
    /**
     * Clear the colony tiles.
     */
    private void clearColonyTiles() {
        synchronized (this.colonyTiles) { this.colonyTiles.clear(); }
    }
        
    /**
     * Get the {@code ColonyTile} matching the given {@code Tile}.
     *
     * @param tile The {@code Tile} to check.
     * @return The corresponding {@code ColonyTile}, or null if not found.
     */
    public ColonyTile getColonyTile(Tile tile) {
        return find(getColonyTiles(), matchKey(tile, ColonyTile::getWorkTile));
    }

    /**
     * Get the export data.
     *
     * @return The list of {@code ExportData}.
     */
    protected Collection<ExportData> getExportData() {
        return this.exportData.values();
    }

    /**
     * Set the export data.
     *
     * @param exportData The new list of {@code ExportData}.
     */
    protected void setExportData(Collection<ExportData> exportData) {
        this.exportData.clear();
        for (ExportData ed : exportData) setExportData(ed);
    }

    /**
     * Get the export date for a goods type.
     *
     * @param goodsType The {@code GoodsType} to check.
     * @return The required {@code ExportData}.
     */
    public ExportData getExportData(final GoodsType goodsType) {
        ExportData result = this.exportData.get(goodsType.getId());
        if (result == null) {
            result = new ExportData(goodsType, getWarehouseCapacity());
            setExportData(result);
        }
        return result;
    }

    /**
     * Set some export data.
     *
     * @param newExportData A new {@code ExportData} value.
     */
    public final void setExportData(final ExportData newExportData) {
        this.exportData.put(newExportData.getId(), newExportData);
    }

    /**
     * Get the sons-of-liberty percentage.
     *
     * @return The sol%.
     */
    public int getSonsOfLiberty() {
        return this.sonsOfLiberty;
    }

    protected int getOldSonsOfLiberty() {
        return this.oldSonsOfLiberty;
    }
    protected int getToryCount() {
        return this.tories;
    }
    protected int getOldToryCount() {
        return this.oldTories;
    }
    
    /**
     * Gets the production bonus of the colony.
     *
     * @return The current production bonus of the colony.
     */
    public int getProductionBonus() {
        return this.productionBonus;
    }

    /**
     * Sets the production bonus of the colony.
     *
     * Only public for the convenience of the test suite.
     *
     * @param productionBonus The new production bonus of the colony.
     */
    public void setProductionBonus(int productionBonus) {
        this.productionBonus = productionBonus;
    }

    /**
     * Modify the immigration points by amount given.
     *
     * @param amount An amount of immigration.
     */
    public void modifyImmigration(int amount) {
        this.immigration += amount;
    }

    /**
     * Get the turn this colony was established.
     *
     * @return The establishment {@code Turn}.
     */
    public Turn getEstablished() {
        return this.established;
    }

    /**
     * Set the turn of establishment.
     *
     * @param newEstablished The new {@code Turn} of establishment.
     */
    public void setEstablished(final Turn newEstablished) {
        this.established = newEstablished;
    }

    /**
     * Get the build queue contents.
     *
     * @return A list of {@code Buildable}s.
     */
    public List<BuildableType> getBuildQueue() {
        return this.buildQueue.getValues();
    }

    /**
     * Set the build queue.
     *
     * @param buildQueue A list of new values for the build queue.
     */
    public void setBuildQueue(final List<BuildableType> buildQueue) {
        this.buildQueue.setValues(buildQueue);
    }

    /**
     * Get the population queue contents.
     *
     * @return A list of {@code Buildable}s.
     */
    public List<UnitType> getPopulationQueue() {
        return this.populationQueue.getValues();
    }

    /**
     * Set the population queue.
     *
     * @param populationQueue A list of new values for the population queue.
     */
    public void setPopulationQueue(final List<UnitType> populationQueue) {
        this.populationQueue.setValues(populationQueue);
    }
    
    /**
     * Get the display unit count.
     *
     * @return The explicit unit count for display purposes.
     */
    public int getDisplayUnitCount() {
        return this.displayUnitCount;
    }

    /**
     * Sets the apparent number of units at this colony.
     * Used in client enemy colonies
     *
     * @param count The new apparent number of {@code Unit}s at
     *     this colony.
     */
    public void setDisplayUnitCount(int count) {
        this.displayUnitCount = count;
    }


    // Occupation routines

    /**
     * Gets the occupation tracing status.
     *
     * @return The occupation tracing status.
     */
    public boolean getOccupationTrace() {
        return this.traceOccupation;
    }

    /**
     * Sets the occupation tracing status.
     *
     * @param trace The new occupation tracing status.
     * @return The original occupation tracing status.
     */
    public boolean setOccupationTrace(boolean trace) {
        boolean ret = this.traceOccupation;
        this.traceOccupation = trace;
        return ret;
    }

    private void accumulateChoices(Collection<GoodsType> workTypes,
                                   Collection<GoodsType> tried,
                                   List<Collection<GoodsType>> result) {
        workTypes.removeAll(tried);
        if (!workTypes.isEmpty()) {
            result.add(workTypes);
            tried.addAll(workTypes);
        }
    }

    private void accumulateChoice(GoodsType workType,
                                  Collection<GoodsType> tried,
                                  List<Collection<GoodsType>> result) {
        if (workType == null) return;
        accumulateChoices(workType.getEquivalentTypes(), tried, result);
    }

    /**
     * Get a list of collections of goods types, in order of priority
     * to try to produce in this colony by a given unit.
     *
     * @param unit The {@code Unit} to check.
     * @param userMode If a user requested this, favour the current
     *     work type, if not favour goods that the unit requires.
     * @return The list of collections of {@code GoodsType}s.
     */
    public List<Collection<GoodsType>> getWorkTypeChoices(Unit unit,
                                                          boolean userMode) {
        final Specification spec = getSpecification();
        List<Collection<GoodsType>> result = new ArrayList<>();
        Set<GoodsType> tried = new HashSet<>();

        // Find the food and non-food goods types required by this unit
        // and which are underproduced at present.
        Set<GoodsType> food = new HashSet<>();
        Set<GoodsType> nonFood = new HashSet<>();
        for (AbstractGoods ag : transform(unit.getType().getConsumedGoods(),
                g -> productionCache.getNetProductionOf(g.getType())
                        < g.getAmount())) {
            if (ag.isFoodType()) {
                food.addAll(ag.getType().getEquivalentTypes());
            } else {
                nonFood.addAll(ag.getType().getEquivalentTypes());
            }
        }

        if (userMode) { // Favour current and expert types in user mode
            accumulateChoice(unit.getWorkType(), tried, result);
            accumulateChoice(unit.getType().getExpertProduction(), tried, result);
            accumulateChoice(unit.getExperienceType(), tried, result);
            accumulateChoices(food, tried, result);
            accumulateChoices(nonFood, tried, result);
        } else { // Otherwise favour the required goods types
            accumulateChoices(food, tried, result);
            accumulateChoices(nonFood, tried, result);
            accumulateChoice(unit.getWorkType(), tried, result);
            accumulateChoice(unit.getType().getExpertProduction(), tried, result);
            accumulateChoice(unit.getExperienceType(), tried, result);
        }
        accumulateChoices(spec.getFoodGoodsTypeList(), tried, result);
        accumulateChoices(spec.getNewWorldLuxuryGoodsTypeList(), tried, result);
        accumulateChoices(spec.getGoodsTypeList(), tried, result);
        return result;
    }

    /**
     * Gets the best occupation for a given unit to produce one of
     * a given set of goods types.
     *
     * @param unit The {@code Unit} to find an
     *     {@code Occupation} for.
     * @param workTypes A collection of {@code GoodsType} to
     *     consider producing.
     * @param lb A {@code LogBuilder} to log to.
     * @return An {@code Occupation} for the given unit, or null
     *     if none found.
     */
    private Occupation getOccupationFor(Unit unit,
                                        Collection<GoodsType> workTypes,
                                        LogBuilder lb) {
        if (workTypes.isEmpty()) return null;

        Occupation best = new Occupation(null, null, null);
        int bestAmount = 0;
        for (WorkLocation wl : getCurrentWorkLocationsList()) {
            bestAmount = best.improve(unit, wl, bestAmount, workTypes, lb);
        }

        if (best.workLocation != null) {
            lb.add("\n  => ", best, " = ", bestAmount);
        }
        return (best.workLocation == null) ? null : best;
    }

    /**
     * Gets the best occupation for a given unit.
     *
     * @param unit The {@code Unit} to find an
     *     {@code Occupation} for.
     * @param userMode If a user requested this, favour the current
     *     work type, if not favour goods that the unit requires.
     * @param lb A {@code LogBuilder} to log to.
     * @return An {@code Occupation} for the given unit, or
     *     null if none found.
     */
    private Occupation getOccupationFor(Unit unit, boolean userMode,
                                        LogBuilder lb) {
        for (Collection<GoodsType> types : getWorkTypeChoices(unit, userMode)) {
            lb.add("\n  ");
            FreeColObject.logFreeColObjects(types, lb);
            Occupation occupation = getOccupationFor(unit, types, lb);
            if (occupation != null) return occupation;
        }
        lb.add("\n  => FAILED");
        return null;
    }

    /**
     * Gets the best occupation for a given unit to produce one of
     * a given set of goods types.
     *
     * @param unit The {@code Unit} to find an
     *     {@code Occupation} for.
     * @param workTypes A collection of {@code GoodsType} to
     *     consider producing.
     * @return An {@code Occupation} for the given unit, or null
     *     if none found.
     */
    private Occupation getOccupationFor(Unit unit,
                                        Collection<GoodsType> workTypes) {
        LogBuilder lb = new LogBuilder((getOccupationTrace()) ? 64 : 0);
        lb.add(getName(), ".getOccupationFor(", unit, ", ");
        FreeColObject.logFreeColObjects(workTypes, lb);
        lb.add(")");

        Occupation occupation = getOccupationFor(unit, workTypes, lb);
        lb.log(logger, Level.WARNING);
        return occupation;
    }

    /**
     * Gets the best occupation for a given unit.
     *
     * @param unit The {@code Unit} to find an
     *     {@code Occupation} for.
     * @param userMode If a user requested this, favour the current
     *     work type, if not favour goods that the unit requires.
     * @return An {@code Occupation} for the given unit, or
     *     null if none found.
     */
    private Occupation getOccupationFor(Unit unit, boolean userMode) {
        LogBuilder lb = new LogBuilder((getOccupationTrace()) ? 64 : 0);
        lb.add(getName(), ".getOccupationFor(", unit, ")");

        Occupation occupation = getOccupationFor(unit, userMode, lb);
        lb.log(logger, Level.WARNING);
        return occupation;
    }


    // WorkLocations, Buildings, ColonyTiles

    /**
     * Gets a list of every work location in this colony.
     *
     * @return The list of work locations.
     */
    public List<WorkLocation> getAllWorkLocationsList() {
        List<WorkLocation> ret = new ArrayList<>();
        synchronized (this.colonyTiles) {
            ret.addAll(this.colonyTiles);
        }
        synchronized (this.buildingMap) {
            ret.addAll(this.buildingMap.values());
        }
        return ret;
    }

    /**
     * Gets a stream of every work location in this colony.
     *
     * @return The stream of work locations.
     */
    public Stream<WorkLocation> getAllWorkLocations() {
        Stream<WorkLocation> ret = Stream.<WorkLocation>empty();
        synchronized (this.colonyTiles) {
            ret = concat(ret, map(this.colonyTiles,
                                  Function.<WorkLocation>identity()));
        }
        synchronized (this.buildingMap) {
            ret = concat(ret, map(this.buildingMap.values(),
                                  Function.<WorkLocation>identity()));
        }
        return ret;
    }

    /**
     * Gets a list of all freely available work locations
     * in this colony.
     *
     * @return The list of available {@code WorkLocation}s.
     */
    public List<WorkLocation> getAvailableWorkLocationsList() {
        return transform(getAllWorkLocations(), WorkLocation::isAvailable);
    }

    /**
     * Get a stream of all freely available work locations in this
     * colony.
     *
     * @return The stream of available {@code WorkLocation}s.
     */
    public Stream<WorkLocation> getAvailableWorkLocations() {
        return getAvailableWorkLocationsList().stream();
    }

    /**
     * Gets a list of all current work locations in this colony.
     *
     * @return The list of current {@code WorkLocation}s.
     */
    public List<WorkLocation> getCurrentWorkLocationsList() {
        return transform(getAllWorkLocations(), WorkLocation::isCurrent);
    }

    /**
     * Get a stream of all current work locations in this colony.
     *
     * @return The stream of current {@code WorkLocation}s.
     */
    public Stream<WorkLocation> getCurrentWorkLocations() {
        return getCurrentWorkLocationsList().stream();
    }

    /**
     * Add a Building to this Colony.
     *
     * Lower level routine, do not use directly in-game (use buildBuilding).
     * Used for serialization and public for the test suite.
     *
     * -til: Could change the tile appearance if the building is
     * stockade-type
     *
     * @param building The {@code Building} to build.
     * @return True if the building was added.
     */
    public boolean addBuilding(final Building building) {
        if (building == null || building.getType() == null) return false;
        final BuildingType buildingType = building.getType().getFirstLevel();
        if (buildingType == null || buildingType.getId() == null) return false;
        synchronized (buildingMap) {
            buildingMap.put(buildingType.getId(), building);
        }
        addFeatures(building.getType());
        return true;
    }

    /**
     * Remove a building from this Colony.
     *
     * -til: Could change the tile appearance if the building is
     * stockade-type
     *
     * @param building The {@code Building} to remove.
     * @return True if the building was removed.
     */
    protected boolean removeBuilding(final Building building) {
        final BuildingType buildingType = building.getType().getFirstLevel();
        synchronized (buildingMap) {
            if (buildingMap.remove(buildingType.getId()) == null) return false;
        }
        removeFeatures(building.getType());
        return true;
    }

    /**
     * Add a colony tile.
     *
     * @param ct The {@code ColonyTile} to add.
     */
    private void addColonyTile(ColonyTile ct) {
        if (ct == null) return;
        synchronized (colonyTiles) {
            colonyTiles.add(ct);
        }
    }

    /**
     * Gets a work location with a given ability.
     *
     * @param ability An ability key.
     * @return A {@code WorkLocation} with the required
     *     {@code Ability}, or null if not found.
     */
    public WorkLocation getWorkLocationWithAbility(String ability) {
        return find(getCurrentWorkLocations(), wl -> wl.hasAbility(ability));
    }

    /**
     * Gets a work location of a specific class with a given ability.
     *
     * @param <T> The actual return type.
     * @param ability An ability key.
     * @param returnClass The expected subclass.
     * @return A {@code WorkLocation} with the required
     *     {@code Ability}, or null if not found.
     */
    public <T extends WorkLocation> T getWorkLocationWithAbility(String ability,
                                                                 Class<T> returnClass) {
        WorkLocation wl = getWorkLocationWithAbility(ability);
        try {
            if (wl != null) return returnClass.cast(wl);
        } catch (ClassCastException cce) {};
        return null;
    }

    /**
     * Gets a work location with a given modifier.
     *
     * @param modifier A modifier key.
     * @return A {@code WorkLocation} with the required
     *     {@code Modifier}, or null if not found.
     */
    public WorkLocation getWorkLocationWithModifier(String modifier) {
        return find(getCurrentWorkLocations(), wl -> wl.hasModifier(modifier));
    }

    /**
     * Gets a work location of a specific class with a given modifier.
     *
     * @param <T> The actual return type.
     * @param modifier A modifier key.
     * @param returnClass The expected subclass.
     * @return A {@code WorkLocation} with the required
     *     {@code Modifier}, or null if not found.
     */
    public <T extends WorkLocation> T getWorkLocationWithModifier(String modifier,
                                                                  Class<T> returnClass) {
        WorkLocation wl = getWorkLocationWithModifier(modifier);
        if (wl != null) try { return returnClass.cast(wl); } catch (ClassCastException cce) {}
        return null;
    }

    /**
     * Collect the work locations for consuming a given type of goods.
     *
     * @param goodsType The {@code GoodsType} to consume.
     * @return A list of {@code WorkLocation}s which consume
     *     the given type of goods.
     */
    public List<WorkLocation> getWorkLocationsForConsuming(GoodsType goodsType) {
        return transform(getCurrentWorkLocations(),
                wl -> any(wl.getInputs(), AbstractGoods.matches(goodsType)));
    }

    /**
     * Collect the work locations for producing a given type of goods.
     *
     * @param goodsType The {@code GoodsType} to produce.
     * @return A list of {@code WorkLocation}s which produce
     *     the given type of goods.
     */
    public List<WorkLocation> getWorkLocationsForProducing(GoodsType goodsType) {
        return transform(getCurrentWorkLocations(),
                wl -> any(wl.getOutputs(), AbstractGoods.matches(goodsType)));
    }

    /**
     * Find a work location for producing a given type of goods.
     * Beware that this may not be the optimal location for the
     * production, for which {@link #getWorkLocationFor} is better.
     *
     * @param goodsType The {@code GoodsType} to produce.
     * @return A {@code WorkLocation}s which produces
     *      the given type of goods, or null if not found.
     */
    public WorkLocation getWorkLocationForProducing(GoodsType goodsType) {
        return first(getWorkLocationsForProducing(goodsType));
    }

    /**
     * Gets the work location best suited for the given unit to
     * produce a type of goods.
     *
     * @param unit The {@code Unit} to get the building for.
     * @param goodsType The {@code GoodsType} to produce.
     * @return The best {@code WorkLocation} found.
     */
    public WorkLocation getWorkLocationFor(Unit unit, GoodsType goodsType) {
        if (goodsType == null) return getWorkLocationFor(unit);
        Occupation occupation
                = getOccupationFor(unit, goodsType.getEquivalentTypes());
        return (occupation == null) ? null : occupation.workLocation;
    }

    /**
     * Gets the work location best suited for the given unit.
     *
     * @param unit The {@code Unit} to check for.
     * @return The best {@code WorkLocation} found.
     */
    public WorkLocation getWorkLocationFor(Unit unit) {
        Occupation occupation = getOccupationFor(unit, false);
        return (occupation == null) ? null : occupation.workLocation;
    }

    /**
     * Is a tile actually in use by this colony?
     *
     * @param tile The {@code Tile} to test.
     * @return True if this tile is actively in use by this colony.
     */
    public boolean isTileInUse(Tile tile) {
        ColonyTile colonyTile = getColonyTile(tile);
        return colonyTile != null && !colonyTile.isEmpty();
    }

    /**
     * Get the warehouse-type building in this colony.
     *
     * @return The warehouse {@code Building}.
     */
    public Building getWarehouse() {
        return getWorkLocationWithModifier(Modifier.WAREHOUSE_STORAGE,
                Building.class);
    }

    /**
     * Does this colony have a stockade?
     *
     * @return True if the colony has a stockade.
     */
    public boolean hasStockade() {
        return getStockade() != null;
    }

    /**
     * Gets the stockade building in this colony.
     *
     * @return The stockade {@code Building}.
     */
    public Building getStockade() {
        return getWorkLocationWithModifier(Modifier.DEFENCE, Building.class);
    }

    /**
     * Gets the stockade key, as should be visible to the owner
     * or a player that can see this colony.
     *
     * @return The stockade key, or null if no stockade-building is present.
     */
    public String getStockadeKey() {
        Building stockade = getStockade();
        return (stockade == null) ? null : stockade.getType().getSuffix();
    }

    /**
     * Get a weighted list of natural disasters than can strike this
     * colony.  This list comprises all natural disasters that can
     * strike the colony's tiles.
     *
     * @return A stream of {@code Disaster}s.
     */
    public Stream<RandomChoice<Disaster>> getDisasterChoices() {
        return flatten(getColonyTiles(),
                ct -> ct.getWorkTile().getDisasterChoices());
    }


    // What are we building?  What can we build?

    /**
     * Is a building type able to be automatically built at no cost.
     * True when the player has a modifier that collapses the cost to zero.
     *
     * @param buildingType a {@code BuildingType} value
     * @return True if the building is available at zero cost.
     */
    public boolean isAutomaticBuild(BuildingType buildingType) {
        float value = owner.apply(100f, getGame().getTurn(),
                Modifier.BUILDING_PRICE_BONUS, buildingType);
        return value == 0f && canBuild(buildingType);
    }

    /**
     * Gets a list of every unit type this colony may build.
     *
     * @return A list of buildable {@code UnitType}s.
     */
    public List<UnitType> getBuildableUnits() {
        return transform(getSpecification().getUnitTypeList(),
                ut -> ut.needsGoodsToBuild() && canBuild(ut));
    }

    /**
     * Returns how many turns it would take to build the given
     * {@code BuildableType}.
     *
     * @param buildable The {@code BuildableType} to build.
     * @return The number of turns to build the buildable, negative if
     *     some goods are not being built, UNDEFINED if none is.
     */
    public int getTurnsToComplete(BuildableType buildable) {
        return getTurnsToComplete(buildable, null);
    }

    /**
     * Returns how many turns it would take to build the given
     * {@code BuildableType}.
     *
     * @param buildable The {@code BuildableType} to build.
     * @param needed The {@code AbstractGoods} needed to continue
     *     the build.
     * @return The number of turns to build the buildable (which may
     *     be zero, UNDEFINED if no useful work is being done, negative
     *     if some requirement is or will block completion (value is
     *     the negation of (turns-to-blockage + 1), and if the needed
     *     argument is supplied it is set to the goods deficit).
     */
    public int getTurnsToComplete(BuildableType buildable,
                                  AbstractGoods needed) {
        final List<AbstractGoods> required = buildable.getRequiredGoodsList();
        int turns = 0, satisfied = 0, failing = 0, underway = 0;

        ProductionInfo info = productionCache.getProductionInfo(buildQueue);
        for (AbstractGoods ag : required) {
            final GoodsType type = ag.getType();
            final int amountNeeded = ag.getAmount();
            final int amountAvailable = getGoodsCount(type);
            if (amountAvailable >= amountNeeded) {
                satisfied++;
                continue;
            }
            int production = productionCache.getNetProductionOf(type);
            if (info != null) {
                AbstractGoods consumption = find(info.getConsumption(),
                        AbstractGoods.matches(type));
                if (consumption != null) {
                    // add the amount the build queue itself will consume
                    production += consumption.getAmount();
                }
            }
            if (production <= 0) {
                failing++;
                if (needed != null) {
                    needed.setType(type);
                    needed.setAmount(amountNeeded - amountAvailable);
                }
                continue;
            }

            underway++;
            int amountRemaining = amountNeeded - amountAvailable;
            int eta = amountRemaining / production;
            if (amountRemaining % production != 0) eta++;
            turns = Math.max(turns, eta);
        }

        return (satisfied + underway == required.size()) ? turns // Will finish
                : (failing == required.size()) ? UNDEFINED // Not even trying
                : -(turns + 1); // Blocked by something
    }

    /**
     * Returns {@code true} if this Colony can breed the given
     * type of Goods. Only animals (such as horses) are expected to be
     * breedable.
     *
     * @param goodsType a {@code GoodsType} value
     * @return a {@code boolean} value
     */
    public boolean canBreed(GoodsType goodsType) {
        int breedingNumber = goodsType.getBreedingNumber();
        return (breedingNumber < INFINITY
            && breedingNumber <= getGoodsCount(goodsType));
    }

    /**
     * Gets the type of building currently being built.
     *
     * @return The type of building currently being built.
     */
    public BuildableType getCurrentlyBuilding() {
        return buildQueue.getCurrentlyBuilding();
    }

    /**
     * Sets the current type of buildable to be built and if it is a building
     * insist that there is only one in the queue.
     *
     * @param buildable The {@code BuildableType} to build.
     */
    public void setCurrentlyBuilding(BuildableType buildable) {
        buildQueue.setCurrentlyBuilding(buildable);
    }

    public boolean canBuild() {
        return canBuild(getCurrentlyBuilding());
    }

    /**
     * Returns true if this Colony can build the given BuildableType.
     *
     * @param buildableType a {@code BuildableType} value
     * @return a {@code boolean} value
     */
    public boolean canBuild(BuildableType buildableType) {
        return getNoBuildReason(buildableType, null) == NoBuildReason.NONE;
    }

    /**
     * Return the reason why the give {@code BuildableType} can
     * not be built.
     *
     * @param buildableType A {@code BuildableType} to build.
     * @param assumeBuilt An optional list of other buildable types
     *     which can be assumed to be built, for the benefit of build
     *     queue checks.
     * @return A {@code NoBuildReason} value decribing the failure,
     *     including {@code NoBuildReason.NONE} on success.
     */
    public NoBuildReason getNoBuildReason(BuildableType buildableType,
                                          List<BuildableType> assumeBuilt) {
        if (buildableType == null) {
            return NoBuildReason.NOT_BUILDING;
        } else if (!buildableType.needsGoodsToBuild()) {
            return NoBuildReason.NOT_BUILDABLE;
        } else if (buildableType.getRequiredPopulation() > getUnitCount()) {
            return NoBuildReason.POPULATION_TOO_SMALL;
        } else if (buildableType.hasAbility(Ability.COASTAL_ONLY)
                && !getTile().isCoastland()) {
            return NoBuildReason.COASTAL;
        } else {
            if (any(buildableType.getRequiredAbilities().entrySet(),
                    e -> e.getValue() != hasAbility(e.getKey()))) {
                return NoBuildReason.MISSING_ABILITY;
            }
            if (!all(buildableType.getLimits(), l -> l.evaluate(this))) {
                return NoBuildReason.LIMIT_EXCEEDED;
            }
        }
        if (assumeBuilt == null) {
            assumeBuilt = Collections.<BuildableType>emptyList();
        }
        return buildableType.canBeBuiltInColony(this.getColony(), assumeBuilt);
    }

    /**
     * Returns the price for the remaining hammers and tools for the
     * {@link Building} that is currently being built.
     *
     * @return The price.
     * @see net.sf.freecol.client.control.InGameController#payForBuilding
     */
    public int getPriceForBuilding() {
        return getPriceForBuilding(getCurrentlyBuilding());
    }

    /**
     * Gets the price for the remaining resources to build a given buildable.
     *
     * @param type The {@code BuildableType} to build.
     * @return The price.
     * @see net.sf.freecol.client.control.InGameController#payForBuilding
     */
    public int getPriceForBuilding(BuildableType type) {
        return priceGoodsForBuilding(getRequiredGoods(type));
    }

    /**
     * Gets a price for a map of resources to build a given buildable.
     *
     * @param required A list of required {@code AbstractGoods}.
     * @return The price.
     * @see net.sf.freecol.client.control.InGameController#payForBuilding
     */
    public int priceGoodsForBuilding(List<AbstractGoods> required) {
        final Market market = getOwner().getMarket();
        // FIXME: magic number!
        return sum(required,
                ag -> (ag.getType().isStorable())
                        ? (market.getBidPrice(ag.getType(), ag.getAmount()) * 110)/100
                        : ag.getType().getPrice() * ag.getAmount());
    }

    /**
     * Gets a map of the types of goods and amount thereof required to
     * finish a buildable in this colony.
     *
     * @param type The {@code BuildableType} to build.
     * @return The map to completion.
     */
    public List<AbstractGoods> getRequiredGoods(BuildableType type) {
        return transform(type.getRequiredGoods(),
                ag -> ag.getAmount() > getGoodsCount(ag.getType()),
                ag -> new AbstractGoods(ag.getType(),
                        ag.getAmount() - getGoodsCount(ag.getType())));
    }

    /**
     * Gets all the goods required to complete a build.  The list
     * includes the prerequisite raw materials as well as the direct
     * requirements (i.e. hammers, tools).  If enough of a required
     * goods is present in the colony, then that type is not returned.
     * Take care to order types with raw materials first so that we
     * can prioritize gathering what is required before manufacturing.
     *
     * Public for the benefit of AI planning and the test suite.
     *
     * @param buildable The {@code BuildableType} to consider.
     * @return A list of required abstract goods.
     */
    public List<AbstractGoods> getFullRequiredGoods(BuildableType buildable) {
        if (buildable == null) return Collections.<AbstractGoods>emptyList();

        List<AbstractGoods> required = new ArrayList<>();
        for (AbstractGoods ag : buildable.getRequiredGoodsList()) {
            int amount = ag.getAmount();
            GoodsType type = ag.getType();
            while (type != null) {
                if (amount <= this.getGoodsCount(type)) break; // Shortcut
                required.add(0, new AbstractGoods(type,
                        amount - this.getGoodsCount(type)));
                type = type.getInputType();
            }
        }
        return required;
    }

    /**
     * Check if the owner can buy the remaining hammers and tools for
     * the {@link Building} that is currently being built.
     *
     * @return True if the user can afford to pay.
     * @exception IllegalStateException If the owner of this
     *     {@code Colony} has an insufficient amount of gold.
     * @see #getPriceForBuilding
     */
    public boolean canPayToFinishBuilding() {
        return canPayToFinishBuilding(getCurrentlyBuilding());
    }

    /**
     * Check if the owner can buy the remaining hammers and tools for
     * the {@link Building} given.
     *
     * @param buildableType a {@code BuildableType} value
     * @return True if the user can afford to pay.
     * @exception IllegalStateException If the owner of this
     *     {@code Colony} has an insufficient amount of gold.
     * @see #getPriceForBuilding
     */
    public boolean canPayToFinishBuilding(BuildableType buildableType) {
        return buildableType != null
                && getOwner().checkGold(getPriceForBuilding(buildableType));
    }


    // Liberty and the consequences

    /**
     * Adds to the liberty points by increasing the liberty goods present.
     * Used only by DebugMenu.
     *
     * @param amount The number of liberty to add.
     */
    public void addLiberty(int amount) {
        List<GoodsType> libertyTypeList = getSpecification()
                .getLibertyGoodsTypeList();
        final int uc = getUnitCount();
        if (amount > 0 && !libertyTypeList.isEmpty()) {
            addGoods(libertyTypeList.get(0), amount);
        }
        updateSoL();
        updateProductionBonus();
    }

    /**
     * Modify the liberty points by amount given.
     *
     * @param amount An amount of liberty.
     */
    public void modifyLiberty(int amount) {
        // Produced liberty always applies to the player (for FFs etc)
        getOwner().modifyLiberty(amount);

        liberty += amount;
        // Liberty can not meaningfully go negative.
        liberty = Math.max(0, liberty);

        updateSoL();
        updateProductionBonus();

        // If the bell accumulation cap option is set, and the colony
        // has reached 100%, liberty can not rise higher.
        boolean capped = getSpecification()
                .getBoolean(GameOptions.BELL_ACCUMULATION_CAPPED);
        if (capped && sonsOfLiberty >= 100) {
            liberty = LIBERTY_PER_REBEL * getUnitCount();
        }
    }

    /**
     * Calculates the current SoL membership of the colony based on
     * the liberty value and colonists.
     */
    public void updateSoL() {
        int uc = getUnitCount();
        this.oldSonsOfLiberty = this.sonsOfLiberty;
        this.oldTories = this.tories;
        this.sonsOfLiberty = calculateSoLPercentage(uc, getLiberty());
        this.tories = calculateToryCount(uc, this.sonsOfLiberty);
    }

    /**
     * Calculate the SoL membership percentage of this colony based on
     * a given number of colonists and liberty.
     *
     * @param uc The proposed number of units in the colony.
     * @param liberty The proposed amount of liberty.
     * @return The percentage of SoLs, negative if not calculable.
     */
    private int calculateSoLPercentage(int uc, int liberty) {
        if (uc <= 0) return -1;

        float membership = (liberty * 100.0f) / (LIBERTY_PER_REBEL * uc);
        membership = applyModifiers(membership, getGame().getTurn(),
                                    getOwner().getModifiers(Modifier.SOL));
        if (membership < 0.0f) {
            membership = 0.0f;
        } else if (membership > 100.0f) {
            membership = 100.0f;
        }
        return (int)membership;
    }

    /**
     * Calculate the number of rebels in a colony given a unit count
     * and sons-of-liberty percentage.
     *
     * @param uc The number of units in the colony.
     * @param solPercent The percentage of sons-of-liberty.
     * @return The number of rebels.
     */
    public static int calculateRebelCount(int uc, int solPercent) {
        return (int)Math.floor(0.01 * solPercent * uc);
    }

    /**
     * Calculate the number of tories in a colony given a
     * sons-of-liberty percentage and unit count.
     *
     * @param uc The number of units in the colony.
     * @param solPercent The percentage of sons-of-liberty.
     * @return The number of tories.
     */
    public static int calculateToryCount(int uc, int solPercent) {
        return uc - calculateRebelCount(uc, solPercent);
    }

    /**
     * Calculate the colony production bonus for a given
     * sons-of-liberty percentage.
     *
     * @param solPercent The sons-of-liberty percentage to use.
     * @return The production bonus.
     */
    private int calculateProductionBonus(int solPercent) {
        final Specification spec = getSpecification();
        final int veryBadGovernment
            = spec.getInteger(GameOptions.VERY_BAD_GOVERNMENT_LIMIT);
        final int badGovernment
            = spec.getInteger(GameOptions.BAD_GOVERNMENT_LIMIT);
        final int veryGoodGovernment
            = spec.getInteger(GameOptions.VERY_GOOD_GOVERNMENT_LIMIT);
        final int goodGovernment
            = spec.getInteger(GameOptions.GOOD_GOVERNMENT_LIMIT);
        if (solPercent >= veryGoodGovernment) return GOVERNMENT_VERY_GOOD;
        if (solPercent >= goodGovernment) return GOVERNMENT_GOOD;
        int tc = calculateToryCount(getUnitCount(), solPercent);
        return (tc > veryBadGovernment) ? GOVERNMENT_VERY_BAD
            : (tc > badGovernment) ? GOVERNMENT_BAD
            : GOVERNMENT_ORDINARY;
    }        

    /**
     * Update the colony's production bonus.
     *
     * @return True if the bonus changed.
     */
    protected boolean updateProductionBonus() {
        int newBonus = calculateProductionBonus(sonsOfLiberty);
        if (productionBonus != newBonus) {
            invalidateCache();
            setProductionBonus(newBonus);
            return true;
        }
        return false;
    }

    /**
     * Gets the number of units that would be good to add/remove from this
     * colony.  That is the number of extra units that can be added without
     * damaging the production bonus, or the number of units to remove to
     * improve it.
     *
     * @return The number of units to add to the colony, or if negative
     *      the negation of the number of units to remove.
     */
    public int getPreferredSizeChange() {
        return productionBonus < 0 ? -getUnitsToRemove() : getUnitsToAdd();
    }

    public int getUnitsToAdd() {
        int pop = getUnitCount();
        for (int i = 1; i <= CHANGE_UPPER_BOUND; i++) {
            if (governmentChange(pop + i) == -1) {
                return i - 1;
            }
        }
        return CHANGE_UPPER_BOUND;
    }

    public int getUnitsToRemove() {
        int pop = getUnitCount();
        for (int i = 1; i < pop; i++) {
            if (governmentChange(pop - i) == 1) {
                return i;
            }
        }
        return 0;
    }

    /**
     * The RebelToolTip shows many things, but the number of turns to
     * the next bonus point needs to account for the bonuses in
     * calculateSoLPercentage, which is an awkward calculation to do
     * in reverse.  Given the tooltip already calculates the
     * libertyProduction, we use that and count forward to the turns
     * it takes to reach the next bonus change, the good government
     * mark, and the very good government mark.
     *
     * @param libertyProduction The projected colony liberty production.
     * @return A list of number of turns to next,good,very good bonus marks.
     */
    public List<Integer> rebelHelper(int libertyProduction) {
        List<Integer> ret = new ArrayList<>();
        ret.add(-1);
        ret.add(-1);
        ret.add(-1);
        if (libertyProduction <= 0) return ret;

        final int uc = getUnitCount();
        int liberty = getLiberty();
        int soLPercent = calculateSoLPercentage(uc, liberty);
        int bonus0 = calculateProductionBonus(soLPercent);

        int n = 0, bonus = bonus0;
        for (;;) {
            if (bonus != bonus0 && ret.get(0) < 0) {
                ret.set(0, n);
            }
            if (bonus == GOVERNMENT_GOOD && ret.get(1) < 0) {
                ret.set(1, n);
            }
            if (bonus == GOVERNMENT_VERY_GOOD && ret.get(2) < 0) {
                ret.set(2, n);
                break;
            }
            liberty += libertyProduction;
            soLPercent = calculateSoLPercentage(uc, liberty);
            bonus = calculateProductionBonus(soLPercent);
            n++;
        }
        return ret;
    }
            

    // Unit manipulation and population

    /**
     * Special routine to handle non-specific add of unit to colony.
     *
     * @param unit The {@code Unit} to add.
     * @return True if the add succeeds.
     */
    public boolean joinColony(Unit unit) {
        boolean ret;
        Occupation occupation = getOccupationFor(unit, false);
        if (occupation == null) {
            if (!traceOccupation) {
                LogBuilder lb = new LogBuilder(64);
                getOccupationFor(unit, false, lb);
                lb.log(logger, Level.WARNING);
            }
            ret = false;
        } else {
            ret = occupation.install(unit);
        }
        if (!ret) {
            unit.setLocation(getTile()); // Fall back to safe value
            logger.warning("Failed to join " + getName() + ": " + unit);
        }
        return ret;
    }

    /**
     * Can this colony reduce its population voluntarily?
     *
     * This is generally the case, but can be prevented by buildings
     * such as the stockade in classic mode.
     *
     * @return True if the population can be reduced.
     */
    public boolean canReducePopulation() {
        return getUnitCount() > apply(0f, getGame().getTurn(),
                Modifier.MINIMUM_COLONY_SIZE);
    }

    /**
     * Gets the message to display if the colony can not reduce its
     * population.
     *
     * @return A {@code StringTemplate} describing why a colony
     *     can not reduce its population, or null if it can.
     */
    public StringTemplate getReducePopulationMessage() {
        if (canReducePopulation()) return null;
        Modifier min = first(getModifiers(Modifier.MINIMUM_COLONY_SIZE));
        if (min == null) return null;
        FreeColObject source = min.getSource();
        if (source instanceof BuildingType) {
            // If the modifier source is a building type, use the
            // building in the colony, which may be of a different
            // level to the modifier source.
            // This prevents the stockade modifier from matching a
            // colony-fort, and thus the message attributing the
            // failure to reduce population to a non-existing
            // stockade, BR#3522055.
            source = getBuilding((BuildingType)source).getType();
        }
        return StringTemplate.template("model.colony.minimumColonySize")
                .addName("%object%", source);
    }

    /**
     * Gets the message to display if a colony can not build something.
     *
     * @param buildable The {@code BuildableType} that can not be built.
     * @return A {@code ModelMessage} describing the build failure.
     */
    public ModelMessage getUnbuildableMessage(BuildableType buildable) {
        return new ModelMessage(ModelMessage.MessageType.WARNING,
                "model.colony.unbuildable", this, buildable)
                .addName("%colony%", getName())
                .addNamed("%object%", buildable);
    }

    /**
     * Returns 1, 0, or -1 to indicate that government would improve,
     * remain the same, or deteriorate if the colony had the given
     * population.
     *
     * @param unitCount The proposed population for the colony.
     * @return 1, 0 or -1.
     */
    public int governmentChange(int unitCount) {
        final Specification spec = getSpecification();
        final int veryBadGovernment
                = spec.getInteger(GameOptions.VERY_BAD_GOVERNMENT_LIMIT);
        final int badGovernment
                = spec.getInteger(GameOptions.BAD_GOVERNMENT_LIMIT);
        final int veryGoodGovernment
                = spec.getInteger(GameOptions.VERY_GOOD_GOVERNMENT_LIMIT);
        final int goodGovernment
                = spec.getInteger(GameOptions.GOOD_GOVERNMENT_LIMIT);

        int newSoLPercent = calculateSoLPercentage(unitCount, getLiberty());
        int newToryCount = calculateToryCount(unitCount, newSoLPercent);
        int oldSoLPercent = getSonsOfLiberty();
        int oldToryCount = getToryCount();
        
        int result = 0;
        if (newSoLPercent >= veryGoodGovernment) { // There are no tories left.
            if (oldSoLPercent < veryGoodGovernment) {
                result = 1;
            }
        } else if (newSoLPercent >= goodGovernment) {
            if (oldSoLPercent >= veryGoodGovernment) {
                result = -1;
            } else if (oldSoLPercent < goodGovernment) {
                result = 1;
            }
        } else {
            if (oldSoLPercent >= goodGovernment) {
                result = -1;
            } else { // Now that no bonus is applied, penalties may.
                if (newToryCount > veryBadGovernment) {
                    if (oldToryCount <= veryBadGovernment) {
                        result = -1;
                    }
                } else if (newToryCount > badGovernment) {
                    if (oldToryCount <= badGovernment) {
                        result = -1;
                    } else if (oldToryCount > veryBadGovernment) {
                        result = 1;
                    }
                } else {
                    if (oldToryCount > badGovernment) {
                        result = 1;
                    }
                }
            }
        }
        return result;
    }

    /**
     * Has the government bonus changed?  If so, return a suitable message.
     *
     * @return A {@code ModelMessage} describing the change, or null if none.
     */
    public ModelMessage checkForGovMgtChangeMessage() {
        final Specification spec = getSpecification();
        final int veryBadGovernment
                = spec.getInteger(GameOptions.VERY_BAD_GOVERNMENT_LIMIT);
        final int badGovernment
                = spec.getInteger(GameOptions.BAD_GOVERNMENT_LIMIT);
        final int veryGoodGovernment
                = spec.getInteger(GameOptions.VERY_GOOD_GOVERNMENT_LIMIT);
        final int goodGovernment
                = spec.getInteger(GameOptions.GOOD_GOVERNMENT_LIMIT);

        String msgId = null;
        int number = 0;
        ModelMessage.MessageType msgType = ModelMessage.MessageType.GOVERNMENT_EFFICIENCY;
        if (this.sonsOfLiberty >= veryGoodGovernment) {
            // there are no tories left
            if (this.oldSonsOfLiberty < veryGoodGovernment) {
                msgId = "model.colony.veryGoodGovernment";
                msgType = ModelMessage.MessageType.SONS_OF_LIBERTY;
                number = veryGoodGovernment;
            }
        } else if (this.sonsOfLiberty >= goodGovernment) {
            if (this.oldSonsOfLiberty == veryGoodGovernment) {
                msgId = "model.colony.lostVeryGoodGovernment";
                msgType = ModelMessage.MessageType.SONS_OF_LIBERTY;
                number = veryGoodGovernment;
            } else if (this.oldSonsOfLiberty < goodGovernment) {
                msgId = "model.colony.goodGovernment";
                msgType = ModelMessage.MessageType.SONS_OF_LIBERTY;
                number = goodGovernment;
            }
        } else {
            if (this.oldSonsOfLiberty >= goodGovernment) {
                msgId = "model.colony.lostGoodGovernment";
                msgType = ModelMessage.MessageType.SONS_OF_LIBERTY;
                number = goodGovernment;
            }

            // Now that no bonus is applied, penalties may.
            if (this.tories > veryBadGovernment) {
                if (this.oldTories <= veryBadGovernment) {
                    // government has become very bad
                    msgId = "model.colony.veryBadGovernment";
                }
            } else if (this.tories > badGovernment) {
                if (this.oldTories <= badGovernment) {
                    // government has become bad
                    msgId = "model.colony.badGovernment";
                } else if (this.oldTories > veryBadGovernment) {
                    // government has improved, but is still bad
                    msgId = "model.colony.governmentImproved1";
                }
            } else if (this.oldTories > badGovernment) {
                // government was bad, but has improved
                msgId = "model.colony.governmentImproved2";
            }
        }

        GoodsType bells = getSpecification().getGoodsType("model.goods.bells");
        return (msgId == null) ? null
                : new ModelMessage(msgType, msgId, this, bells)
                .addName("%colony%", getName())
                .addAmount("%number%", number);
    }

    /**
     * Signal to the colony that its population is changing.
     * Called from Unit.setLocation when a unit moves into or out of this
     * colony, but *not* if it is moving within the colony.
     */
    public void updatePopulation() {
        updateSoL();
        updateProductionBonus();
        if (getOwner().isAI()) {
            firePropertyChange(Colony.REARRANGE_COLONY, true, false);
        }
    }

    /**
     * Signal to the colony that a unit is moving in or out or
     * changing its internal work location to one with a different
     * teaching ability.  This requires either checking for a new
     * teacher or student, or clearing any existing education
     * relationships.
     *
     * @param unit The {@code Unit} that is changing its education state.
     * @param enable If true, check for new education opportunities, otherwise
     *     clear existing ones.
     */
    public void updateEducation(Unit unit, boolean enable) {
        WorkLocation wl = unit.getWorkLocation();
        if (wl == null) {
            throw new RuntimeException("updateEducation(" + unit
                    + ") unit not at work location.");
        } else if (wl.getColony() != this) {
            throw new RuntimeException("updateEducation(" + unit
                    + ") unit not at work location in this colony.");
        }
        if (enable) {
            if (wl.canTeach()) {
                Unit student = unit.getStudent();
                if (student == null
                        && (student = findStudent(unit)) != null) {
                    unit.setStudent(student);
                    student.setTeacher(unit);
                    unit.setTurnsOfTraining(0);// Teacher starts teaching
                    unit.changeWorkType(null);
                }
            } else {
                Unit teacher = unit.getTeacher();
                if (teacher == null
                        && (teacher = findTeacher(unit)) != null) {
                    unit.setTeacher(teacher);
                    teacher.setStudent(unit);
                }
            }
        } else {
            if (wl.canTeach()) {
                Unit student = unit.getStudent();
                if (student != null) {
                    student.setTeacher(null);
                    unit.setStudent(null);
                    unit.setTurnsOfTraining(0);// Teacher stops teaching
                }
            } else {
                Unit teacher = unit.getTeacher();
                if (teacher != null) {
                    teacher.setStudent(null);
                    unit.setTeacher(null);
                }
            }
        }
    }

    /**
     * Does this colony have undead units?
     *
     * @return True if this colony has undead units.
     */
    public boolean isUndead() {
        Unit u = getFirstUnit();
        return u != null && u.isUndead();
    }

    /**
     * Gets the apparent number of units at this colony.
     * Used in client enemy colonies
     *
     * @return The apparent number of {@code Unit}s at this colony.
     */
    public int getApparentUnitCount() {
        return (this.displayUnitCount > 0) ? this.displayUnitCount
            : getUnitCount();
    }


    // Defence, offense and trade response

    /**
     * Gets the best defender type available to this colony.
     *
     * @return The best available defender type.
     */
    public UnitType getBestDefenderType() {
        final Predicate<UnitType> defenderPred = ut ->
                ut.getDefence() > 0
                        && !ut.isNaval()
                        && ut.isAvailableTo(getOwner());
        return maximize(getSpecification().getUnitTypeList(), defenderPred,
                UnitType.defenceComparator);
    }

    /**
     * Gets the total defence power.
     *
     * @return The total defence power.
     */
    public double getTotalDefencePower() {
        final CombatModel cm = getGame().getCombatModel();
        return sumDouble(getTile().getUnits(), Unit::isDefensiveUnit,
                u -> cm.getDefencePower(null, u));
    }

    /**
     * Determines whether this colony is sufficiently unprotected and
     * contains something worth pillaging.  To be called by CombatModels
     * when the attacker has defeated an unarmed colony defender.
     *
     * @param attacker The {@code Unit} that has defeated the defender.
     * @return True if the attacker can pillage this colony.
     */
    public boolean canBePillaged(Unit attacker) {
        return !hasStockade()
                && attacker.hasAbility(Ability.PILLAGE_UNPROTECTED_COLONY)
                && !(getBurnableBuildings().isEmpty()
                && getTile().getNavalUnits().isEmpty()
                && (getLootableGoodsList().isEmpty()
                || !attacker.getType().canCarryGoods()
                || !attacker.hasSpaceLeft())
                && !canBePlundered());
    }

    /**
     * Checks if this colony can be plundered.  That is, can it yield
     * non-zero gold.
     *
     * @return True if at least one piece of gold can be plundered from this
     *     colony.
     */
    public boolean canBePlundered() {
        return owner.checkGold(1);
    }

    /**
     * Gets the buildings in this colony that could be burned by a raid.
     *
     * @return A list of burnable buildings.
     */
    public List<Building> getBurnableBuildings() {
        return transform(getBuildings(), Building::canBeDamaged);
    }

    /**
     * Gets a list of all stored goods in this colony, suitable for
     * being looted.
     *
     * @return A list of lootable goods in this colony.
     */
    public List<Goods> getLootableGoodsList() {
        return transform(getGoodsList(), AbstractGoods::isStorable);
    }

    /**
     * Decide if the number of enemy combat units on all tiles that
     * belong to the colony exceeds the number of friendly combat
     * units. At the moment, only the colony owner's own units are
     * considered friendly, but that could be extended to include the
     * units of allied players.
     *
     * FIXME: if a colony is under siege, it should not be possible to
     * put units outside the colony, unless those units are armed.
     *
     * @return Whether the colony is under siege.
     */
    public boolean isUnderSiege() {
        int friendlyUnits = 0;
        int enemyUnits = 0;
        for (Unit u : iterable(flatten(getColonyTiles(),
                ct -> ct.getWorkTile().getUnits()))) {
            if (u.getOwner() == getOwner()) {
                if (u.isDefensiveUnit()) friendlyUnits++;
            } else if (getOwner().atWarWith(u.getOwner())) {
                if (u.isOffensiveUnit()) enemyUnits++;
            }
        }
        return enemyUnits > friendlyUnits;
    }

    /**
     * Evaluate this colony for a given player.
     *
     * @param player The {@code Player} to evaluate for.
     * @return A value for the player.
     */
    public int evaluateFor(Player player) {
        if (player.isAI()
            && player.owns(this)
            && player.getSettlementCount() < Colony.TRADE_MARGIN) {
            return Integer.MIN_VALUE;
        }
        int result, v;
        if (player.owns(this)) {
            result = 0;
            for (WorkLocation wl : getAvailableWorkLocationsList()) {
                v = wl.evaluateFor(player);
                if (v == Integer.MIN_VALUE) return Integer.MIN_VALUE;
                result += v;
            }
            for (Unit u : getTile().getUnitList()) {
                v = u.evaluateFor(player);
                if (v == Integer.MIN_VALUE) return Integer.MIN_VALUE;
                result += v;
            }
            for (Goods g : getCompactGoodsList()) {
                v = g.evaluateFor(player);
                if (v == Integer.MIN_VALUE) return Integer.MIN_VALUE;
                result += v;
            }
        } else { // Much guesswork
            result = getApparentUnitCount() * 1000
                    + 500 // Some useful goods?
                    + 200 * count(getTile().getSurroundingTiles(0, 1),
                    matchKey(this, Tile::getOwningSettlement));
            Building stockade = getStockade();
            if (stockade != null) result *= stockade.getLevel();
        }
        return result;
    }


    // Education

    /**
     * Returns true if this colony has a schoolhouse and the unit type is a
     * skilled unit type with a skill level not exceeding the level of the
     * schoolhouse. @see Building#canAdd
     *
     * @param unit The unit to add as a teacher.
     * @return {@code true} if this unit type could be added.
     */
    public boolean canTrain(Unit unit) {
        return canTrain(unit.getType());
    }

    /**
     * Returns true if this colony has a schoolhouse and the unit type is a
     * skilled unit type with a skill level not exceeding the level of the
     * schoolhouse. The number of units already in the schoolhouse and
     * the availability of pupils are not taken into account. @see
     * Building#canAdd
     *
     * @param unitType The unit type to add as a teacher.
     * @return {@code true} if this unit type could be added.
     */
    public boolean canTrain(UnitType unitType) {
        return hasAbility(Ability.TEACH)
                && any(getBuildings(),
                b -> b.canTeach() && b.canAddType(unitType));
    }

    /**
     * Gets a list of all teachers currently present in the school
     * building.
     *
     * @return A stream of teacher {@code Unit}s.
     */
    public Stream<Unit> getTeachers() {
        return flatten(getBuildings(), Building::canTeach, Building::getUnits);
    }

    /**
     * Find a teacher for the specified student.
     * Do not search if ALLOW_STUDENT_SELECTION is true--- it is the
     * player's job then.
     *
     * @param student The student {@code Unit} that needs a teacher.
     * @return A potential teacher, or null of none found.
     */
    public Unit findTeacher(Unit student) {
        return (getSpecification().getBoolean(GameOptions.ALLOW_STUDENT_SELECTION))
            ? null // No automatic assignment
            : find(getTeachers(), u ->
                u.getStudent() == null && student.canBeStudent(u));
    }

    /**
     * Find a student for the specified teacher.
     * Do not search if ALLOW_STUDENT_SELECTION is true--- its the
     * player's job then.
     *
     * @param teacher The teacher {@code Unit} that needs a student.
     * @return A potential student, or null of none found.
     */
    public Unit findStudent(final Unit teacher) {
        if (getSpecification().getBoolean(GameOptions.ALLOW_STUDENT_SELECTION))
            return null; // No automatic assignment
        final GoodsType expertProduction
                = teacher.getType().getExpertProduction();
        final Predicate<Unit> teacherPred = u ->
                u.getTeacher() == null && u.canBeStudent(teacher);
        // Always pick the student with the least skill first.
        // Break ties by favouring the one working in the teacher's trade,
        // otherwise first applicant wins.
        final Comparator<Unit> skillComparator
                = Comparator.comparingInt(Unit::getSkillLevel);
        final Comparator<Unit> tradeComparator
                = Comparator.comparingInt(u ->
                (u.getWorkType() == expertProduction) ? 0 : 1);
        final Comparator<Unit> fullComparator
                = skillComparator.thenComparing(tradeComparator);
        return minimize(getUnits(), teacherPred, fullComparator);
    }


    // Production and consumption

    /**
     * Does this colony produce a goods type?
     *
     * This is more reliable than checking net or total production,
     * either of which might be cancelling to zero.
     *
     * @param goodsType The {@code GoodsType} to check.
     * @return True if goods type is produced.
     */
    public boolean isProducing(GoodsType goodsType) {
        return productionCache.isProducing(goodsType);
    }

    /**
     * Does this colony consume a goods type?
     *
     * This is more reliable than checking net or total consumption,
     * either of which might be cancelling to zero.
     *
     * @param goodsType The {@code GoodsType} to check.
     * @return True if goods type is consumed.
     */
    public boolean isConsuming(GoodsType goodsType) {
        return productionCache.isConsuming(goodsType);
    }

    /**
     * Get a list of all {@link Consumer}s in the colony sorted by
     * priority. Consumers include all object that consume goods,
     * e.g. Units, Buildings and BuildQueues.
     *
     * @return a list of consumers
     */
    public List<Consumer> getConsumers() {
        List<Consumer> result = new ArrayList<>();
        result.addAll(getUnitList());
        result.addAll(getBuildings());
        result.add(buildQueue);
        result.add(populationQueue);
        result.sort(Consumer.COMPARATOR);
        return result;
    }

    /**
     * Returns the number of goods of a given type used by the settlement
     * each turn.
     *
     * @param goodsType {@code GoodsType} values
     * @return an {@code int} value
     */
    @Override
    public int getConsumptionOf(GoodsType goodsType) {
        final Specification spec = getSpecification();
        int result = super.getConsumptionOf(goodsType);
        if (spec.getGoodsType("model.goods.bells").equals(goodsType)) {
            result -= spec.getInteger(GameOptions.UNITS_THAT_USE_NO_BELLS);
        }
        return Math.max(0, result);
    }

    /**
     * Gets the combined production of all food types.
     *
     * @return an {@code int} value
     */
    public int getFoodProduction() {
        return sum(getSpecification().getFoodGoodsTypeList(),
                ft -> getTotalProductionOf(ft));
    }

    /**
     * Get the number of turns before starvation occurs at this colony
     * with current production levels.
     *
     * @return The number of turns before starvation occurs, or negative
     *     if it will not.
     */
    public int getStarvationTurns() {
        final GoodsType foodType = getSpecification().getPrimaryFoodType();
        final int food = getGoodsCount(foodType);
        final int newFood = getAdjustedNetProductionOf(foodType);
        return (newFood >= 0) ? -1 : food / -newFood;
    }

    /**
     * Get the number of turns before a new colonist will be born in
     * this colony with current production levels.
     *
     * @return A number of turns, or negative if no colonist will be born.
     */
    public int getNewColonistTurns() {
        final GoodsType foodType = getSpecification().getPrimaryFoodType();
        final int food = getGoodsCount(foodType);
        final int newFood = getAdjustedNetProductionOf(foodType);
        return (food + newFood >= Settlement.FOOD_PER_COLONIST) ? 1
                : (newFood <= 0) ? -1
                : (Settlement.FOOD_PER_COLONIST - food) / newFood + 1;
    }


    /**
     * Get the current production {@code Modifier}, which is
     * generated from the current production bonus.
     *
     * @param goodsType The {@code GoodsType} to produce.
     * @param unitType An optional {@code UnitType} to do the work.
     * @param wl The {@link WorkLocation}
     * @return A stream of suitable {@code Modifier}s.
     */
    public Stream<Modifier> getProductionModifiers(GoodsType goodsType,
                                                   UnitType unitType, WorkLocation wl) {
        if (productionBonus == 0) return Stream.<Modifier>empty();
        int bonus = (int)Math.floor(productionBonus * wl.getRebelFactor());
        Modifier mod = new Modifier(goodsType.getId(), bonus,
                Modifier.ModifierType.ADDITIVE,
                Specification.SOL_MODIFIER_SOURCE);
        mod.setModifierIndex(Modifier.COLONY_PRODUCTION_INDEX);
        return Stream.of(mod);
    }

    /**
     * Get the net production of the given goods type.
     *
     * (Also part of interface TradeLocation)
     *
     * @param goodsType a {@code GoodsType} value
     * @return an {@code int} value
     */
    public int getNetProductionOf(GoodsType goodsType) {
        return productionCache.getNetProductionOf(goodsType);
    }

    /**
     * Is a work location productive?
     *
     * @param workLocation The {@code WorkLocation} to check.
     * @return True if something is being produced at the
     *     {@code WorkLocation}.
     */
    public boolean isProductive(WorkLocation workLocation) {
        ProductionInfo info = productionCache.getProductionInfo(workLocation);
        return info != null && info.getProduction() != null
                && !info.getProduction().isEmpty()
                && info.getProduction().get(0).getAmount() > 0;
    }

    /**
     * Returns the net production of the given GoodsType adjusted by
     * the possible consumption of BuildQueues.
     *
     * @param goodsType a {@code GoodsType} value
     * @return an {@code int} value
     */
    public int getAdjustedNetProductionOf(final GoodsType goodsType) {
        final ToIntFunction<BuildQueue> consumes = q -> {
            ProductionInfo pi = productionCache.getProductionInfo(q);
            return (pi == null) ? 0
                    : AbstractGoods.getCount(goodsType, pi.getConsumption());
        };
        return productionCache.getNetProductionOf(goodsType)
                + sum(Stream.of(buildQueue, populationQueue), consumes);
    }

    /**
     * Gets a copy of the current production map.
     * Useful in the server at the point net production is applied to a colony.
     *
     * @return A copy of the current production map.
     */
    protected TypeCountMap<GoodsType> getProductionMap() {
        return productionCache.getProductionMap();
    }

    /**
     * Returns the ProductionInfo for the given Object.
     *
     * @param object an {@code Object} value
     * @return a {@code ProductionInfo} value
     */
    public ProductionInfo getProductionInfo(Object object) {
        return productionCache.getProductionInfo(object);
    }

    /**
     * Update all the production types.
     *
     * Called at initialization, to default to something rational when
     * nothing was specified.  This can not be done until all the tiles are
     * present.
     */
    public void updateProductionTypes() {
        for (WorkLocation wl : getAvailableWorkLocationsList()) {
            wl.updateProductionType();
        }
    }

    /**
     * Can this colony produce certain goods?
     *
     * @param goodsType The {@code GoodsType} to check production of.
     * @return True if the goods can be produced.
     */
    public boolean canProduce(GoodsType goodsType) {
        return (getNetProductionOf(goodsType) > 0)
                ? true // Obviously:-)

                // Breeding requires the breedable number to be present
                : (goodsType.isBreedable())
                ? getGoodsCount(goodsType) >= goodsType.getBreedingNumber()

                // Is there a work location that can produce the goods, with
                // positive generic production potential and all inputs satisfied?
                : any(getWorkLocationsForProducing(goodsType),
                wl -> wl.getGenericPotential(goodsType) > 0
                        && all(wl.getInputs(), ag -> canProduce(ag.getType())));
    }


    // Planning support

    /** Container class for tile exploration or improvement suggestions. */
    public static class TileImprovementSuggestion {

        /**
         * Comparator to order suggestions by descending improvement
         * amount.
         */
        public static final Comparator<TileImprovementSuggestion> descendingAmountComparator
                = Comparator.comparingInt(TileImprovementSuggestion::getAmount)
                .reversed()
                .thenComparing(tis -> (FreeColObject)tis.tile);

        /** The tile to explore or improve. */
        public Tile tile;
        /** The tile improvement to make, or if null to explore an LCR. */
        public TileImprovementType tileImprovementType;
        /** The expected improvement.  INFINITY for LCRs. */
        public int amount;


        public TileImprovementSuggestion(Tile tile, TileImprovementType t,
                                         int amount) {
            this.tile = tile;
            this.tileImprovementType = t;
            this.amount = amount;
        }

        public boolean isExploration() {
            return this.tileImprovementType == null;
        }

        public int getAmount() {
            return this.amount;
        }
    };

    /**
     * Collect suggestions for tiles that need exploration or
     * improvement (which may depend on current use within the colony).
     *
     * @return A list of {@code TileImprovementSuggestion}s.
     */
    public List<TileImprovementSuggestion> getTileImprovementSuggestions() {
        final Specification spec = getSpecification();

        // Encourage exploration of neighbouring rumours.
        List<TileImprovementSuggestion> result
                = transform(getTile().getSurroundingTiles(1, 1),
                Tile::hasLostCityRumour,
                t -> new TileImprovementSuggestion(t, null, INFINITY));

        // Consider improvements for all available colony tiles.
        for (final ColonyTile ct : transform(getColonyTiles(),
                WorkLocation::isAvailable)) {
            final ToIntFunction<TileImprovementType> improve = cacheInt(ti ->
                    ct.improvedBy(ti));
            result.addAll(transform(spec.getTileImprovementTypeList(),
                    ti -> !ti.isNatural() && improve.applyAsInt(ti) > 0,
                    ti -> new TileImprovementSuggestion(ct.getWorkTile(),
                            ti, improve.applyAsInt(ti))));
        }
        result.sort(TileImprovementSuggestion.descendingAmountComparator);
        return result;
    }

    /**
     * Finds another unit in this colony that would be better at doing the
     * job of the specified unit.
     *
     * @param expert The {@code Unit} to consider.
     * @return A better expert, or null if none available.
     */
    public Unit getBetterExpert(Unit expert) {
        GoodsType production = expert.getWorkType();
        UnitType expertType = expert.getType();
        GoodsType expertise = expertType.getExpertProduction();
        Unit bestExpert = null;
        int bestImprovement = 0;

        if (production == null || expertise == null
                || production == expertise) return null;

        // We have an expert not doing the job of their expertise.
        // Check if there is a non-expert doing the job instead.
        for (Unit nonExpert : transform(getUnits(), u ->
                u.getWorkType() == expertise && u.getType() != expertType)) {

            // We have found a unit of a different type doing the
            // job of this expert's expertise now check if the
            // production would be better if the units swapped
            // positions.
            int expertProductionNow = 0;
            int nonExpertProductionNow = 0;
            int expertProductionPotential = 0;
            int nonExpertProductionPotential = 0;

            // Get the current and potential productions for the
            // work location of the expert.
            WorkLocation ewl = expert.getWorkLocation();
            if (ewl != null) {
                expertProductionNow = ewl.getPotentialProduction(expertise,
                        expert.getType());
                nonExpertProductionPotential
                        = ewl.getPotentialProduction(expertise,
                        nonExpert.getType());
            }

            // Get the current and potential productions for the
            // work location of the non-expert.
            WorkLocation nwl = nonExpert.getWorkLocation();
            if (nwl != null) {
                nonExpertProductionNow = nwl.getPotentialProduction(expertise,
                        nonExpert.getType());
                expertProductionPotential
                        = nwl.getPotentialProduction(expertise, expertType);
            }

            // Find the unit that achieves the best improvement.
            int improvement = expertProductionPotential
                    + nonExpertProductionPotential
                    - expertProductionNow
                    - nonExpertProductionNow;
            if (improvement > bestImprovement) {
                bestImprovement = improvement;
                bestExpert = nonExpert;
            }
        }
        return bestExpert;
    }

    /**
     * Determine if there is a problem with the production of a given
     * goods type.
     *
     * @param goodsType The {@code GoodsType} to check.
     * @return A collection of warning messages.
     */
    public Collection<StringTemplate> getProductionWarnings(GoodsType goodsType) {
        final int amount = getGoodsCount(goodsType);
        final int production = getNetProductionOf(goodsType);
        List<StringTemplate> result = new ArrayList<>();

        if (goodsType.isStorable()) {
            if (goodsType.limitIgnored()) {
                if (goodsType.isFoodType()) { // Check for famine/starvation
                    int starve = getStarvationTurns();
                    if (starve == 0) {
                        result.add(StringTemplate
                                .template("model.colony.starving")
                                .addName("%colony%", getName()));
                    } else if (starve <= Colony.FAMINE_TURNS) {
                        result.add(StringTemplate
                                .template("model.colony.famineFeared")
                                .addName("%colony%", getName())
                                .addAmount("%number%", starve));
                    }
                }
            } else { // Check for overflow
                int waste;
                if (!getExportData(goodsType).getExported()
                        && (waste = amount + production - getWarehouseCapacity()) > 0) {
                    result.add(StringTemplate
                            .template("model.building.warehouseSoonFull")
                            .addNamed("%goods%", goodsType)
                            .addName("%colony%", getName())
                            .addAmount("%amount%", waste));
                }
            }
        }

        // Add a message for goods required for the current building if any.
        BuildableType currentlyBuilding = getCurrentlyBuilding();
        if (currentlyBuilding != null) {
            final Function<AbstractGoods, StringTemplate> bMapper = ag ->
                    StringTemplate.template("model.colony.buildableNeedsGoods")
                            .addName("%colony%", getName())
                            .addNamed("%buildable%", currentlyBuilding)
                            .addAmount("%amount%", ag.getAmount() - amount)
                            .addNamed("%goodsType%", goodsType);
            result.addAll(transform(currentlyBuilding.getRequiredGoods(),
                    ag -> ag.getType() == goodsType
                            && amount < ag.getAmount(),
                    bMapper));
        }

        // Add insufficient production messages for each production location
        // that has a deficit in producing the goods type.
        final Function<WorkLocation, ProductionInfo> piMapper = wl ->
                getProductionInfo(wl);
        final Predicate<WorkLocation> prodPred = isNotNull(piMapper);
        final Function<WorkLocation, StringTemplate> pMapper = wl ->
                getInsufficientProductionMessage(getProductionInfo(wl),
                        wl.getProductionDeficit(goodsType));
        result.addAll(transform(getWorkLocationsForProducing(goodsType),
                prodPred, pMapper, toListNoNulls()));

        // Add insufficient production messages for each consumption
        // location for the goods type where there is a consequent
        // deficit in production of a dependent goods.
        final Function<WorkLocation, List<StringTemplate>> cMapper = wl -> {
            final ProductionInfo info = getProductionInfo(wl);
            final Function<AbstractGoods, StringTemplate> gMapper = ag ->
                    getInsufficientProductionMessage(info,
                            wl.getProductionDeficit(ag.getType()));
            return transform(wl.getOutputs(), AbstractGoods::isStorable,
                    gMapper, toListNoNulls());
        };
        result.addAll(transform(getWorkLocationsForConsuming(goodsType),
                prodPred, cMapper, toAppendedList()));

        return result;
    }

    /**
     * Get a message about insufficient production for a building
     *
     * @param info The {@code ProductionInfo} for the work location.
     * @param deficit The {@code AbstractGoods} in deficit.
     * @return A suitable {@code StringTemplate} or null if none required.
     */
    private StringTemplate getInsufficientProductionMessage(ProductionInfo info,
                                                            AbstractGoods deficit) {
        if (info == null || deficit == null) return null;

        List<AbstractGoods> input = info.getConsumptionDeficit();
        if (input.isEmpty()) return null;
        StringTemplate label = StringTemplate.label(", ");
        for (AbstractGoods ag : input) label.addStringTemplate(ag.getLabel());

        return StringTemplate.template("model.colony.insufficientProduction")
                .addName("%colony%", getName())
                .addNamed("%outputType%", deficit.getType())
                .addAmount("%outputAmount%", deficit.getAmount())
                .addStringTemplate("%consumptionDeficit%", label);
    }

    /**
     * Check if a goods type is still useful to this colony.
     *
     * In general, all goods are useful.  However post-independence there is
     * no need for more liberty once Sol% reaches 100, nor immigration.
     * Note the latter may change when we implement sailing to other European
     * ports.
     *
     * @param goodsType The {@code GoodsType} to check.
     * @return True if these goods are still useful here.
     */
    public boolean goodsUseful(GoodsType goodsType) {
        if (getOwner().getPlayerType() == Player.PlayerType.INDEPENDENT) {
            if ((goodsType.isLibertyType() && getSonsOfLiberty() >= 100)
                    || goodsType.isImmigrationType()) return false;
        }
        return true;
    }

    /**
     * Special goods need modifiers applied when changed, and immigration
     * accumulates to the owner.
     *
     * @param goodsType The {@code GoodsType} to modify.
     * @param amount The amount of modification.
     */
    private void modifySpecialGoods(GoodsType goodsType, int amount) {
        final Turn turn = getGame().getTurn();
        List<Modifier> mods;

        mods = toList(goodsType.getModifiers(Modifier.LIBERTY));
        if (!mods.isEmpty()) {
            modifyLiberty((int)applyModifiers(amount, turn, mods));
        }

        mods = toList(goodsType.getModifiers(Modifier.IMMIGRATION));
        if (!mods.isEmpty()) {
            int migration = (int)applyModifiers(amount, turn, mods);
            modifyImmigration(migration);
            getOwner().modifyImmigration(migration);
        }
    }

    /**
     * Creates a temporary copy of this colony for planning purposes.
     *
     * A simple colony.copy() can not work because all the colony
     * tiles will be left referring to uncopied work tiles which the
     * colony-copy does not own, which prevents them being used as
     * valid work locations.  We have to copy the colony tile (which
     * includes the colony), and fix up all the colony tile work tiles
     * to point to copies of the original tile, and fix the ownership
     * of those tiles.
     *
     * @return A scratch version of this colony.
     */
    public Colony copyColony() {
        final Game game = getGame();
        Tile tile = getTile();
        Tile tileCopy = tile.copy(game);
        Colony colony = tileCopy.getColony();
        for (ColonyTile ct : colony.getColonyTiles()) {
            Tile wt;
            if (ct.isColonyCenterTile()) {
                wt = tileCopy;
            } else {
                wt = ct.getWorkTile();
                wt = wt.copy(game);
                if (wt.getOwningSettlement() == this) {
                    wt.setOwningSettlement(colony);
                }
            }
            ct.setWorkTile(wt);
        }
        return colony;
    }

    /**
     * Finds the corresponding FreeColObject from another copy of this colony.
     *
     * @param <T> The actual return type.
     * @param fco The {@code FreeColObject} in the other colony.
     * @return The corresponding {@code FreeColObject} in this
     *     colony, or null if not found.
     */
    @SuppressWarnings("unchecked")
    public <T extends FreeColObject> T getCorresponding(T fco) {
        final String id = fco.getId();
        return (fco instanceof WorkLocation)
                ? (T)find(getAllWorkLocations(),
                matchKeyEquals(id, WorkLocation::getId))
                : (fco instanceof Tile)
                ? (T)((getTile().getId().equals(id)) ? getTile()
                : find(map(getColonyTiles(), ColonyTile::getWorkTile),
                matchKeyEquals(id, Tile::getId)))
                : (fco instanceof Unit)
                ? (T)find(getAllUnitsList(),
                matchKeyEquals(id, Unit::getId))
                : null;
    }


    // Override FreeColObject

    /**
     * {@inheritDoc}
     */
    @Override
    public Stream<Ability> getAbilities(String id, FreeColSpecObjectType type,
                                        Turn turn) {
        if (turn == null) turn = getGame().getTurn();
        return concat(super.getAbilities(id, type, turn),
                ((owner == null) ? Stream.<Ability>empty()
                        : owner.getAbilities(id, type, turn)));
    }


    // Override FreeColGameObject

    /**
     * {@inheritDoc}
     */
    @Override
    public Stream<FreeColGameObject> getDisposables() {
        return concat(flatten(getAllWorkLocations(),
                WorkLocation::getDisposables),
                super.getDisposables());
    }


    // Interface Location (from Settlement via GoodsLocation via UnitLocation)
    //   UnitLocation.units is not used in Colony.  getUnits/List is defined
    //   to return the union of the units in the work locations, which may
    //   or not be the best idea.  Another choice would be to return all
    //   the units in the work locations, plus those present on the tile,
    //   which is provided by Settlement.getAllUnitsList.
    //   TODO: look at all the uses, see if this makes sense.
    // Inherits
    //   FreeColObject.getId
    //   Settlement.getTile
    //   Settlement.getLocationLabel
    //   GoodsLocation.canAdd
    //   GoodsLocation.getGoodsContainer
    //   Settlement.getSettlement

    /**
     * {@inheritDoc}
     */
    @Override
    public StringTemplate getLocationLabelFor(Player player) {
        // Everyone can always work out a colony name, but it can be invalid
        final String name = getName();
        return StringTemplate.name((name == null) ? "?" : name);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean add(Locatable locatable) {
        if (locatable instanceof Unit) {
            return joinColony((Unit)locatable);
        }
        return super.add(locatable);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean remove(Locatable locatable) {
        if (locatable instanceof Unit) {
            Location loc = locatable.getLocation();
            if (loc instanceof WorkLocation) {
                WorkLocation wl = (WorkLocation)loc;
                if (wl.getColony() == this) {
                    return wl.remove(locatable);
                }
            }
            return false;
        }
        return super.remove(locatable);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean contains(Locatable locatable) {
        if (locatable instanceof Unit) {
            return any(getAvailableWorkLocations(),
                    wl -> wl.contains(locatable));
        }
        return super.contains(locatable);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public int getUnitCount() {
        return sum(getCurrentWorkLocations(), UnitLocation::getUnitCount);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Stream<Unit> getUnits() {
        return flatten(getCurrentWorkLocations(), WorkLocation::getUnits);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public List<Unit> getUnitList() {
        return toList(getUnits());
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public final Colony getColony() {
        return this;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Location up() {
        return this;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String toShortString() {
        return getName();
    }


    // Interface UnitLocation
    // Inherits
    //   UnitLocation.getSpaceTaken [Irrelevant!]
    //   UnitLocation.moveToFront [Irrelevant!]
    //   UnitLocation.clearUnitList [Irrelevant!]
    //   Settlement.equipForRole
    //   Settlement.getNoAddReason


    // Interface GoodsLocation

    /**
     * {@inheritDoc}
     */
    public void invalidateCache() {
        this.productionCache.invalidate();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public int getGoodsCapacity() {
        return (int)apply(0f, getGame().getTurn(), Modifier.WAREHOUSE_STORAGE);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean addGoods(GoodsType type, int amount) {
        super.addGoods(type, amount);
        productionCache.invalidate(type);
        modifySpecialGoods(type, amount);
        return true;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Goods removeGoods(GoodsType type, int amount) {
        Goods removed = super.removeGoods(type, amount);
        productionCache.invalidate(type);
        if (removed != null) modifySpecialGoods(type, -removed.getAmount());
        return removed;
    }


    // Settlement

    /**
     * {@inheritDoc}
     */
    @Override
    public int getImmigration() {
        return immigration;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public int getLiberty() {
        return liberty;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Unit getDefendingUnit(Unit attacker) {
        if (displayUnitCount > 0) {
            // There are units, but we don't see them
            return null;
        }

        // Note that this function will only return a unit working
        // inside the colony.  Typically, colonies are also defended
        // by units outside the colony on the same tile.  To consider
        // units outside the colony as well, use
        // @see Tile#getDefendingUnit instead.
        final CombatModel cm = getGame().getCombatModel();
        final Comparator<Unit> comp
                = cachingDoubleComparator(u -> cm.getDefencePower(attacker, u));
        return maximize(getUnits(), comp);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public double getDefenceRatio() {
        return getTotalDefencePower() / (1 + getUnitCount());
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean isBadlyDefended() {
        final double defencePower = getTotalDefencePower();
        if (getTile().getUnits().filter(u -> u.isOffensiveUnit()).count() < 1) {
            return true;
        }
        if (getTile().getUnits().filter(u -> u.isOffensiveUnit()).count() > 5) {
            return false;
        }
        return defencePower < 0.95 * getUnitCount() - 2.5;
    }
    
    public boolean isVeryWellDefended() {
        final double defencePower = getTotalDefencePower();
        if (getTile().getUnits().filter(u -> u.isOffensiveUnit()).count() < 3) {
            return false;
        }
        if (getTile().getUnits().filter(u -> u.isOffensiveUnit()).count() > 5) {
            return true;
        }
        return defencePower / 2 > 0.95 * getUnitCount() - 2.5;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public RandomRange getPlunderRange(Unit attacker) {
        if (canBePlundered()) {
            int upper = (owner.getGold() * (getUnitCount() + 1))
                    / (owner.getColoniesPopulation() + 1);
            if (upper > 0) return new RandomRange(100, 1, upper+1, 1);
        }
        return null;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public int getUpkeep() {
        return sum(getBuildings(), b -> b.getType().getUpkeep());
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public int getTotalProductionOf(GoodsType goodsType) {
        return sum(getCurrentWorkLocations(),
                wl -> wl.getTotalProductionOf(goodsType));
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean canProvideGoods(List<AbstractGoods> requiredGoods) {
        // Unlike priceGoods, this takes goods "reserved" for other
        // purposes into account.
        BuildableType buildable = getCurrentlyBuilding();
        for (AbstractGoods goods : requiredGoods) {
            int available = getGoodsCount(goods.getType());

            int breedingNumber = goods.getType().getBreedingNumber();
            if (breedingNumber != INFINITY) available -= breedingNumber;

            if (buildable != null) {
                available -= AbstractGoods.getCount(goods.getType(),
                        buildable.getRequiredGoodsList());
            }

            if (available < goods.getAmount()) return false;
        }
        return true;
    }

    /**
     * {@inheritDoc}
     */
    public boolean hasContacted(Player player) {
        return player != null
                && (player.isEuropean()
                || getOwner().getStance(player) != Stance.UNCONTACTED);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public StringTemplate getAlarmLevelLabel(Player player) {
        Stance stance = getOwner().getStance(player);
        return StringTemplate.template("model.colony." + stance.getKey())
                .addStringTemplate("%nation%", getOwner().getNationLabel());
    }


    /**
     * Determines the value of a potential attack on a {@code Colony}
     *
     * @param value The previously calculated input value from
     *          {@link net.sf.freecol.server.ai.mission.UnitSeekAndDestroyMission
     *                  #scoreSettlementPath(AIUnit, PathNode, Settlement)}
     * @param unit The Unit doing the attacking.
     * @return The newly calculated value.
     */
    @Override
    public int calculateSettlementValue(int value, Unit unit) {
        // Favour high population (more loot:-).
        value += this.getUnitCount();
        if (this.hasStockade()) { // Avoid fortifications.
            value -= 200 * this.getStockade().getLevel();
        }
        return value;
    }


    // Interface TradeLocation

    /**
     * Calculate the present field.
     *
     * @param goodsType The {@link GoodsType} to check for got import/export.
     * @param turns The number of turns before the goods is required.
     * @return The amount of goods to export.
     */
    private int returnPresent(GoodsType goodsType, int turns) {
        return Math.max(0, getGoodsCount(goodsType)
            + turns * getNetProductionOf(goodsType));
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public int getAvailableGoodsCount(GoodsType goodsType) {
        return getGoodsCount(goodsType);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public int getExportAmount(GoodsType goodsType, int turns) {
        final int present = returnPresent(goodsType, turns);
        final ExportData ed = getExportData(goodsType);
        return Math.max(0, present - ed.getExportLevel());
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public int getImportAmount(GoodsType goodsType, int turns) {
        if (goodsType.limitIgnored()) return GoodsContainer.HUGE_CARGO_SIZE;

        final int present = returnPresent(goodsType, turns);
        final ExportData ed = getExportData(goodsType);
        int capacity = ed.getEffectiveImportLevel(getWarehouseCapacity());
        return Math.max(0, capacity - present);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getLocationName(TradeLocation tradeLocation) {
        Colony colony = (Colony) tradeLocation;
        return colony.getName();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean canBeInput() {
        return true;
    }


    //
    // Miscellaneous low level
    //

    /**
     * Add port ability to non-landlocked colonies.
     */
    protected void addPortAbility() {
        addAbility(new Ability(Ability.HAS_PORT));
    }

    /**
     * Check the integrity of the build queues.  Catches build fails
     * due to broken requirements.
     *
     * @param fix Fix problems if possible.
     * @param lb An optional {@code LogBuilder} to log to.
     * @return The integrity found.
     */
    public IntegrityType checkBuildQueueIntegrity(boolean fix, LogBuilder lb) {
        IntegrityType result = IntegrityType.INTEGRITY_GOOD;
        List<BuildableType> buildables = buildQueue.getValues();
        List<BuildableType> assumeBuilt = new ArrayList<>();
        for (int i = 0; i < buildables.size(); i++) {
            BuildableType bt = buildables.get(i);
            NoBuildReason reason = getNoBuildReason(bt, assumeBuilt);
            if (reason == NoBuildReason.NONE) {
                assumeBuilt.add(bt);
            } else if (fix) {
                if (lb != null) lb.add("\n  Invalid build queue item removed: ", bt.getId());
                buildQueue.remove(i);
                result = result.fix();
            } else {
                if (lb != null) lb.add("\n  Invalid build queue item: ", bt.getId());
                result = result.fail();
            }
        }
        List<UnitType> unitTypes = populationQueue.getValues();
        assumeBuilt.clear();
        for (int i = 0; i < unitTypes.size(); i++) {
            UnitType ut = unitTypes.get(i);
            NoBuildReason reason = getNoBuildReason(ut, assumeBuilt);
            if (reason == NoBuildReason.NONE) {
                assumeBuilt.add(ut);
            } else if (fix) {
                if (lb != null) lb.add("\n  Invalid population queue item removed: ", ut.getId());
                populationQueue.remove(i);
                result = result.fix();
            } else {
                if (lb != null) lb.add("\n  Invalid population queue item: ", ut.getId());
                result = result.fail();
            }
        }
        return result;
    }


    // Override FreeColGameObject

    /**
     * {@inheritDoc}
     */
    @Override
    public IntegrityType checkIntegrity(boolean fix, LogBuilder lb) {
        IntegrityType result = super.checkIntegrity(fix, lb);

        return result.combine(checkBuildQueueIntegrity(fix, lb));
    }


    // Override FreeColObject
    
    /**
     * {@inheritDoc}
     */
    @Override
    public int getClassIndex () {
        return COLONY_CLASS_INDEX;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public <T extends FreeColObject> boolean copyIn(T other) {
        Colony o = copyInCast(other, Colony.class);
        if (o == null || !super.copyIn(o)) return false;
        final Game game = getGame();
        this.setBuildingMap(game.update(o.getBuildings(), true));
        this.setColonyTiles(game.update(o.getColonyTiles(), true));
        this.setExportData(o.getExportData());
        this.liberty = o.getLiberty();
        this.sonsOfLiberty = o.getSonsOfLiberty();
        this.oldSonsOfLiberty = o.getOldSonsOfLiberty();
        this.tories = o.getToryCount();
        this.oldTories = o.getOldToryCount();
        this.productionBonus = o.getProductionBonus();
        this.immigration = o.getImmigration();
        this.established = o.getEstablished();
        this.setBuildQueue(o.getBuildQueue());
        this.setPopulationQueue(o.getPopulationQueue());
        this.displayUnitCount = o.getDisplayUnitCount();

        for (WorkLocation wl : getAllWorkLocationsList()) wl.setColony(this);

        invalidateCache(); // Almost any change will break the cache
        return true;
    }


    // Serialization

    private static final String BUILD_QUEUE_TAG = "buildQueueItem";
    private static final String ESTABLISHED_TAG = "established";
    private static final String IMMIGRATION_TAG = "immigration";
    private static final String LIBERTY_TAG = "liberty";
    private static final String PRODUCTION_BONUS_TAG = "productionBonus";
    private static final String NAME_TAG = "name";
    private static final String OLD_SONS_OF_LIBERTY_TAG = "oldSonsOfLiberty";
    private static final String OLD_TORIES_TAG = "oldTories";
    private static final String POPULATION_QUEUE_TAG = "populationQueueItem";
    private static final String SONS_OF_LIBERTY_TAG = "sonsOfLiberty";
    private static final String TORIES_TAG = "tories";
    private static final String UNIT_COUNT_TAG = "unitCount";


    /**
     * {@inheritDoc}
     */
    @Override
    protected void writeAttributes(FreeColXMLWriter xw) throws XMLStreamException {
        super.writeAttributes(xw);

        // Delegated from Settlement
        xw.writeAttribute(NAME_TAG, getName());

        xw.writeAttribute(ESTABLISHED_TAG, established.getNumber());

        // SoL has to be visible for the popular support bonus to be
        // visible to an attacking rebel player.
        xw.writeAttribute(SONS_OF_LIBERTY_TAG, sonsOfLiberty);

        if (xw.validFor(getOwner())) {

            xw.writeAttribute(OLD_SONS_OF_LIBERTY_TAG, oldSonsOfLiberty);

            xw.writeAttribute(TORIES_TAG, tories);

            xw.writeAttribute(OLD_TORIES_TAG, oldTories);

            xw.writeAttribute(LIBERTY_TAG, liberty);

            xw.writeAttribute(IMMIGRATION_TAG, immigration);

            xw.writeAttribute(PRODUCTION_BONUS_TAG, productionBonus);

        } else {
            int uc = getApparentUnitCount();
            if (uc > 0) { // Valid if above zero
                xw.writeAttribute(UNIT_COUNT_TAG, uc);
            } else if (uc == 0) { // Zero is an error!  Find that bug
                FreeCol.trace(logger, "Unit count fail: " + uc
                    + " id=" + getId() + " name=" + getName()
                    + " unitCount=" + getUnitCount()
                    + " displayUnitCount=" + this.displayUnitCount
                    + " scope=" + xw.getWriteScope()
                    + "/" + xw.getClientPlayer());
            } // else do nothing, negative means no value set
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    protected void writeChildren(FreeColXMLWriter xw) throws XMLStreamException {
        super.writeChildren(xw);

        if (xw.validFor(getOwner())) {

            for (Entry<String, ExportData> e : mapEntriesByKey(exportData)) {
                e.getValue().toXML(xw);
            }

            for (WorkLocation wl : sort(getAllWorkLocations())) {
                wl.toXML(xw);
            }

            for (BuildableType item : buildQueue.getValues()) { // In order!
                xw.writeStartElement(BUILD_QUEUE_TAG);

                xw.writeAttribute(ID_ATTRIBUTE_TAG, item);

                xw.writeEndElement();
            }

            for (BuildableType item : populationQueue.getValues()) { // In order
                xw.writeStartElement(POPULATION_QUEUE_TAG);

                xw.writeAttribute(ID_ATTRIBUTE_TAG, item);

                xw.writeEndElement();
            }

        } else {
            // Special case.  Serialize stockade-class buildings to
            // otherwise unprivileged clients as the stockade level is
            // visible to anyone who can see the colony.  This should
            // have no other information leaks because stockade
            // buildings have no production or units inside.
            Building stockade = getStockade();
            if (stockade != null) stockade.toXML(xw);
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void readAttributes(FreeColXMLReader xr) throws XMLStreamException {
        super.readAttributes(xr);

        established = new Turn(xr.getAttribute(ESTABLISHED_TAG, 0));

        sonsOfLiberty = xr.getAttribute(SONS_OF_LIBERTY_TAG, 0);

        oldSonsOfLiberty = xr.getAttribute(OLD_SONS_OF_LIBERTY_TAG, 0);

        tories = xr.getAttribute(TORIES_TAG, 0);

        oldTories = xr.getAttribute(OLD_TORIES_TAG, 0);

        liberty = xr.getAttribute(LIBERTY_TAG, 0);

        immigration = xr.getAttribute(IMMIGRATION_TAG, 0);

        productionBonus = xr.getAttribute(PRODUCTION_BONUS_TAG, 0);

        displayUnitCount = xr.getAttribute(UNIT_COUNT_TAG, -1);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void readChildren(FreeColXMLReader xr) throws XMLStreamException {
        // Clear containers.
        clearBuildingMap();
        clearColonyTiles();
        exportData.clear();
        buildQueue.clear();
        populationQueue.clear();

        super.readChildren(xr);

        invalidateCache();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void readChild(FreeColXMLReader xr) throws XMLStreamException {
        final Specification spec = getSpecification();
        final Game game = getGame();
        final String tag = xr.getLocalName();

        if (BUILD_QUEUE_TAG.equals(tag)) {
            BuildableType bt = xr.getType(spec, ID_ATTRIBUTE_TAG,
                    BuildableType.class, (BuildableType)null);
            if (bt != null) buildQueue.add(bt);
            xr.closeTag(BUILD_QUEUE_TAG);

        } else if (POPULATION_QUEUE_TAG.equals(xr.getLocalName())) {
            UnitType ut = xr.getType(spec, ID_ATTRIBUTE_TAG,
                    UnitType.class, (UnitType)null);
            if (ut != null) populationQueue.add(ut);
            xr.closeTag(POPULATION_QUEUE_TAG);

        } else if (Building.TAG.equals(tag)) {
            addBuilding(xr.readFreeColObject(game, Building.class));

        } else if (ColonyTile.TAG.equals(tag)) {
            addColonyTile(xr.readFreeColObject(game, ColonyTile.class));

        } else if (ExportData.TAG.equals(tag)) {
            ExportData data = new ExportData(xr);
            setExportData(data);

        } else {
            super.readChild(xr);
        }
    }

    /**
     * {@inheritDoc}
     */
    public String getXMLTagName() { return TAG; }


    // Override Object
    
    /**
     * {@inheritDoc}
     */
    @Override
    public String toString() {
        return getName();
    }
}
