package cz.cuni.amis.pogamut.ut2004.tag.tournament;
   
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   
   import cz.cuni.amis.pogamut.unreal.communication.messages.UnrealId;
   import cz.cuni.amis.pogamut.ut2004.analyzer.stats.UT2004AnalyzerObsStats;
  import cz.cuni.amis.pogamut.ut2004.communication.messages.gbinfomessages.PlayerMessage;
  import cz.cuni.amis.pogamut.ut2004.tag.server.BotTagRecord;
  import cz.cuni.amis.pogamut.ut2004.tournament.match.UT2004MatchResult;
  import cz.cuni.amis.utils.maps.HashMapMap;
  import cz.cuni.amis.utils.token.IToken;
  
  public class UT2004TagResult extends UT2004MatchResult {
  	private List<IToken> bots = new ArrayList<IToken>();
  	
  	private List<IToken> nativeBots = new ArrayList<IToken>();
  	
  	private Map<IToken, BotTagRecord<PlayerMessage>> playerScores = new HashMap<IToken, BotTagRecord<PlayerMessage>>();
  	
  	private Map<UnrealId, Integer> tagsPassed = new HashMap<UnrealId, Integer>();
  	
  	private Map<IToken, Integer> tagsReceived = new HashMap<IToken, Integer>();
  	
  	private HashMapMap<IToken, IToken, Integer> tagCounts = new HashMapMap<IToken, IToken, Integer>(); 
  	
  	private Map<IToken, UT2004AnalyzerObsStats> botObservers = new HashMap<IToken, UT2004AnalyzerObsStats>();
  
  	/**
  	 * When the match has ended (in seconds);
  	 */
  	public double matchTimeEnd;
  
  	/**
  	 * No side has won.
  	 */
  	private boolean draw = false;
  	
  	@Override
  	public String toString() {
  		return "UT2004TagGameResult[" + (isDraw() ? "DRAW" : (isIndividual() ? "winnerBot=" + getWinnerBot() : "winnerTeam=" + getWinnerTeam()) ) + "]";
  	}
  	
  	public UT2004TagResult() {
  		super();
  	}
  	
  	public UT2004TagResult(IToken winnerBot) {
  		super(winnerBot);
  	}
  
  	
  	/**
  	 * Get all players tag scores.
  	 * @return
  	 */
  	public Map<IToken, BotTagRecord<PlayerMessage>> getPlayerScores() {
  		return playerScores;
  	}
  
  	/**
  	 * Set all players tag scores.
  	 * @param playerScores
  	 */
  	public void setPlayerScores(Map<IToken, BotTagRecord<PlayerMessage>> playerScores) {
  		this.playerScores = playerScores;
  	}
  
  	/**
  	 * Returns list with custom bots (run by Pogamut platform).
  	 * @return
  	 */
  	public List<IToken> getBots() {
  		return bots;
  	}
  
  	/**
  	 * List with custom bots (run by Pogamut platform).
  	 * @param bots
  	 */
  	public void setBots(List<IToken> bots) {
  		this.bots = bots;
  	}
  
  	/**
  	 * Returns list with native bots (bots from UT2004 itself).
  	 * @return
  	 */
  	public List<IToken> getNativeBots() {
  		return nativeBots;
  	}
  
  	/**
  	 * List with native bots (bots from UT2004 itself).
  	 * @param nativeBots
  	 */
  	public void setNativeBots(List<IToken> nativeBots) {
 		this.nativeBots = nativeBots;
 	}
 	
 	/**
 	 * Returns list of all bot (custom + native) ids.
 	 * @return
 	 */
 	public List<IToken> getAllBots() {
 		List<IToken> all = new ArrayList<IToken>(this.bots);
 		all.addAll(this.nativeBots);
 		return all;
 	}
 
 	/**
 	 * When the match has ended (in seconds). I.e., how long was the match.
 	 */
 	public double getMatchTimeEnd() {
 		return matchTimeEnd;
 	}
 
 	/**
 	 * When the match has ended (in seconds). I.e., how long was the match.
 	 */
 	public void setMatchTimeEnd(double matchTimeEnd) {
 		this.matchTimeEnd = matchTimeEnd;
 	}
 
 	/**
 	 * Who -&gt; tagged Whom -&gt; How many times, i.e., map.get(taggerId).get(victimId) == how many time tagger tagged the victim.
 	 * @return
 	 */
 	public HashMapMap<IToken, IToken, Integer> getTagCounts() {
 		return tagCounts;
 	}
 
 	/**
 	 * Who -&gt; tagged Whom -&gt; How many times, i.e., map.get(taggerId).get(victimId) == how many time tagger tagged the victim.
 	 * @return
 	 */
 	public void setTagCounts(HashMapMap<IToken, IToken, Integer> tagCounts) {
 		this.tagCounts = tagCounts;
 	}
 	
 	
 	/**
 	 * How many times one bot tagged another bot.
 	 * @return
 	 */
 	public Map<UnrealId, Integer> getTotalTags() {
 		return tagsPassed;
 	}
 
 	/**
 	 * How many times one bot tagged another bot.
 	 * @return
 	 */
 	public void setTotalTags(Map<UnrealId, Integer> totalTags) {
 		this.tagsPassed = totalTags;
 	}
 	
 	/**
 	 * How many times some bot was tagged by ANOTHER bot.
 	 * @return
 	 */
 	public Map<IToken, Integer> getWasTagged() {
 		return tagsReceived;
 	}
 
 	/**
 	 * How many times some bot was tagged by ANOTHER bot.
 	 * @return
 	 */
 	public void setWasTagged(Map<IToken, Integer> tagsReceived) {
 		this.tagsReceived = tagsReceived;
 	}
 
 
 	/**
 	 * Map with observers (custom bots only!) containing detailed statistics about respective bots.
 	 * @return
 	 */
 	public Map<IToken, UT2004AnalyzerObsStats> getBotObservers() {
 		return botObservers;
 	}
 
 	/**
 	 * Map with observers (custom bots only!) containing detailed statistics about respective bots.
 	 * @param botObservers
 	 */
 	public void setBotObservers(Map<IToken, UT2004AnalyzerObsStats> botObservers) {
 		this.botObservers = botObservers;
 	}
 }