/*
    * Created on 27 octobre 2002, 12:15
    * 
    *   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.clickable.ability;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.Collection;
  
  import net.sf.magicproject.action.ActionFactory;
  import net.sf.magicproject.action.Actiontype;
  import net.sf.magicproject.action.MAction;
  import net.sf.magicproject.action.RemoveObject;
  import net.sf.magicproject.action.Repeat;
  import net.sf.magicproject.action.listener.WaitingAbility;
  import net.sf.magicproject.action.target.AbstractTarget;
  import net.sf.magicproject.action.target.ChoosenTarget;
  import net.sf.magicproject.clickable.action.ToStringHelper;
  import net.sf.magicproject.clickable.targetable.card.MCard;
  import net.sf.magicproject.event.EventFactory;
  import net.sf.magicproject.event.MEventListener;
  import net.sf.magicproject.event.context.ContextEventListener;
  import net.sf.magicproject.network.ConnectionManager;
  import net.sf.magicproject.network.IdMessages;
  import net.sf.magicproject.stack.StackManager;
  import net.sf.magicproject.token.IdCommonToken;
  import net.sf.magicproject.token.TrueFalseAuto;
  import net.sf.magicproject.tools.Log;
  
  /***
   * A non-abstract ability.
   * 
   * @author <a href="mailto:fabdouglas@users.sourceforge.net">Fabrice Daugan </a>
   */
  public abstract class UserAbility extends Ability {
  
  	/***
  	 * Create an instance of UserAbility <br>
  	 * <ul>
  	 * Structure of InputStream : Data[size]
  	 * <li>event [Event]</li>
  	 * <li>cost [Action[]]</li>
  	 * <li>effect [Action[]]</li>
  	 * </ul>
  	 * 
  	 * @param inputFile
  	 *          file containing this ability
  	 * @param card
  	 *          referenced card
  	 * @throws IOException
  	 *           if error occurred during the reading process from the specified
  	 *           input stream
  	 * @since 0.81 constraints on actions of this ability are supported
  	 */
  	public UserAbility(InputStream inputFile, MCard card) throws IOException {
  		super(inputFile);
  		try {
  			// Read id event
  			eventComing = EventFactory.readNextEvent(inputFile, card);
  
  			// Read list of actions
  			actionList = ActionFactory.readActionList(inputFile, null);
  
  			// Extract constraints
  			eventComing.test = ActionFactory.getConstraints(actionList,
  					eventComing.test);
  
  			// Optimize target options
  			updateCheckingAction();
  
  			// Read list of effect
  			effectList = ActionFactory.readActionList(inputFile, null);
  		} catch (Throwable e) {
  			throw new RuntimeException("reading UserAbility " + getName() + ", card:"
  					+ card.getName(), e);
  		}
  	}
  
  	/***
  	 * Create an instance of UserAbility
  	 * 
 	 * @param name
 	 *          Name of card used to display this ability in a stack
 	 * @param actionList
 	 *          list of actions to do for activate this ability
 	 * @param effectList
 	 *          list of effects of this ability
 	 * @param optimizer
 	 *          the optimizer to use.
 	 * @param priority
 	 *          the resolution type.
 	 * @param eventComing
 	 *          event condition of this ability
 	 * @param pictureName
 	 *          the picture name of this ability. If <code>null</code> the card
 	 *          picture will be used instead.
 	 * @param linkedAbilities
 	 *          the linked abilities. May be null.
 	 * @param playAsSpell
 	 *          play-as-spell.
 	 */
 	protected UserAbility(String name, MAction[] actionList,
 			MAction[] effectList, Optimization optimizer, Priority priority,
 			MEventListener eventComing, String pictureName,
 			Collection<Ability> linkedAbilities, TrueFalseAuto playAsSpell) {
 		super(name, optimizer, priority, pictureName, linkedAbilities, playAsSpell);
 		this.actionList = actionList;
 		this.effectList = effectList;
 		this.eventComing = eventComing;
 		updateCheckingAction();
 	}
 
 	private void updateCheckingAction() {
 		// Optimize target options
 		checkingOptions = NO_TARGET;
 		for (int i = actionList.length; i-- > 0;) {
 			if (actionList()[i] instanceof ChoosenTarget) {
 				if (((ChoosenTarget) actionList()[i]).isTargeting()) {
 					checkingOptions |= REAL_TARGET;
 				} else {
 					checkingOptions |= SILENT_TARGET;
 				}
 			} else if (actionList()[i] instanceof RemoveObject && i > 0) {
 				if (actionList()[i - 1] instanceof Repeat) {
 					if (i > 1
 							&& actionList()[i - 2] instanceof AbstractTarget
 							&& ((Repeat) actionList()[i - 1]).getPreemptionTimes(this, null) > 0) {
 						checkingOptions |= REMOVE_OBJECT;
 					}
 				} else if (actionList()[i - 1] instanceof AbstractTarget) {
 					checkingOptions |= REMOVE_OBJECT;
 				}
 			}
 		}
 	}
 
 	@Override
 	public abstract Ability clone(MCard container);
 
 	@Override
 	public MCard getCard() {
 		return eventComing.card;
 	}
 
 	@Override
 	public final boolean checkTargetActions() {
 		return (checkingOptions & TARGET_OPTIONS) == NO_TARGET
 				|| super.checkTargetActions();
 	}
 
 	@Override
 	public final boolean checkObjectActions() {
 		return (checkingOptions & OBJECT_OPTIONS) == NO_TARGET
 				|| super.checkObjectActions();
 	}
 
 	@Override
 	public final boolean recheckTargets() {
 		if ((checkingOptions & TARGET_OPTIONS) == REAL_TARGET) {
 			return super.recheckTargets();
 		}
 		return true;
 	}
 
 	@Override
 	public boolean isMatching() {
 
 		// enougth mana?
 		final int[] manaNeeded = manaNeeded(null);
 		int unUsed = 0;
 		for (int i = IdCommonToken.COLOR_NAMES.length; i-- > IdCommonToken.BLACK_MANA;) {
 			if (manaNeeded[i] > getController().mana.getMana(i, this)) {
 				return false;
 			}
 			unUsed += getController().mana.getMana(i, this) - manaNeeded[i];
 		}
 		if (manaNeeded[IdCommonToken.COLORLESS_MANA] > getController().mana
 				.getMana(IdCommonToken.COLORLESS_MANA, this)
 				+ unUsed) {
 			return false;
 		}
 
 		// check the target actions of 'cost' part can be played
 		return checkTargetActions() && checkObjectActions();
 	}
 
 	@Override
 	public int[] manaNeeded(ContextEventListener context) {
 		final int[] result = new int[IdCommonToken.COLOR_NAMES.length];
 		for (int id = actionList().length; id-- > 0;) {
 			final MAction action = actionList[id];
 			if (action.getIdAction() == Actiontype.PAY_MANA) {
 				// this ability need manas
 				final int[] actionCost = action.manaNeeded(this, context);
 				for (int i = IdCommonToken.COLOR_NAMES.length; i-- > IdCommonToken.COLORLESS_MANA;) {
 					result[i] += actionCost[i];
 				}
 			}
 		}
 		for (int id = effectList().length; id-- > 0;) {
 			final MAction action = effectList()[id];
 			if (action.getIdAction() == Actiontype.PAY_MANA) {
 				// this ability need manas
 				final int[] actionCost = action.manaNeeded(this, context);
 				for (int i = IdCommonToken.COLOR_NAMES.length; i-- > IdCommonToken.COLORLESS_MANA;) {
 					result[i] += actionCost[i];
 				}
 			}
 		}
 		return result;
 	}
 
 	@Override
 	public final String toString() {
 		return ToStringHelper.toString(this);
 	}
 
 	@Override
 	public String toHtmlString(ContextEventListener context) {
 		return ToStringHelper.toHtmlString(this, context);
 	}
 
 	@Override
 	public final MEventListener eventComing() {
 		return eventComing;
 	}
 
 	@Override
 	public final MAction[] actionList() {
 		return actionList;
 	}
 
 	@Override
 	public final MAction[] effectList() {
 		return effectList;
 	}
 
 	@Override
 	public boolean triggerIt(ContextEventListener context) {
 		super.triggerIt(context);
 		if (isHidden()) {
 			getController().zoneManager.triggeredBuffer.addHidden(this, context);
 		} else {
 			getController().zoneManager.triggeredBuffer
 					.add(getTriggeredClone(context));
 		}
 		return true;
 	}
 
 	/***
 	 * is called when you click on me
 	 * 
 	 * @param index
 	 *          is the index of this ability within the choice list of playable
 	 *          abilities of the card owning this ability.
 	 */
 	public final void mouseClicked(int index) {
 		if (StackManager.actionManager.clickOn(this)) {
 			Log.debug("clickOn(Mouse):" + getCard() + " -> " + this);
 			// send this information to our opponent : card + ability
 			final int[] cardBytes = getCard().getBytes();
 			final int[] toSend = new int[1 + cardBytes.length];
 			System.arraycopy(cardBytes, 1, toSend, 1, cardBytes.length - 1);
 			toSend[0] = IdMessages.MSG_CLICK_ABILITY;
 			toSend[cardBytes.length] = index;
 			// we inform opponent our choice
 			ConnectionManager.sendToOpponent(toSend);
 			StackManager.actionManager.succeedClickOn(this);
 		}
 	}
 
 	/***
 	 * This method is invoked when opponent has clicked on this object. this call
 	 * should be done from the net.sf.magicproject.network listener
 	 * 
 	 * @param input
 	 *          input stream of our net.sf.magicproject.network connection
 	 * @throws IOException
 	 *           if error occurred when reading the message
 	 */
 	public static void clickOn(InputStream input) throws IOException {
 		// waiting for card information
 		final MCard card = MCard.getCard(input);
 		Log.debug("clickOn(VirtualInput):" + card);
 
 		final int index = input.read();
 		if (index >= 128) {
 			// advanced activated ability
 			StackManager.actionManager
 					.succeedClickOn(((WaitingAbility) StackManager.actionManager.currentAction)
 							.advancedAbilitiesOf(card).get(index - 128));
 		} else {
 			// normal activated ability
 			StackManager.actionManager
 					.succeedClickOn(((WaitingAbility) StackManager.actionManager.currentAction)
 							.abilitiesOf(card).get(index));
 		}
 	}
 
 	/***
 	 * will contains MAction objects of cost part
 	 */
 	protected MAction[] actionList;
 
 	/***
 	 * will contains MAction objects of effect part
 	 */
 	protected MAction[] effectList;
 
 	private static final int REAL_TARGET = 2;
 
 	private static final int SILENT_TARGET = 1;
 
 	private static final int NO_TARGET = 0;
 
 	private static final int TARGET_OPTIONS = 3;
 
 	private static final int OBJECT_OPTIONS = 4;
 
 	private static final int REMOVE_OBJECT = 4;
 
 	/***
 	 * Is this ability contains targeting or removing object action(s).
 	 */
 	protected int checkingOptions;
 
 }