* 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.

*/

*

* @author BetaSteward_at_googlemail.com, nantuko8

*/

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

    private static final String YOUR_HAND = "Your hand";

    private static final int X_PHASE_WIDTH = 55;

    private static final int STACK_MIN_CARDS_OFFSET_Y = 7;

    private final Map<UUID, PlayAreaPanel> players = new HashMap<>();

    private final Map<UUID, ExileZoneDialog> exiles = new HashMap<>();

    private final Map<String, ShowCardsDialog> revealed = new HashMap<>();

    private final Map<String, ShowCardsDialog> lookedAt = new HashMap<>();

    private final ArrayList<ShowCardsDialog> pickTarget = new ArrayList<>();

    private UUID gameId;

    private UUID playerId; // playerId of the player

    private Session session;

    GamePane gamePane;

    private ReplayTask replayTask;

    private final PickNumberDialog pickNumber;

    private JLayeredPane jLayeredPane;

    private String chosenHandKey = "You";

    private boolean smallMode = false;

    private boolean initialized = false;

    private int lastUpdatedTurn;

    private boolean menuNameSet = false;

   

   

    private Map<String, Card> loadedCards = new HashMap<>();

    private int storedHeight;

   

    private Map<String, HoverButton> hoverButtons;

    public GamePanel() {

        initComponents();

        pickNumber = new PickNumberDialog();

        MageFrame.getDesktop().add(pickNumber, JLayeredPane.MODAL_LAYER);

        this.feedbackPanel.setConnectedChatPanel(this.userChatPanel);

        this.stack.setMinOffsetY(STACK_MIN_CARDS_OFFSET_Y);

        // Override layout (I can't edit generated code)

        this.setLayout(new BorderLayout());

        final JLayeredPane jLayeredBackgroundPane = new JLayeredPane();

        jLayeredBackgroundPane.setSize(1024, 768);

        this.add(jLayeredBackgroundPane);

        jLayeredBackgroundPane.add(jSplitPane0, JLayeredPane.DEFAULT_LAYER);

        Map<String, JComponent> myUi = getUIComponents(jLayeredBackgroundPane);

        Plugins.getInstance().updateGamePanel(myUi);

        // Enlarge jlayeredpane on resize

        addComponentListener(new ComponentAdapter() {

            @Override

            public void componentResized(ComponentEvent e) {

                int width = ((JComponent) e.getSource()).getWidth();

                int height = ((JComponent) e.getSource()).getHeight();

                jLayeredBackgroundPane.setSize(width, height);

                jSplitPane0.setSize(width, height);

                if (height < storedHeight) {

                    pnlBattlefield.setSize(0, 200);

                }

                storedHeight = height;

                sizeToScreen();

                if (!initialized) {

                    String state = PreferencesDialog.getCachedValue(PreferencesDialog.KEY_BIG_CARD_TOGGLED, null);

                    if (state != null && state.equals("down")) {

                        jSplitPane0.setDividerLocation(1.0);

                    }

                    initialized = true;

                }

            }

        });

    }

    private Map<String, JComponent> getUIComponents(JLayeredPane jLayeredPane) {

        Map<String, JComponent> components = new HashMap<>();

        components.put("jSplitPane1", jSplitPane1);

        components.put("pnlBattlefield", pnlBattlefield);

        components.put("jPanel3", jPanel3);

        components.put("hand", handContainer);

        components.put("gameChatPanel", gameChatPanel);

        components.put("userChatPanel", userChatPanel);

        components.put("jLayeredPane", jLayeredPane);

        components.put("gamePanel", this);

        return components;

    }

    public void cleanUp() {

        MageFrame.removeGame(gameId);

        saveDividerLocations();

        this.gameChatPanel.disconnect();

        this.userChatPanel.disconnect();

        this.removeListener();

        this.handContainer.cleanUp();

        this.stack.cleanUp();

        for(Map.Entry<UUID, PlayAreaPanel>  playAreaPanelEntry: players.entrySet()) {

            playAreaPanelEntry.getValue().CleanUp();

        }

        this.players.clear();

       

        jLayeredPane.remove(abilityPicker);

        this.abilityPicker.cleanUp();

        jLayeredPane.remove(DialogManager.getManager(gameId));

        DialogManager.removeGame(gameId);

       

        if (pickNumber != null) {

            pickNumber.removeDialog();

        }

        for (ExileZoneDialog exileDialog: exiles.values()) {

            exileDialog.cleanUp();

            exileDialog.removeDialog();

        }

        for (ShowCardsDialog revealDialog: revealed.values()) {

            revealDialog.cleanUp();

            revealDialog.removeDialog();

        }

        for (ShowCardsDialog lookedAtDialog: lookedAt.values()) {

            lookedAtDialog.cleanUp();

            lookedAtDialog.removeDialog();

        }

        for (ShowCardsDialog pickTargetDialog: pickTarget) {

            pickTargetDialog.cleanUp();

            pickTargetDialog.removeDialog();

        }

        Plugins.getInstance().getActionCallback().hidePopup();

        try {

            Component popupContainer = MageFrame.getUI().getComponent(MageComponents.POPUP_CONTAINER);

            popupContainer.setVisible(false);

        } catch (InterruptedException ex) {

            logger.fatal("popupContainer error:", ex);

        }

        jPanel2.remove(bigCard);

        this.bigCard = null;      

    }

    private void saveDividerLocations() {

        // save panel sizes and divider locations.

        Rectangle rec = MageFrame.getDesktop().getBounds();

        String sb = Double.toString(rec.getWidth()) + "x" + Double.toString(rec.getHeight());

        PreferencesDialog.saveValue(PreferencesDialog.KEY_MAGE_PANEL_LAST_SIZE, sb);

        PreferencesDialog.saveValue(PreferencesDialog.KEY_GAMEPANEL_DIVIDER_LOCATION_0, Integer.toString(this.jSplitPane0.getDividerLocation()));

        PreferencesDialog.saveValue(PreferencesDialog.KEY_GAMEPANEL_DIVIDER_LOCATION_1, Integer.toString(this.jSplitPane1.getDividerLocation()));

        PreferencesDialog.saveValue(PreferencesDialog.KEY_GAMEPANEL_DIVIDER_LOCATION_2, Integer.toString(this.jSplitPane2.getDividerLocation()));

    }

    private void restoreDividerLocations() {

        Rectangle rec = MageFrame.getDesktop().getBounds();

        if (rec != null) {

            String size = PreferencesDialog.getCachedValue(PreferencesDialog.KEY_MAGE_PANEL_LAST_SIZE, null);

            String sb = Double.toString(rec.getWidth()) + "x" + Double.toString(rec.getHeight());

            // use divider positions only if screen size is the same as it was the time the settings were saved

            if (size != null && size.equals(sb)) {

                String location = PreferencesDialog.getCachedValue(PreferencesDialog.KEY_GAMEPANEL_DIVIDER_LOCATION_0, null);

                if (location != null && jSplitPane0 != null) {

                    jSplitPane0.setDividerLocation(Integer.parseInt(location));

                }

                location = PreferencesDialog.getCachedValue(PreferencesDialog.KEY_GAMEPANEL_DIVIDER_LOCATION_1, null);

                if (location != null && jSplitPane1 != null) {

                    jSplitPane1.setDividerLocation(Integer.parseInt(location));

                }

                location = PreferencesDialog.getCachedValue(PreferencesDialog.KEY_GAMEPANEL_DIVIDER_LOCATION_2, null);

                if (location != null && jSplitPane2 != null) {

                    jSplitPane2.setDividerLocation(Integer.parseInt(location));

                }

            }

        }

    }

    private void sizeToScreen() {

        Rectangle rect = this.getBounds();

        if (rect.height < 720) {

            if (!smallMode) {

                smallMode = true;

                Dimension bbDimension = new Dimension(128, 184);

                bigCard.setMaximumSize(bbDimension);

                bigCard.setMinimumSize(bbDimension);

                bigCard.setPreferredSize(bbDimension);

                pnlShortCuts.revalidate();

                pnlShortCuts.repaint();

                //this.handContainer.sizeHand(0.8, smallMode);

                for (PlayAreaPanel p: players.values()) {

                    p.sizePlayer(smallMode);

                }

            }

        }

        else {

            if (smallMode) {

                smallMode = false;

                Dimension bbDimension = new Dimension(256, 367);

                bigCard.setMaximumSize(bbDimension);

                bigCard.setMinimumSize(bbDimension);

                bigCard.setPreferredSize(bbDimension);

                pnlShortCuts.revalidate();

                pnlShortCuts.repaint();

                this.handContainer.sizeHand(1, smallMode);

                for (PlayAreaPanel p: players.values()) {

                    p.sizePlayer(smallMode);

                }

            }

        }

        ArrowBuilder.getBuilder().setSize(rect.width, rect.height);

        DialogManager.getManager(gameId).setScreenWidth(rect.width);

        DialogManager.getManager(gameId).setScreenHeight(rect.height);

        DialogManager.getManager(gameId).setBounds(0, 0, rect.width, rect.height);

    }

    public synchronized void showGame(UUID gameId, UUID playerId, GamePane gamePane) {

        this.gameId = gameId;

        this.gamePane = gamePane;

        this.playerId = playerId;

        session = MageFrame.getSession();

        MageFrame.addGame(gameId, this);

        this.feedbackPanel.init(gameId);

        this.feedbackPanel.clear();

        this.abilityPicker.init(session, gameId);

        this.btnConcede.setVisible(true);

        this.btnStopWatching.setVisible(false);

        this.btnSwitchHands.setVisible(false);

        this.btnCancelSkip.setVisible(true);

        this.btnSkipToNextTurn.setVisible(true);

        this.btnSkipToEndTurn.setVisible(true);

        this.btnSkipToNextMain.setVisible(true);

        this.btnSkipToYourTurn.setVisible(true);

       

        this.pnlReplay.setVisible(false);

       

        this.gameChatPanel.clear();

        this.gameChatPanel.connect(session.getGameChatId(gameId));

        if (!session.joinGame(gameId)) {

            removeGame();

        }

    }

    public synchronized void watchGame(UUID gameId, GamePane gamePane) {

        this.gameId = gameId;

        this.gamePane = gamePane;

        this.playerId = null;

        session = MageFrame.getSession();

        MageFrame.addGame(gameId, this);

        this.feedbackPanel.init(gameId);

        this.feedbackPanel.clear();

        this.btnConcede.setVisible(false);

        this.btnStopWatching.setVisible(true);

        this.btnSwitchHands.setVisible(false);

        this.btnCancelSkip.setVisible(false);

        this.btnSkipToNextTurn.setVisible(false);

        this.btnSkipToEndTurn.setVisible(false);

        this.btnSkipToNextMain.setVisible(false);

        this.btnSkipToYourTurn.setVisible(false);

       

       

        this.pnlReplay.setVisible(false);

        this.gameChatPanel.clear();

        this.gameChatPanel.connect(session.getGameChatId(gameId));

        if (!session.watchGame(gameId)) {

            removeGame();

        }

        for (PlayAreaPanel panel : getPlayers().values()) {

            panel.setPlayingMode(false);

        }

    }

    public synchronized void replayGame(UUID gameId) {

        this.gameId = gameId;

        this.playerId = null;

        session = MageFrame.getSession();

        MageFrame.addGame(gameId, this);

        this.feedbackPanel.init(gameId);

        this.feedbackPanel.clear();

        this.btnConcede.setVisible(false);

        this.btnSkipToNextTurn.setVisible(false);

        this.btnSwitchHands.setVisible(false);

        this.btnStopWatching.setVisible(false);

        this.pnlReplay.setVisible(true);

        this.gameChatPanel.clear();

        if (!session.startReplay(gameId)) {

            removeGame();

        }

        for (PlayAreaPanel panel : getPlayers().values()) {

            panel.setPlayingMode(false);

        }

    }

    /**

     * Closes the game and it's resources

     */

    public void removeGame() {

        Component c = this.getParent();

        while (c != null && !(c instanceof GamePane)) {

            c = c.getParent();

        }

        if (c != null) {

            ((GamePane)c).removeGame();

        }

    }

    public synchronized void init(GameView game) {

        addPlayers(game);

        updateGame(game);

        lastUpdatedTurn = game.getTurn();

    }

    private void addPlayers(GameView game) {

        this.players.clear();

        this.pnlBattlefield.removeAll();

        //arrange players in a circle with the session player at the bottom left

        int numSeats = game.getPlayers().size();

        int numColumns = (numSeats + 1) / 2;

        boolean oddNumber = (numColumns > 1 && numSeats % 2 == 1);

        int col = 0;

        int row = 1;

        int playerSeat = 0;

        if (playerId != null) {

            for (PlayerView player: game.getPlayers()) {

                if (playerId.equals(player.getPlayerId())) {

                    break;

                }

                playerSeat++;

            }

        }

        PlayerView player = game.getPlayers().get(playerSeat);

        PlayAreaPanel sessionPlayer = new PlayAreaPanel(player, bigCard, gameId, true, game.getPriorityTime(), game.isPlayer(), this);

        players.put(player.getPlayerId(), sessionPlayer);

        GridBagConstraints c = new GridBagConstraints();

        c.fill = GridBagConstraints.BOTH;

        c.weightx = 0.5;

        c.weighty = 0.5;

        if (oddNumber) {

            c.gridwidth = 2;

        }

        c.gridx = col;

        c.gridy = row;

        this.pnlBattlefield.add(sessionPlayer, c);

        sessionPlayer.setVisible(true);

        if (oddNumber) {

            col++;

        }

        int playerNum = playerSeat + 1;

        if (playerNum >= numSeats) {

            playerNum = 0;

        }

        while (true) {

            if (row == 1) {

                col++;

            }

            else {

                col--;

            }

            if (col >= numColumns) {

                row = 0;

                col = numColumns - 1;

            }

            player = game.getPlayers().get(playerNum);

            PlayAreaPanel playerPanel = new PlayAreaPanel(player, bigCard, gameId, false, game.getPriorityTime(), game.isPlayer(), this);

            players.put(player.getPlayerId(), playerPanel);

            c = new GridBagConstraints();

            c.fill = GridBagConstraints.BOTH;

            c.weightx = 0.5;

            c.weighty = 0.5;

            c.gridx = col;

            c.gridy = row;

            this.pnlBattlefield.add(playerPanel, c);

            playerPanel.setVisible(true);

            playerNum++;

            if (playerNum >= numSeats) {

                playerNum = 0;

            }

            if (playerNum == playerSeat) {

                break;

            }

        }

        for (PlayAreaPanel p: players.values()) {

            p.sizePlayer(smallMode);

        }

    }

    public synchronized void updateGame(GameView game) {

        updateGame(game, null);

    }

    public synchronized void updateGame(GameView game, Map<String, Serializable> options) {

        if (playerId == null || game.getHand() == null) {

            this.handContainer.setVisible(false);

        } else {

            handCards.clear();

            handCards.put(YOUR_HAND, game.getHand());

            // Mark playable

            if (game.getCanPlayInHand() != null) {

                for (CardView card : handCards.get(YOUR_HAND).values()) {

                    if (game.getCanPlayInHand().contains(card.getId())) {

                        card.setPlayable(true);

                    }

                }

            }

            // Get opponents hand cards if available

            if (game.getOpponentHands() != null) {

                for (Map.Entry<String, SimpleCardsView> hand: game.getOpponentHands().entrySet()) {

                    handCards.put(hand.getKey(), CardsViewUtil.convertSimple(hand.getValue(), loadedCards));

                }

            }

            if (!handCards.containsKey(chosenHandKey)) {

                chosenHandKey = YOUR_HAND;

            }

            handContainer.loadCards(handCards.get(chosenHandKey), bigCard, gameId);

            hideAll();

            // set visible only if we have any other hand visible than ours

            boolean previous = btnSwitchHands.isVisible();

            boolean visible = handCards.size() > 1;

            if (previous != visible) {

                btnSwitchHands.setVisible(visible);

                if (visible) {

                    JOptionPane.showMessageDialog(null, "You control other player's turn. \nUse \"Switch Hand\" button to switch between cards in different hands.");

                } else {

                    JOptionPane.showMessageDialog(null, "You lost control on other player's turn.");

                }

            }

        }

        if (game.getPhase() != null) {

            this.txtPhase.setText(game.getPhase().toString());

        } else {

            this.txtPhase.setText("");

        }

       

        if (game.getStep() != null) {

            updatePhases(game.getStep());

            this.txtStep.setText(game.getStep().toString());

        }

        else {

            this.txtStep.setText("");

        }

        this.txtActivePlayer.setText(game.getActivePlayerName());

        this.txtPriority.setText(game.getPriorityPlayerName());

        this.txtTurn.setText(Integer.toString(game.getTurn()));

        List<UUID> possibleAttackers = new ArrayList<>();

        if (options != null && options.containsKey(Constants.Option.POSSIBLE_ATTACKERS)) {

            if (options.get(Constants.Option.POSSIBLE_ATTACKERS) instanceof List) {

                possibleAttackers.addAll((List) options.get(Constants.Option.POSSIBLE_ATTACKERS));

            }

        }

        for (PlayerView player: game.getPlayers()) {

            if (players.containsKey(player.getPlayerId())) {

                if (!possibleAttackers.isEmpty()) {

                    for (UUID permanentId : possibleAttackers) {

                        if (player.getBattlefield().containsKey(permanentId)) {

                            player.getBattlefield().get(permanentId).setCanAttack(true);

                        }

                    }

                }

                players.get(player.getPlayerId()).update(player);

                if (player.getPlayerId().equals(playerId)) {

                    updateSkipButtons(player.isPassedTurn(), player.isPassedUntilEndOfTurn(), player.isPassedUntilNextMain(), player.isPassedAllTurns());

                }

            } else {

                logger.warn("Couldn't find player.");

                logger.warn("   uuid:" + player.getPlayerId());

                logger.warn("   players:");

                for (PlayAreaPanel p : players.values()) {

                    logger.warn(""+p);

                }

            }

        }

        if (!menuNameSet) {

            StringBuilder sb = new StringBuilder();

            if (playerId == null) {

                sb.append("Watching: ");

            } else {

                sb.append("Playing: ");

            }

            boolean first = true;

            for (PlayerView player: game.getPlayers()) {

                if (first) {

                    first = false;

                } else {

                    sb.append(" - ");

                }

                sb.append(player.getName());

            }

            menuNameSet = true;

            gamePane.setTitle(sb.toString());

        }

        GameManager.getInstance().setStackSize(game.getStack().size());

        displayStack(game, bigCard, feedbackPanel, gameId);

        for (ExileView exile: game.getExile()) {

            if (!exiles.containsKey(exile.getId())) {

                ExileZoneDialog newExile = new ExileZoneDialog();

                exiles.put(exile.getId(), newExile);

                MageFrame.getDesktop().add(newExile, JLayeredPane.MODAL_LAYER);

                newExile.show();

            }

            exiles.get(exile.getId()).loadCards(exile, bigCard, gameId);

        }

        showRevealed(game);

        showLookedAt(game);

        if (game.getCombat().size() > 0) {

            CombatManager.getInstance().showCombat(game.getCombat(), gameId);

        } else {

            CombatManager.getInstance().hideCombat(gameId);

        }

        feedbackPanel.disableUndo();

        this.revalidate();

        this.repaint();

    }

   

    static final int BORDER_SIZE = 2;

    private void updateSkipButtons(boolean turn, boolean endOfTurn, boolean nextMain, boolean allTurns) {

        if (turn) { //F4

            btnSkipToNextTurn.setBorder(new LineBorder(Color.red, BORDER_SIZE));

        } else {

            btnSkipToNextTurn.setBorder(new EmptyBorder(BORDER_SIZE,BORDER_SIZE,BORDER_SIZE,BORDER_SIZE));

        }

        if (endOfTurn) { // F5

            btnSkipToEndTurn.setBorder(new LineBorder(Color.red, BORDER_SIZE));

        } else {

            btnSkipToEndTurn.setBorder(new EmptyBorder(BORDER_SIZE,BORDER_SIZE,BORDER_SIZE,BORDER_SIZE));

        }

        if (nextMain) { // F7

            btnSkipToNextMain.setBorder(new LineBorder(Color.red, BORDER_SIZE));

        } else {

            btnSkipToNextMain.setBorder(new EmptyBorder(BORDER_SIZE,BORDER_SIZE,BORDER_SIZE,BORDER_SIZE));

        }

        if (allTurns) { // F9

            btnSkipToYourTurn.setBorder(new LineBorder(Color.red, BORDER_SIZE));

        } else {

            btnSkipToYourTurn.setBorder(new EmptyBorder(BORDER_SIZE,BORDER_SIZE,BORDER_SIZE,BORDER_SIZE));

        }

    }

    /**

     * Set the same state for menu selections to all player areas.

     * @param manaPoolAutomatic

     */

    public void setMenuStates(boolean manaPoolAutomatic) {

       for(PlayAreaPanel playAreaPanel: players.values()) {

           playAreaPanel.setMenuStates(manaPoolAutomatic);

       }

    }

   

    private void displayStack(GameView game, BigCard bigCard, FeedbackPanel feedbackPanel, UUID gameId) {

        this.stack.loadCards(game.getStack(), bigCard, gameId, null);

    }

    /**

     * Update phase buttons\labels.

     */

    private void updatePhases(PhaseStep step) {

        if (step == null) {

            logger.warn("step is null");

            return;

        }

        if (currentStep != null) {

            currentStep.setLocation(prevPoint);

        }

        switch (step) {

            case UNTAP: updateButton("Untap"); break;

            case UPKEEP: updateButton("Upkeep"); break;

            case DRAW: updateButton("Draw"); break;

            case PRECOMBAT_MAIN: updateButton("Main1"); break;

            case BEGIN_COMBAT: updateButton("Combat_Start"); break;

            case DECLARE_ATTACKERS: updateButton("Combat_Attack"); break;

            case DECLARE_BLOCKERS: updateButton("Combat_Block"); break;

            case FIRST_COMBAT_DAMAGE:

            case COMBAT_DAMAGE: updateButton("Combat_Damage"); break;

            case END_COMBAT: updateButton("Combat_End"); break;

            case POSTCOMBAT_MAIN: updateButton("Main2"); break;

            case END_TURN: updateButton("Cleanup"); break;

        }

    }

    private void updateButton(String name) {

        if (hoverButtons.containsKey(name)) {

            currentStep = hoverButtons.get(name);

            prevPoint = currentStep.getLocation();

            currentStep.setLocation(prevPoint.x - 15, prevPoint.y);

        }

    }

    private void showRevealed(GameView game) {

//        toRemove.addAll(revealed.keySet());

//        for (ShowCardsDialog reveal: revealed.values()) {

//            reveal.clearReloaded(); // seems not to be used

//        }

        for (RevealedView reveal: game.getRevealed()) {

            if (!revealed.containsKey(reveal.getName())) {

                ShowCardsDialog newReveal = new ShowCardsDialog();

                revealed.put(reveal.getName(), newReveal);

            }

            revealed.get(reveal.getName()).loadCards("Revealed " + reveal.getName(), CardsViewUtil.convertSimple(reveal.getCards(), loadedCards), bigCard, Config.dimensions, gameId, false);

        }

//            ShowCardsDialog revealDialog = revealed.get(revealName);

//            if (revealDialog != null) {

//                revealed.remove(revealName);

//                revealDialog.cleanUp();

//                revealDialog.removeDialog();

//            }

//        }

    }

    private void showLookedAt(GameView game) {

        for (ShowCardsDialog looked: lookedAt.values()) {

            looked.clearReloaded();

        }

        for (LookedAtView looked: game.getLookedAt()) {

            if (!lookedAt.containsKey(looked.getName())) {

                ShowCardsDialog newLookedAt = new ShowCardsDialog();

                lookedAt.put(looked.getName(), newLookedAt);

            }

            lookedAt.get(looked.getName()).loadCards("Looked at by " + looked.getName(), CardsViewUtil.convertSimple(looked.getCards(), loadedCards), bigCard, Config.dimensions, gameId, false);

        }

    }

    public void ask(String question, GameView gameView, int messageId) {

        updateGame(gameView);

        this.feedbackPanel.getFeedback(FeedbackMode.QUESTION, question, false, null, messageId);

    }

    /**

     * Shows a pick target dialog  and allows the player to pick a target (e.g. the pick triggered ability)

     *

     * @param message

     * @param cardView

     * @param gameView

     * @param targets

     * @param required

     * @param options

     * @param messageId

     */

    public void pickTarget(String message, CardsView cardView, GameView gameView, Set<UUID> targets, boolean required, Map<String, Serializable> options, int messageId) {

        ShowCardsDialog dialog = null;

        updateGame(gameView);

        Map<String, Serializable> options0 = options == null ? new HashMap<String, Serializable>() : options;

        if (cardView != null && cardView.size() > 0) {

            dialog = showCards(message, cardView, required, options0);

            options0.put("dialog", dialog);

        }

        this.feedbackPanel.getFeedback(required?FeedbackMode.INFORM:FeedbackMode.CANCEL, message, gameView.getSpecial(), options0, messageId);       

        if (dialog != null) {

            this.pickTarget.add(dialog);

        }

    }

    public void inform(String information, GameView gameView, int messageId) {

        updateGame(gameView);

        this.feedbackPanel.getFeedback(FeedbackMode.INFORM, information, gameView.getSpecial(), null, messageId);

    }

    public void endMessage(String message, int messageId) {

        this.feedbackPanel.getFeedback(FeedbackMode.END, message, false, null, messageId);

        ArrowBuilder.getBuilder().removeAllArrows(gameId);

    }

    public int modalQuestion(String message, String title) {

        return JOptionPane.showConfirmDialog(this, message, title, JOptionPane.YES_NO_OPTION);

    }

    public void select(String message, GameView gameView, int messageId, Map<String, Serializable> options) {

        updateGame(gameView, options);

        String messageToDisplay = message;

        Map<String, Serializable> panelOptions = null;

        for (PlayerView playerView : gameView.getPlayers()) {

            if (playerView.getPlayerId().equals(playerId)) {

                if (playerView.isActive()) {

                    panelOptions = new HashMap<>();

                    panelOptions.put("your_turn", true);

                    messageToDisplay = message + " <div style='font-size:11pt'>Your turn</div>";

                }

                // magenoxx: because of uncaught bug with saving state, rolling back and stack

                // undo is allowed only for empty stack

                if (playerView.getStatesSavedSize() > 0 && gameView.getStack().size() == 0) {

                    feedbackPanel.allowUndo(playerView.getStatesSavedSize());

                }

                break;

            }

        }

        this.feedbackPanel.getFeedback(FeedbackMode.SELECT, messageToDisplay, gameView.getSpecial(), panelOptions, messageId);

    }

    public void playMana(String message, GameView gameView, int messageId) {

        updateGame(gameView);

        DialogManager.getManager(gameId).fadeOut();

        this.feedbackPanel.getFeedback(FeedbackMode.CANCEL, message, gameView.getSpecial(), null, messageId);

    }

    public void playXMana(String message, GameView gameView, int messageId) {

        updateGame(gameView);

        DialogManager.getManager(gameId).fadeOut();

        this.feedbackPanel.getFeedback(FeedbackMode.CONFIRM, message, gameView.getSpecial(), null, messageId);

    }

    public void replayMessage(String message) {

        //TODO: implement this

    }

    public void pickAbility(AbilityPickerView choices) {

        hideAll();

        DialogManager.getManager(gameId).fadeOut();

        this.abilityPicker.show(choices, MageFrame.getDesktop().getMousePosition());

    }

    private void hideAll() {

        ActionCallback callback = Plugins.getInstance().getActionCallback();

        ((MageActionCallback)callback).hideGameUpdate(gameId);

    }

    private ShowCardsDialog showCards(String title, CardsView cards, boolean required, Map<String, Serializable> options) {

        hideAll();

        ShowCardsDialog showCards = new ShowCardsDialog();

        showCards.loadCards(title, cards, bigCard, Config.dimensionsEnlarged, gameId, required, options);

        return showCards;

    }

    public void getAmount(int min, int max, String message) {

        pickNumber.showDialog(min, max, message);

        if (pickNumber.isCancel()) {

            session.sendPlayerBoolean(gameId, false);

        }

        else {

            session.sendPlayerInteger(gameId, pickNumber.getAmount());

        }

    }

    public void getChoice(Choice choice, UUID objectId) {

        hideAll();

        PickChoiceDialog pickChoice = new PickChoiceDialog();

        pickChoice.showDialog(choice, objectId);

        if (choice.isKeyChoice()) {

            if (pickChoice.isAutoSelect()) {

                session.sendPlayerString(gameId, "#" + choice.getChoiceKey());

            } else {

                session.sendPlayerString(gameId, choice.getChoiceKey());

            }

        } else {

            session.sendPlayerString(gameId, choice.getChoice());

        }

        pickChoice.removeDialog();

    }

    public void pickPile(String message, CardsView pile1, CardsView pile2) {

        hideAll();

        PickPileDialog pickPileDialog = new PickPileDialog();

        pickPileDialog.loadCards(message, pile1, pile2, bigCard, Config.dimensions, gameId);

        session.sendPlayerBoolean(gameId, pickPileDialog.isPickedPile1());

        pickPileDialog.cleanUp();

        pickPileDialog.removeDialog();

    }

    public Map<UUID, PlayAreaPanel> getPlayers() {

        return players;

    }

    @SuppressWarnings("unchecked")

    private void initComponents() {

        abilityPicker = new mage.client.components.ability.AbilityPicker();

        jSplitPane1 = new javax.swing.JSplitPane();

        jSplitPane0 = new javax.swing.JSplitPane();

        jPanel2 = new javax.swing.JPanel();

        jPanel3 = new javax.swing.JPanel();

        pnlShortCuts = new javax.swing.JPanel();

        lblPhase = new javax.swing.JLabel();

        txtPhase = new javax.swing.JLabel();

        lblStep = new javax.swing.JLabel();

        txtStep = new javax.swing.JLabel();

        lblTurn = new javax.swing.JLabel();

        txtTurn = new javax.swing.JLabel();

        txtActivePlayer = new javax.swing.JLabel();

        lblActivePlayer = new javax.swing.JLabel();

        txtPriority = new javax.swing.JLabel();

        lblPriority = new javax.swing.JLabel();

        feedbackPanel = new mage.client.game.FeedbackPanel();

        btnCancelSkip = new javax.swing.JButton(); // F3

        btnSkipToNextTurn = new javax.swing.JButton(); // F4

        btnSkipToEndTurn = new javax.swing.JButton(); // F5

        btnSkipToNextMain = new javax.swing.JButton(); // F7

        btnSkipToYourTurn = new javax.swing.JButton(); // F9

        btnConcede = new javax.swing.JButton();

        btnSwitchHands = new javax.swing.JButton();

        btnStopWatching = new javax.swing.JButton();

       

        bigCard = new mage.client.cards.BigCard();

        stack = new mage.client.cards.Cards();

        pnlReplay = new javax.swing.JPanel();

        btnStopReplay = new javax.swing.JButton();

        btnNextPlay = new javax.swing.JButton();

        btnPlay = new javax.swing.JButton();

        btnSkipForward = new javax.swing.JButton();

        btnPreviousPlay = new javax.swing.JButton();

        pnlBattlefield = new javax.swing.JPanel();

        gameChatPanel = new mage.client.chat.ChatPanel();

        gameChatPanel.useExtendedView(ChatPanel.VIEW_MODE.GAME);

        userChatPanel = new mage.client.chat.ChatPanel();

        userChatPanel.setParentChat(gameChatPanel);

        userChatPanel.useExtendedView(ChatPanel.VIEW_MODE.CHAT);

        userChatPanel.setChatType(ChatPanel.ChatType.GAME);

        gameChatPanel.setConnectedChat(userChatPanel);

        gameChatPanel.disableInput();

        gameChatPanel.setMinimumSize(new java.awt.Dimension(100, 48));

        jSplitPane2 = new javax.swing.JSplitPane();

        handContainer = new HandPanel();

        handCards = new HashMap<>();

        jSplitPane1.setBorder(null);

        jSplitPane1.setDividerSize(7);

        jSplitPane1.setResizeWeight(1.0);

        jSplitPane1.setOneTouchExpandable(true);

        jSplitPane1.setMinimumSize(new java.awt.Dimension(26, 48));

        jSplitPane0.setBorder(null);

        jSplitPane0.setDividerSize(7);

        jSplitPane0.setResizeWeight(1.0);

        jSplitPane0.setOneTouchExpandable(true);

        restoreDividerLocations();

        pnlShortCuts.setOpaque(false);

        pnlShortCuts.setPreferredSize(new Dimension(400, 72));

        lblPhase.setLabelFor(txtPhase);

        lblPhase.setText("Phase:");

        txtPhase.setText("Phase");

        txtPhase.setBorder(new javax.swing.border.LineBorder(new java.awt.Color(153, 153, 153), 1, true));