/*
    * Created on Sep 3, 2004 
    * 
    *   Magic-Project is a turn based strategy simulator
    *   Copyright (C) 2003-2007 Fabrice Daugan
    *
    *   This program is free software; you can redistribute it and/or modify it 
    * under the terms of the GNU General Public License as published by the Free 
    * Software Foundation; either version 2 of the License, or (at your option) any
   * later version.
   *
   *   This program is distributed in the hope that it will be useful, but WITHOUT 
   * ANY WARRANTY; 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 this program; if not, write to the Free Software Foundation, Inc., 
   * 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   * 
   */
  package net.sf.magicproject.modifier;
  
  import java.awt.Graphics;
  import java.util.ArrayList;
  import java.util.List;
  
  import net.sf.magicproject.action.RefreshModifier;
  import net.sf.magicproject.clickable.ability.Ability;
  import net.sf.magicproject.clickable.ability.RefreshAbility;
  import net.sf.magicproject.clickable.ability.RemoveModifier;
  import net.sf.magicproject.clickable.targetable.card.MCard;
  import net.sf.magicproject.clickable.targetable.card.SystemCard;
  import net.sf.magicproject.event.MEventListener;
  import net.sf.magicproject.event.MovedCard;
  import net.sf.magicproject.event.TriggeredEvent;
  import net.sf.magicproject.test.And;
  import net.sf.magicproject.test.InZone;
  import net.sf.magicproject.test.IsTested;
  import net.sf.magicproject.test.Test;
  import net.sf.magicproject.test.True;
  import net.sf.magicproject.test.TestOn;
  import net.sf.magicproject.token.IdZones;
  import net.sf.magicproject.tools.Log;
  
  /***
   * @author <a href="mailto:fabdouglas@users.sourceforge.net">Fabrice Daugan </a>
   */
  public abstract class Modifier implements Unregisterable, ObjectModifier {
  
  	/***
  	 * Creates a new instance of Modifier <br>
  	 * 
  	 * @param name
  	 *          The modifier name.
  	 * @param to
  	 *          Targetable attached to.
  	 * @param creatorAbility
  	 *          is the ability owning this test. The card component of this
  	 *          ability should correspond to the card owning this test too.
  	 * @param whileCondition
  	 *          When this test is true, this modifier is activated. Otherwise this
  	 *          modifier does nothing.
  	 * @param linkedEvents
  	 *          the linked events used to build dynamically the corresponding
  	 *          abilities.
  	 * @param until
  	 *          the until events stopping this modifier.
  	 * @param linked
  	 *          is this modifier is linked to the creator.
  	 * @param layer
  	 *          the layer of this modifier.
  	 */
  	protected Modifier(String name, MCard to, Ability creatorAbility,
  			Test whileCondition, List<MEventListener> linkedEvents,
  			List<MEventListener> until, boolean linked, int layer) {
  		this.name = name;
  		this.to = to;
  		this.layer = layer;
  		abilities = new ArrayList<Ability>();
  		this.ability = creatorAbility;
  		final MCard creator = creatorAbility.getCard();
  
  		/*
  		 * create the abilities linked to this modifier in order to maintain the
  		 * coherence. Any event that could modifiy the "while-test" make a triggered
  		 * ability to be created listening this event.
  		 */
  		if (linkedEvents != null) {
  			final RefreshModifier refreshAction = new RefreshModifier(this);
  			for (MEventListener event : linkedEvents) {
  				final Ability refreshAbility = new RefreshAbility(
  						(TriggeredEvent) event.clone(to), refreshAction,
  						creator == null ? to : creator);
  				refreshAbility.registerToManager();
  				abilities.add(refreshAbility);
  			}
  		}
  
 		// link creator <--> target
 		if (linked && creator != null && creator != SystemCard.instance) {
 			// when the creator moves, this modifier is destroyed
 			final Ability linkAbility = new RemoveModifier(new MovedCard(
 					IdZones.PLAY, And.append(IsTested.TESTED_IS_ME, new InZone(
 							IdZones.PLAY, TestOn.THIS)), True.getInstance(), creator),
 					this);
 			linkAbility.registerToManager();
 			abilities.add(linkAbility);
 		}
 
 		// when the until condition become true, this modifier is destroyed
 		for (MEventListener event : until) {
 			final Ability untilAbility = new RemoveModifier((TriggeredEvent) event
 					.clone(to), this);
 			untilAbility.registerToManager();
 			abilities.add(untilAbility);
 		}
 
 		this.whileCondition = whileCondition;
 	}
 
 	public int paintObject(Graphics g, int startX, int startY) {
 		if (next != null) {
 			return next.paintObject(g, startX, startY);
 		}
 		return startX;
 	}
 
 	/***
 	 * Add a modifier to the end of the modifier chain. The current modifier stays
 	 * the first modifier of this chain.
 	 * 
 	 * @param modifier
 	 *          the property modifier to add.
 	 * @return the new chain.
 	 */
 	public final Modifier addModifier(Modifier modifier) {
 		assert modifier.next != null;
 		if (modifier.next != null) {
 			throw new InternalError("'next' modifier should not be specified");
 		}
 
 		// Is the specified modifier has lower layer?
 		if (modifier.layer < layer) {
 			// insert the modifier just before this modifier
 			modifier.next = this;
 			return modifier;
 		}
 
 		// Are we to the end of the chain?
 		if (this.next == null) {
 			// the modifier becomes the last one of the chain
 			this.next = modifier;
 			return this;
 		}
 
 		// continue within the chain to add this modifier to the end of this layer
 		this.next = next.addModifier(modifier);
 		return this;
 	}
 
 	/***
 	 * remove from the manager a modifier
 	 * 
 	 * @param modifier
 	 *          the modifier to remove
 	 * @return the new chain
 	 */
 	protected Modifier removeModifier(Modifier modifier) {
 		if (next != null) {
 			next = next.removeModifier(modifier);
 		} else {
 			Log.warn("Cannot remove the modifier " + modifier.getClass() + ", name="
 					+ modifier.name);
 		}
 		return this;
 	}
 
 	/***
 	 * Refresh this modifier following the whileCondition.
 	 */
 	public abstract void refresh();
 
 	public int getNbObjects(String objectName, Test objectTest) {
 		if (next == null) {
 			return 0;
 		}
 		return next.getNbObjects(objectName, objectTest);
 	}
 
 	public Modifier removeObject(String objectName, Test objectTest) {
 		// if (next == null):no more instance of this object on the card -> ignored
 		if (next != null) {
 			next = next.removeObject(objectName, objectTest);
 		}
 		return this;
 	}
 
 	public void removeFromManager() {
 		if (unregisteringModifier) {
 			// we are currently unregistering this modifier
 			return;
 		}
 		unregisteringModifier = true;
 		for (int i = abilities.size(); i-- > 0;) {
 			abilities.get(i).removeFromManager();
 		}
 		unregisteringModifier = false;
 	}
 
 	/***
 	 * Tag indicating we are currently unregistering this modifier
 	 */
 	protected boolean unregisteringModifier;
 
 	/***
 	 * Tag indicating this modifier is completely unregistered and can be released
 	 */
 	protected boolean unregisteredModifier;
 
 	@Override
 	public String toString() {
 		return name;
 	}
 
 	public MCard getCard() {
 		return ability.getCard();
 	}
 
 	/***
 	 * The next modifier
 	 */
 	public Modifier next;
 
 	/***
 	 * The modifier name
 	 */
 	protected final String name;
 
 	/***
 	 * When this test is true, this modifier is activated. Otherwise this modifier
 	 * does nothing.
 	 */
 	protected final Test whileCondition;
 
 	/***
 	 * Is this modifier is activated
 	 */
 	protected boolean activated;
 
 	/***
 	 * Targetable attached to.
 	 */
 	protected final MCard to;
 
 	/***
 	 * The ability having created this modifier.
 	 */
 	protected Ability ability;
 
 	/***
 	 * Abilities linked to this modifier
 	 */
 	protected final List<Ability> abilities;
 
 	/***
 	 * is the strategy used to add this modifier within the existing chain.
 	 */
 	public int layer;
 }