* Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved.

*

* Redistribution and use in ability and binary forms, with or without modification, are

* permitted provided that the following conditions are met:

*

*    1. Redistributions of ability 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.

*/

    private static final transient Logger logger = Logger.getLogger(PlayerImpl.class);

    private static Random rnd = new Random();

    /**

     * Used to cancel waiting requests send to the player

     */

    protected boolean abort;

    protected final UUID playerId;

    protected String name;

    protected boolean human;

    protected int life;

    protected boolean wins;

    protected boolean loses;

    protected Library library;

    protected Cards sideboard;

    protected Cards hand;

    protected Cards graveyard;

    protected UUID commanderId;

    protected Abilities<Ability> abilities;

    protected Counters counters;

    protected int landsPlayed;

    protected int landsPerTurn = 1;

    protected int loyaltyUsePerTurn = 1;

    protected int maxHandSize = 7;

    protected int maxAttackedBy = Integer.MAX_VALUE;

    protected ManaPool manaPool;

    // priority control

    protected boolean passed; // player passed priority

    protected boolean passedTurn; // F4

    protected boolean passedUntilEndOfTurn; // F5

    protected boolean passedUntilNextMain; // F6

    protected boolean skippedAtLeastOnce; // used to track if passed started in specific phase

    /**

     * This indicates that player passed all turns until his own turn starts (F9).

     * Note! This differs from passedTurn as it doesn't care about spells and abilities in the stack and will pass them as well.

     */

    protected boolean passedAllTurns; // F9

   

    protected int turns;

    protected int storedBookmark = -1;

    protected int priorityTimeLeft = Integer.MAX_VALUE;

    //

    // conceded or connection lost game

    protected boolean left;

    // set if the player quits the complete match

    protected boolean quit;

    // set if the player lost match because of priority timeout

    protected boolean timerTimeout;

    // set if the player lost match because of idle timeout

    protected boolean idleTimeout;

    protected RangeOfInfluence range;

    protected Set<UUID> inRange = new HashSet<>();

    protected boolean isTestMode = false;

    protected boolean canGainLife = true;

    protected boolean canLoseLife = true;

    protected boolean canPayLifeCost = true;

    protected boolean canPaySacrificeCost = true;

    protected boolean loseByZeroOrLessLife = true;

    protected boolean canPlayCardsFromGraveyard = true;

    protected final List<AlternativeSourceCosts> alternativeSourceCosts = new ArrayList<>();

   

    protected boolean isGameUnderControl = true;

    protected UUID turnController;

    protected Set<UUID> playersUnderYourControl = new HashSet<>();

    protected List<UUID> attachments = new ArrayList<>();

    protected boolean topCardRevealed = false;

  

    // 800.4i When a player leaves the game, any continuous effects with durations that last until that player's next turn

    // or until a specific point in that turn will last until that turn would have begun.

    // They neither expire immediately nor last indefinitely.

    protected boolean reachedNextTurnAfterLeaving = false;

    // indicates that a sourceId will be cast without paying mana

    protected UUID castSourceIdWithoutMana;

    protected UserData userData;

    /**

     * During some steps we can't play anything

     */

    protected final Map<PhaseStep, Step.StepPart> silentPhaseSteps = new HashMap<PhaseStep, Step.StepPart>() {{

        put(PhaseStep.DECLARE_ATTACKERS, Step.StepPart.PRE);

    }};

    public PlayerImpl(String name, RangeOfInfluence range) {

        this(UUID.randomUUID());

        this.name = name;

        this.range = range;

        hand = new CardsImpl(Zone.HAND);

        graveyard = new CardsImpl(Zone.GRAVEYARD);

        abilities = new AbilitiesImpl<>();

        counters = new Counters();

        manaPool = new ManaPool(playerId);

        library = new Library(playerId);

        sideboard = new CardsImpl(Zone.OUTSIDE);

    }

    protected PlayerImpl(UUID id) {

        this.playerId = id;

    }

    public PlayerImpl(final PlayerImpl player) {

        this.abort = player.abort;

        this.playerId = player.playerId;

        this.name = player.name;

        this.human = player.human;

        this.life = player.life;

        this.wins = player.wins;

        this.loses = player.loses;

        this.library = player.library.copy();

        this.sideboard = player.sideboard.copy();

        this.hand = player.hand.copy();

        this.graveyard = player.graveyard.copy();

        this.commanderId = player.commanderId;

        this.abilities = player.abilities.copy();

        this.counters = player.counters.copy();

        this.landsPlayed = player.landsPlayed;

        this.landsPerTurn = player.landsPerTurn;

        this.loyaltyUsePerTurn = player.loyaltyUsePerTurn;

        this.maxHandSize = player.maxHandSize;

        this.maxAttackedBy = player.maxAttackedBy;

        this.manaPool = player.manaPool.copy();

        this.turns = player.turns;

        this.left = player.left;

        this.quit = player.quit;

        this.timerTimeout = player.timerTimeout;

        this.idleTimeout = player.idleTimeout;

        this.range = player.range;

        this.canGainLife = player.canGainLife;

        this.canLoseLife = player.canLoseLife;

        this.loseByZeroOrLessLife = player.loseByZeroOrLessLife;

        this.canPlayCardsFromGraveyard = player.canPlayCardsFromGraveyard;

        this.attachments.addAll(player.attachments);

        this.inRange.addAll(player.inRange);

        this.userData = player.userData;

        this.canPayLifeCost = player.canPayLifeCost;

        this.canPaySacrificeCost = player.canPaySacrificeCost;

        this.alternativeSourceCosts.addAll(player.alternativeSourceCosts);

        this.storedBookmark = player.storedBookmark;

        this.topCardRevealed = player.topCardRevealed;

        this.playersUnderYourControl.clear();

        this.playersUnderYourControl.addAll(player.playersUnderYourControl);

        this.isTestMode = player.isTestMode;

        this.isGameUnderControl = player.isGameUnderControl;

        this.turnController = player.turnController;

        this.passed = player.passed;

       

        this.passedTurn = player.passedTurn;

        this.passedUntilEndOfTurn = player.passedUntilEndOfTurn;

        this.passedUntilNextMain = player.passedUntilNextMain;

        this.skippedAtLeastOnce = player.skippedAtLeastOnce;

        this.passedAllTurns = player.passedAllTurns;

       

        this.priorityTimeLeft = player.getPriorityTimeLeft();

        this.reachedNextTurnAfterLeaving = player.reachedNextTurnAfterLeaving;

        this.castSourceIdWithoutMana = player.castSourceIdWithoutMana;

    }

    @Override

    public void restore(Player player) {

        this.name = player.getName();

        this.human = player.isHuman();

        this.life = player.getLife();

        this.wins = player.hasWon();

        this.loses = player.hasLost();

        this.library = player.getLibrary().copy();

        this.sideboard = player.getSideboard().copy();

        this.hand = player.getHand().copy();

        this.graveyard = player.getGraveyard().copy();

        this.commanderId = player.getCommanderId();

        this.abilities = player.getAbilities().copy();

        this.counters = player.getCounters().copy();

        this.landsPlayed = player.getLandsPlayed();

        this.landsPerTurn = player.getLandsPerTurn();

        this.loyaltyUsePerTurn = player.getLoyaltyUsePerTurn();

        this.maxHandSize = player.getMaxHandSize();

        this.maxAttackedBy = player.getMaxAttackedBy();

        this.manaPool = player.getManaPool().copy();

        this.turns = player.getTurns();

        this.left = player.hasLeft();

        this.quit = player.hasQuit();

        this.timerTimeout = player.hasTimerTimeout();

        this.idleTimeout = player.hasIdleTimeout();

        this.range = player.getRange();

        this.canGainLife = player.isCanGainLife();

        this.canLoseLife = player.isCanLoseLife();

        this.attachments.clear();

        this.attachments.addAll(player.getAttachments());

        this.inRange.clear();

        this.inRange.addAll(player.getInRange());

        this.userData = player.getUserData();

        this.canPayLifeCost = player.canPayLifeCost();

        this.canPaySacrificeCost = player.canPaySacrificeCost();

        this.loseByZeroOrLessLife = player.canLoseByZeroOrLessLife();

        this.canPlayCardsFromGraveyard = player.canPlayCardsFromGraveyard();

        this.alternativeSourceCosts.addAll(player.getAlternativeSourceCosts());

        this.storedBookmark = player.getStoredBookmark();

        this.topCardRevealed = player.isTopCardRevealed();

        this.playersUnderYourControl.clear();

        this.playersUnderYourControl.addAll(player.getPlayersUnderYourControl());

        this.isTestMode = player.isTestMode();

        this.isGameUnderControl = player.isGameUnderControl();

        this.turnController = player.getTurnControlledBy();

        this.passed = player.isPassed();

        this.priorityTimeLeft = player.getPriorityTimeLeft();

        this.reachedNextTurnAfterLeaving = player.hasReachedNextTurnAfterLeaving();

        this.castSourceIdWithoutMana = player.getCastSourceIdWithoutMana();

    }

    @Override

    public void useDeck(Deck deck, Game game) {

        library.clear();

        library.addAll(deck.getCards(), game);

        sideboard.clear();

        for (Card card : deck.getSideboard()) {

            sideboard.add(card);

        }

    }

    /**

     * Cast e.g. from Karn Liberated to restart the current game

     * @param game

     */

    @Override

    public void init(Game game) {

        init(game, false);

    }

    @Override

    public void init(Game game, boolean testMode) {

        this.abort = false;

        if (!testMode) {

            this.hand.clear();

            this.graveyard.clear();

        }

        this.library.reset();

        this.abilities.clear();

        this.counters.clear();

        this.wins = false;

        this.loses = false;

        this.left = false;

        // reset is neccessary because in tournament player will be used for each round

        this.quit = false;

        this.timerTimeout = false;

        this.idleTimeout = false;

        this.turns = 0;

        this.isGameUnderControl = true;

        this.turnController = this.getId();

        this.playersUnderYourControl.clear();

        this.passed = false;

        this.passedTurn = false;

        this.passedUntilEndOfTurn = false;

        this.passedUntilNextMain = false;

        this.skippedAtLeastOnce = false;

        this.passedAllTurns = false;

        this.canGainLife = true;

        this.canLoseLife = true;

        this.topCardRevealed = false;

        this.setLife(game.getLife(), game);

        this.setReachedNextTurnAfterLeaving(false);

        game.getState().getWatchers().add(new BloodthirstWatcher(playerId));

        this.castSourceIdWithoutMana = null;

    }

    /**

     * called before apply effects

     *

     */

    @Override

    public void reset() {

        this.abilities.clear();

        this.landsPerTurn = 1;

        this.loyaltyUsePerTurn = 1;

        this.maxHandSize = 7;

        this.maxAttackedBy = Integer.MAX_VALUE;

        this.canGainLife = true;

        this.canLoseLife = true;

        this.canPayLifeCost = true;

        this.canPaySacrificeCost = true;

        this.loseByZeroOrLessLife = true;

        this.canPlayCardsFromGraveyard = false;

        this.topCardRevealed = false;

        this.alternativeSourceCosts.clear();

        this.castSourceIdWithoutMana = null;

        this.getManaPool().clearEmptyManaPoolRules();

    }

    @Override

    public Counters getCounters() {

        return counters;

    }

    @Override

    public void otherPlayerLeftGame(Game game) {

        findRange(game);

    }

    @Override

    public void beginTurn(Game game) {

        this.landsPlayed = 0;

        findRange(game);

    }

    @Override

    public RangeOfInfluence getRange() {

        return range;

    }

    protected void findRange(Game game) {

        //20100423 - 801.2c

        inRange.clear();

        if (range == RangeOfInfluence.ALL) {

            for (Player player: game.getPlayers().values()) {

                if (!player.hasLeft()) {

                    inRange.add(player.getId());

                }

            }

        }

        else {

            if ((range.getRange() * 2) + 1 >= game.getPlayers().size()) {

                for (Player player: game.getPlayers().values()) {

                    if (!player.hasLeft()) {

                        inRange.add(player.getId());

                    }

                }

            }

            else {

                inRange.add(playerId);

                PlayerList players = game.getState().getPlayerList(playerId);

                for (int i = 0; i < range.getRange(); i++) {

                    Player player = players.getNext(game);

                    while (player.hasLeft()) {

                        player = players.getNext(game);

                    }

                    inRange.add(player.getId());

                }

                players = game.getState().getPlayerList(playerId);

                for (int i = 0; i < range.getRange(); i++) {

                    Player player = players.getPrevious(game);

                    while (player.hasLeft()) {

                        player = players.getPrevious(game);

                    }

                    inRange.add(player.getId());

                }

            }

        }

    }

    @Override

    public Set<UUID> getInRange() {

        return inRange;

    }

    @Override

    public Set<UUID> getPlayersUnderYourControl() {

        return this.playersUnderYourControl;

    }

    @Override

    public void controlPlayersTurn(Game game, UUID playerId) {

        if (!playerId.equals(this.getId())) {

            this.playersUnderYourControl.add(playerId);

            Player player = game.getPlayer(playerId);

            if (!player.hasLeft()&& !player.hasLost()) {

                player.setGameUnderYourControl(false);

                player.setTurnControlledBy(this.getId());

            }

            DelayedTriggeredAbility ability = new AtTheEndOfTurnStepPostDelayedTriggeredAbility(new LoseControlOnOtherPlayersControllerEffect());

            ability.setSourceId(getId());

            ability.setControllerId(getId());

            game.addDelayedTriggeredAbility(ability);

        }

    }

    @Override

    public void setTurnControlledBy(UUID playerId) {

        this.turnController = playerId;

    }

    @Override

    public UUID getTurnControlledBy() {

        return this.turnController;

    }

    @Override

    public void resetOtherTurnsControlled() {

        playersUnderYourControl.clear();

    }

    @Override

    public boolean isGameUnderControl() {

        return isGameUnderControl;

    }

    @Override

    public void setGameUnderYourControl(boolean value) {

        this.isGameUnderControl = value;

    }

    @Override

    public void endOfTurn(Game game) {

        this.passedTurn = false;

    }

    @Override

    public boolean canBeTargetedBy(MageObject source, Game game) {

        if (this.hasLost() || this.hasLeft()) {

            return false;

        }

        if (source != null) {

            if (abilities.containsKey(ShroudAbility.getInstance().getId())) {

                return false;

            }

            if (abilities.containsKey(HexproofAbility.getInstance().getId())) {

                UUID controllerId = null;

                if (source instanceof Permanent) {

                    controllerId = ((Permanent) source).getControllerId();

                } else if (source instanceof StackObject) {

                    controllerId = ((StackObject) source).getControllerId();

                }

                if (controllerId != null && this.hasOpponent(controllerId, game) &&

                        !game.getContinuousEffects().asThough(this.getId(), AsThoughEffectType.HEXPROOF, this.getId(), game)) {

                    return false;

                }

            }

            if (hasProtectionFrom(source, game)) {

                return false;

            }

        }

        return true;

    }

    @Override

    public boolean hasProtectionFrom(MageObject source, Game game) {

        for (ProtectionAbility ability: abilities.getProtectionAbilities()) {

            if (!ability.canTarget(source, game)) {

                return true;

            }

        }

        return false;

    }

    @Override

    public int drawCards(int num, Game game) {

        return game.doAction(new MageDrawAction(this, num, null));

    }

    @Override

    public int drawCards(int num, Game game, ArrayList<UUID> appliedEffects) {

        return game.doAction(new MageDrawAction(this, num, appliedEffects));

    }

    @Override

    public void discardToMax(Game game) {

        if (hand.size() > this.maxHandSize) {

            game.informPlayers(new StringBuilder(getName()).append(" discards down to ").append(this.maxHandSize).append(this.maxHandSize == 1?" hand card":" hand cards").toString());

            while (isInGame() && hand.size() > this.maxHandSize) {

                TargetDiscard target = new TargetDiscard(playerId);

                target.setTargetName(new StringBuilder(" card to discard (").append(hand.size() - this.maxHandSize).append(" in total)").toString());

                choose(Outcome.Discard, target, null, game);

                discard(hand.get(target.getFirstTarget(), game), null, game);

            }

        }

    }

    @Override

    public boolean putInHand(Card card, Game game) {

        if (card.getOwnerId().equals(playerId)) {

            this.hand.add(card);

            game.setZone(card.getId(), Zone.HAND);

        } else {

            return game.getPlayer(card.getOwnerId()).putInHand(card, game);

        }

        return true;

    }

    @Override

    public boolean removeFromHand(Card card, Game game) {

        hand.remove(card);

        return true;

    }

    @Override

    public boolean removeFromLibrary(Card card, Game game) {

        if (card == null) {

            return false;

        }

        library.remove(card.getId(), game);

        return true;

    }

    @Override

    public void discard(int amount, Ability source, Game game) {

        if (amount >= hand.size()) {

            while (hand.size() > 0) {

                discard(hand.get(hand.iterator().next(), game), source, game);

            }

            return;

        }

        int numDiscarded = 0;

        while (isInGame() && numDiscarded < amount) {

            if (hand.size() == 0) {

                break;

            }

            TargetDiscard target = new TargetDiscard(playerId);

            choose(Outcome.Discard, target, source.getSourceId(), game);

            Card card = hand.get(target.getFirstTarget(), game);

            if (card != null) {

                numDiscarded++;

                discard(card, source, game);

            }

        }

    }

    @Override

    public boolean discard(Card card, Ability source, Game game) {

        //20100716 - 701.7

        /* 701.7. Discard #

            701.7a To discard a card, move it from its owner’s hand to that player’s graveyard.

            701.7b By default, effects that cause a player to discard a card allow the affected

                   player to choose which card to discard. Some effects, however, require a random

                   discard or allow another player to choose which card is discarded.

            701.7c If a card is discarded, but an effect causes it to be put into a hidden zone

                   instead of into its owner’s graveyard without being revealed, all values of that

                   card’s characteristics are considered to be undefined.

                   TODOD:

                   If a card is discarded this way to pay a cost that specifies a characteristic

                   about the discarded card, that cost payment is illegal; the game returns to

                   the moment before the cost was paid (see rule 717, "Handling Illegal Actions").

        */

        if (card != null) {

            // write info to game log first so game log infos from triggered or replacement effects follow in the game log

            game.informPlayers(new StringBuilder(name).append(" discards ").append(card.getName()).toString());