/*
    *   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.action;
  
  import java.awt.BorderLayout;
  import java.awt.Dimension;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.io.IOException;
  import java.io.InputStream;
  
  import javax.swing.BoxLayout;
  import javax.swing.JButton;
  import javax.swing.JLabel;
  import javax.swing.JPanel;
  import javax.swing.JScrollPane;
  import javax.swing.JTabbedPane;
  import javax.swing.ScrollPaneConstants;
  import javax.swing.SwingConstants;
  
  import net.sf.magicproject.action.WaitChoosenActionChoice;
  import net.sf.magicproject.action.context.ActionContextWrapper;
  import net.sf.magicproject.action.handler.ChoosenAction;
  import net.sf.magicproject.clickable.ability.Ability;
  import net.sf.magicproject.clickable.targetable.card.CardFactory;
  import net.sf.magicproject.clickable.targetable.card.MCard;
  import net.sf.magicproject.database.DatabaseFactory;
  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.tools.Log;
  import net.sf.magicproject.ui.MagicUIComponents;
  import net.sf.magicproject.ui.UIHelper;
  import net.sf.magicproject.ui.i18n.LanguageManager;
  import net.sf.magicproject.ui.wizard.WizardImageIcon;
  
  /***
   * The panel containing all playable action.
   * 
   * @author <a href="mailto:fabdouglas@users.sourceforge.net">Fabrice Daugan </a>
   * @since 0.90
   */
  public class ChoosenCostPanel extends JPanel implements ActionListener {
  
  	/***
  	 * Create a new instance of this class.
  	 */
  	public ChoosenCostPanel() {
  		super(new BorderLayout());
  		final JPanel controlsPanel = new JPanel(null);
  		final BoxLayout layout0 = new BoxLayout(controlsPanel, BoxLayout.X_AXIS);
  		controlsPanel.setLayout(layout0);
  		actionsPanel = new JPanel();
  		final BoxLayout layout = new BoxLayout(actionsPanel, BoxLayout.Y_AXIS);
  		actionsPanel.setLayout(layout);
  		cancelButton = new JButton(LanguageManager.getString("cancel"), UIHelper
  				.getIcon("cancel.gif"));
  		cancelButton.setEnabled(false);
  		final JScrollPane scrollActions = new JScrollPane();
  		scrollActions
  				.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
  		scrollActions.setAutoscrolls(true);
  		scrollActions.setViewportView(actionsPanel);
  		add(controlsPanel, BorderLayout.SOUTH);
  		add(scrollActions, BorderLayout.CENTER);
  
  		controlsPanel.add(cancelButton);
  		controlsPanel.add(new JPanel());
  		controlsPanel.setPreferredSize(new Dimension(1, 30));
  		miniCard = new JLabel("  ");
  		miniCard.setHorizontalAlignment(SwingConstants.RIGHT);
  		controlsPanel.add(miniCard);
  		cancelButton.addActionListener(this);
  	}
  
  	public void actionPerformed(ActionEvent e) {
  		if (e.getSource() == cancelButton) {
  			StackManager.cancel();
  		}
  	}
  
  	/***
 	 * 
 	 *
 	 */
 	private void cleanPriv() {
 		// clean old actions
 		cancelButton.setEnabled(false);
 		actionsPanel.removeAll();
 		currentAction = null;
 		recordIndex = 0;
 	}
 
 	/***
 	 * Disable multi-way pay
 	 */
 	public void clean() {
 		cleanPriv();
 		recordIndex = 1;
 		((WizardImageIcon) miniCard.getIcon())
 				.setImage(DatabaseFactory.scaledBackImage);
 
 		// desactive the ChoosenAction panel
 		((JTabbedPane) getParent()).setSelectedIndex(0);
 		// miniCard.repaint();
 	}
 
 	/***
 	 * <ul>
 	 * Initialize UI
 	 * <li>Remove all existing JChoosenAction componnents
 	 * <li>Set the card's picture withe the appropriate tooltip
 	 * <li>Fill the panel with the JChoosenAction components associated to the
 	 * given <code>contextes</code>
 	 * <li>Bring to front this panel
 	 * </ul>
 	 * 
 	 * @param card
 	 *          the card owning the played ability
 	 * @param contextes
 	 *          the Action contextes of the played ability
 	 */
 	public void initUI(MCard card, ActionContextWrapper... contextes) {
 		((WizardImageIcon) miniCard.getIcon()).setCard(card);
 		cleanPriv();
 		miniCard.setToolTipText(StackManager.tokenCard.getTooltipString());
 		for (ActionContextWrapper context : contextes) {
 			if (context != null && context.action instanceof ChoosenAction) {
 				actionsPanel.add(new JChoosenAction(context));
 			}
 		}
 		if (actionsPanel.getComponentCount() == 0) {
 			throw new InternalError("No choosenAction");
 		}
 
 		// active the ChoosenAction panel
 		((JTabbedPane) getParent())
 				.setSelectedComponent(MagicUIComponents.choosenCostPanel);
 	}
 
 	/***
 	 * Reset the UI and execute the first ChoosenAction.
 	 * 
 	 * @param card
 	 *          the card owning the played ability
 	 * @param contextes
 	 *          the Action contextes of the played ability
 	 * @return Always false.TODO Modifying choosenAction order is not yet
 	 *         implemented
 	 */
 	public boolean reset(MCard card, ActionContextWrapper[] contextes) {
 		initUI(card, contextes);
 
 		StackManager.actionManager.currentAction = WaitChoosenActionChoice
 				.getInstance();
 
 		// automatically play the first ChoosenAction
 		StackManager.actionManager.completeChoosenAction(WaitChoosenActionChoice
 				.getInstance().succeedClickOn(
 						(JChoosenAction) actionsPanel.getComponent(0)));
 
 		/*
 		 * if (actionsPanel.getComponentCount() == 1) { // play automatically this
 		 * action StackManager.actionManager.currentAction =
 		 * WaitChoosenActionChoice.instance; StackManager.actionManager
 		 * .completeChoosenAction(WaitChoosenActionChoice.instance
 		 * .succeedClickOn(((JCostAction) actionsPanel.getComponent(0)))); return
 		 * false; // return reActivate(((JCostAction) //
 		 * actionsPanel.getComponent(0)).context.contextID); }
 		 * StackManager.actionManager.waitActionChoice();
 		 */
 		return false;
 	}
 
 	/***
 	 * Reactivate this manager giving the choice to highlight.
 	 * 
 	 * @param contextID
 	 *          the action context id
 	 * @return true if there is no more ChoosenAction to activate. Othervise false
 	 *         value indicate a ChoosenAction has been activated. public boolean
 	 *         reActivate(int contextID) { if
 	 *         (!StackManager.actionManager.getActionContext(contextID).isCompleted()) { //
 	 *         the action to activate is not completed if (currentAction != null) { //
 	 *         first disactivate the current action currentAction.disHighLight();
 	 *         currentAction = null; } for (int index = 0; index <
 	 *         actionsPanel.getComponentCount(); index++) { if
 	 *         (actionsPanel.getComponent(index) instanceof JChoosenAction) {
 	 *         currentAction = (JChoosenAction) actionsPanel.getComponent(index);
 	 *         if (currentAction.context.contextID == contextID) { return
 	 *         currentAction.setSelected(); } } } throw new InternalError( "could
 	 *         not find the ChoosenAction with contextID=" + contextID); } // the
 	 *         action to is already completed return true; }
 	 */
 
 	/***
 	 * Initialize
 	 */
 	public void initialize() {
 		miniCard.setToolTipText(CardFactory.ttHeader + "??");
 		miniCard
 				.setIcon(new WizardImageIcon(DatabaseFactory.scaledBackImage, null));
 		ttClick = "<br><br><b>"
 				+ LanguageManager.getString("clickchoosenaction.tooltip") + "</b>";
 	}
 
 	/***
 	 * Set the current ChoosenAction as completed. Incrementing the internal
 	 * execution count and setting the record index.
 	 * 
 	 * @param ability
 	 *          the current ability.
 	 * @param context
 	 *          the context of current ability.
 	 * @param actionContext
 	 *          the context of current action.
 	 * @return true if the current ChoosenAction is completed and if this action
 	 *         has not to be repeated.
 	 */
 	public boolean completeAction(Ability ability, ContextEventListener context,
 			ActionContextWrapper actionContext) {
 		// increment counter
 		actionContext.done++;
 		// notify refresh descrition text
 		if (actionContext.done >= actionContext.repeat) {
 			// completly done
 			actionContext.recordIndex = recordIndex++;
 			actionContext.refreshText(ability, context);
 			return true;
 		}
 		actionContext.refreshText(ability, context);
 		return false;
 	}
 
 	/***
 	 * Find the first uncompleted action, and execute it.
 	 * 
 	 * @return true if an uncompleted has been found.
 	 */
 	public boolean playFirstUncompleted() {
 		for (int index = 0; index < actionsPanel.getComponentCount(); index++) {
 			if (actionsPanel.getComponent(index) instanceof JChoosenAction) {
 				currentAction = (JChoosenAction) actionsPanel.getComponent(index);
 				if (!currentAction.context.isCompleted()) {
 					return currentAction.setSelected();
 				}
 			}
 		}
 		// no more uncompleted action
 		return true;
 	}
 
 	/***
 	 * 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 occured when reading the message
 	 */
 	public void clickOn(InputStream input) throws IOException {
 		// waiting for player information
 		JChoosenAction action = (JChoosenAction) actionsPanel.getComponent(input
 				.read());
 		Log.debug("clickOn(VirtualInput):" + action.context.action);
 		StackManager.actionManager.succeedClickOn(action);
 	}
 
 	/***
 	 * Send to opponent the message indicating that we've clicked on this card
 	 * 
 	 * @param action
 	 *          the choosen action.
 	 */
 	public void sendClickToOpponent(JChoosenAction action) {
 		for (int index = 0; index < actionsPanel.getComponentCount(); index++) {
 			if (actionsPanel.getComponent(index) instanceof JChoosenAction
 					&& actionsPanel.getComponent(index) == action) {
 				ConnectionManager.sendToOpponent(IdMessages.MSG_CLICK_ACTION, index);
 				return;
 			}
 		}
 		throw new InternalError("could not find the ChoosenAction to send");
 	}
 
 	/***
 	 * The current record index the completed action would obtain.
 	 */
 	private int recordIndex;
 
 	/***
 	 * The selected action. Is null if no action is selected.
 	 */
 	private JChoosenAction currentAction;
 
 	private JLabel miniCard;
 
 	/***
 	 * Panel containing card of ability to pay
 	 */
 	private JPanel actionsPanel;
 
 	/***
 	 * The cancel button allowing to cancel the current spell.
 	 */
 	public JButton cancelButton;
 
 	static String ttClick;
 }