TargetAddress.java

/*
 *  Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without modification, are
 *  permitted provided that the following conditions are met:
 *
 *     1. Redistributions of source code must retain the above copyright notice, this list of
 *        conditions and the following disclaimer.
 *
 *     2. Redistributions in binary form must reproduce the above copyright notice, this list
 *        of conditions and the following disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 *  THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED
 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 *  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR
 *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 *  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 *  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 *  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *  The views and conclusions contained in the software and documentation are those of the
 *  authors and should not be interpreted as representing official policies, either expressed
 *  or implied, of BetaSteward_at_googlemail.com.
 */
package mage.util;

import java.util.Iterator;
import java.util.Objects;
import java.util.UUID;
import mage.abilities.Mode;
import mage.abilities.Modes;
import mage.abilities.SpellAbility;
import mage.cards.Card;
import mage.game.stack.Spell;
import mage.target.Target;

/**
 * @author duncant
 */
public class TargetAddress {

    protected final int spellAbilityIndex;
    protected final UUID mode;
    protected final int targetIndex;

    public TargetAddress(int spellAbilityIndex, UUID mode, int targetIndex) {
        this.spellAbilityIndex = spellAbilityIndex;
        this.mode = mode;
        this.targetIndex = targetIndex;
    }

    protected static class TargetAddressIterable implements Iterable<TargetAddress> {

        protected final Card card;

        public TargetAddressIterable(Card card) {
            this.card = card;
        }

        @Override
        public Iterator<TargetAddress> iterator() {
            return new TargetAddressIterator(card);
        }
    }

    protected static class TargetAddressIterator implements Iterator<TargetAddress> {

        protected final Iterator<SpellAbility> spellAbilityIterator;
        protected Integer lastSpellAbilityIndex = null;
        protected Iterator<UUID> modeIterator = null;
        protected Modes modes = null;
        protected UUID lastMode = null;
        protected Iterator<Target> targetIterator = null;
        protected Integer lastTargetIndex = null;

        public TargetAddressIterator(Spell spell) {
            this.spellAbilityIterator = spell.getSpellAbilities().iterator();
            calcNext();
        }

        public TargetAddressIterator(Card card) {
            this.lastSpellAbilityIndex = 0;
            this.spellAbilityIterator = null;
            this.modes = card.getSpellAbility().getModes();
            this.modeIterator = this.modes.getSelectedModes().iterator();
            calcNext();
        }

        @Override
        public boolean hasNext() {
            return lastTargetIndex != null;
        }

        @Override
        public TargetAddress next() {
            TargetAddress ret = new TargetAddress(lastSpellAbilityIndex,
                    lastMode,
                    lastTargetIndex);
            calcNext();
            return ret;

        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }

        protected void calcNext() {
            if (targetIterator == null) {
                if (modeIterator == null) {
                    if (spellAbilityIterator != null && spellAbilityIterator.hasNext()) {
                        if (lastSpellAbilityIndex == null) {
                            lastSpellAbilityIndex = 0;
                        } else {
                            lastSpellAbilityIndex++;
                        }
                        modes = spellAbilityIterator.next().getModes();
                        modeIterator = modes.getSelectedModes().iterator();
                    } else {
                        lastSpellAbilityIndex = null;
                        return;
                    }
                }

                if (modeIterator != null && modeIterator.hasNext()) {
                    lastMode = modeIterator.next();
                    targetIterator = modes.get(lastMode).getTargets().iterator();
                } else {
                    lastMode = null;
                    modes = null;
                    modeIterator = null;
                    calcNext();
                }
            }

            if (targetIterator != null && targetIterator.hasNext()) {
                if (lastTargetIndex == null) {
                    lastTargetIndex = 0;
                } else {
                    lastTargetIndex++;
                }
                targetIterator.next();
            } else {
                targetIterator = null;
                lastTargetIndex = null;
                calcNext();
            }
        }
    }

    public static Iterable<TargetAddress> walk(Card card) {
        return new TargetAddressIterable(card);
    }

    public Target getTarget(Spell spell) {
        return getMode(spell).getTargets().get(targetIndex);
    }

    public Target getTarget(Card card) {
        return getMode(card).getTargets().get(targetIndex);
    }

    public Mode getMode(Spell spell) {
        return getSpellAbility(spell).getModes().get(mode);
    }

    public Mode getMode(Card card) {
        return getSpellAbility(card).getModes().get(mode);
    }

    public SpellAbility getSpellAbility(Spell spell) {
        return spell.getSpellAbilities().get(spellAbilityIndex);
    }

    public SpellAbility getSpellAbility(Card card) {
        if (spellAbilityIndex > 0) {
            throw new IndexOutOfBoundsException("SpellAbility index " + spellAbilityIndex + " is out of bounds.");
        }
        return card.getSpellAbility();
    }

    public boolean equals(TargetAddress other) {
        return spellAbilityIndex == other.spellAbilityIndex
                && mode.equals(other.mode)
                && targetIndex == other.targetIndex;
    }

    @Override
    public int hashCode() {
        return spellAbilityIndex ^ mode.hashCode() ^ targetIndex;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final TargetAddress other = (TargetAddress) obj;
        if (this.spellAbilityIndex != other.spellAbilityIndex) {
            return false;
        }
        if (this.targetIndex != other.targetIndex) {
            return false;
        }
        return Objects.equals(this.mode, other.mode);
    }
}