/**
    * 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, version 3.
    *
    * 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, see <http://www.gnu.org/licenses/>.
   */
  
  package net.curre.prefcount.gui;
  
  import java.awt.*;
  import java.awt.geom.Ellipse2D;
  import java.awt.geom.GeneralPath;
  import java.awt.geom.Line2D;
  import java.awt.geom.Point2D;
  import java.awt.geom.Rectangle2D;
  import java.util.List;
  import java.util.Map;
  
  import net.curre.prefcount.bean.GameResultBean;
  import net.curre.prefcount.bean.PlayerStatistics;
  import net.curre.prefcount.bean.Settings;
  import net.curre.prefcount.gui.theme.skin.PrefSkin;
  import net.curre.prefcount.gui.aa.AAJPanel;
  import net.curre.prefcount.service.LafThemeService;
  import net.curre.prefcount.service.SettingsService;
  import net.curre.prefcount.util.Utilities;
  
  /**
   * Object of this class represents the score board panel
   * where all players scores and totals are drawn.
   * <p/>
   * Created date: Apr 8, 2007
   *
   * @author Yevgeny Nyden
   */
  public class ScoreBoardPanel extends AAJPanel {
  
    /** Package protected game scores bean. */
    GameResultBean results;
  
    /**
     * Reference to the map that stores/computes
     * locations for all items on the board.
     */
    ScoreBoardLocationsMap locationsMap;
  
    /**
     * Constructor with a GameResultBean argument.
     *
     * @param results Game results bean.
     */
    public ScoreBoardPanel(GameResultBean results) {
      Settings settings = SettingsService.getSettings();
      super.setSize(settings.getDialogFrameWidth(), settings.getDialogFrameHeight());
      this.results = results;
      locationsMap = new ScoreBoardLocationsMap(this);
    }
  
    /**
     * {@inheritDoc}
     *
     * @throws UnsupportedOperationException If number of player is not supported.
     */
    public void paintComponent(Graphics g) {
  
      Graphics2D g2 = (Graphics2D) g;
  //    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
      final PrefSkin skin = LafThemeService.getInstance().getCurrentSkin();
  
      final float width = (float) super.getSize().getWidth();
      final float height = (float) super.getSize().getHeight();
      locationsMap.computeLocations();
  
      final float centerX = width / 2f;
      final float centerY = height / 2f;
      final float incrX = centerX / 3f;
      final float incrY = centerY / 3f - 7f;
  
      final float oneThirdX = width / 3f;
      final float twoThirdX = oneThirdX * 2f;
      final float oneThirdY = height / 3f;
      final float twoThirdY = oneThirdY * 2f;
  
      // setting main backgound (outer area)
      g2.setColor(skin.getMainBackgroundColor());
      g2.fillRect(0, 0, (int) Math.ceil(width), (int) Math.ceil(height));
  
      // drawing nice borders
      Color bordColor = Utilities.createDarkerColor(skin.getMainBackgroundColor(), 20);
      g2.setColor(bordColor);
      g2.draw(new Rectangle2D.Double(4d, 4d, width - 8d, height - 8d));
      bordColor = Utilities.createDarkerColor(bordColor, 20);
     g2.setColor(bordColor);
     g2.draw(new Rectangle2D.Double(5d, 5d, width - 10d, height - 10d));
 
     // painting score board backgound
     g2.setPaint(skin.getBoardBackgroundPaint());
     g2.fillRect(6, 6, (int) width - 11, (int) height - 11);
 
     // player sections lines
     prepareBoardLinePen(g2, skin);
     Ellipse2D e = new Ellipse2D.Double();
     e.setFrameFromCenter(centerX + 1d, centerY, centerX + 32d, centerY + 30d);
     g2.draw(e);
     g2.draw(new Rectangle2D.Double(incrX, 7d + incrY, twoThirdX, twoThirdY));
     g2.draw(new Rectangle2D.Double(oneThirdX - 7d, oneThirdY - 7d,
                                    oneThirdX + 14d, oneThirdY + 14d));
 
     prepareBoardLinePen(g2, skin);
 
     // section borders and players information
     List<PlayerStatistics> statistics = results.getPlayerStats();
     if (statistics.size() == 3) {
       // drawing section borders (assuming the pen didn't change)
       g2.drawLine(7, (int) height - 7, (int) centerX, (int) centerY);
       g2.drawLine((int) width - 7, (int) height - 7, (int) centerX, (int) centerY);
       g2.drawLine((int) centerX, (int) centerY, (int) centerX, 7);
       g2.drawLine((int) centerX, (int) (height - incrY - 7), (int) centerX, (int) height - 7);
       g2.drawLine(7, 7, (int) incrX, (int) incrY + 7);
       g2.drawLine((int) width - 7, 7, (int) (width - incrX), (int) incrY + 7);
 
       // displaying player 0 information
       drawPlayerScores(0, g2, skin, statistics.get(0), 1, 2);
 
       // displaying player 1 information
       drawPlayerScores(1, g2, skin, statistics.get(1), 0, 2);
 
       // displaying player 2 information
       drawPlayerScores(2, g2, skin, statistics.get(2), 0, 1);
 
     } else if (statistics.size() == 4) {
       // drawing section borders (assuming the pen didn't change)
       g2.drawLine(7, 7, (int) width - 7, (int) height - 7);
       g2.drawLine((int) width - 7, 7, 7, (int) height - 7);
 
       g2.drawLine(7, (int) oneThirdY, (int) incrX, (int) oneThirdY);
       g2.drawLine(7, (int) twoThirdY, (int) incrX, (int) twoThirdY);
       g2.drawLine((int) (width - incrX), (int) oneThirdY, (int) width - 7, (int) oneThirdY);
       g2.drawLine((int) (width - incrX), (int) twoThirdY, (int) width - 7, (int) twoThirdY);
 
       g2.drawLine((int) oneThirdX, 7, (int) oneThirdX, (int) incrY + 7);
       g2.drawLine((int) twoThirdX, 7, (int) twoThirdX, (int) incrY + 7);
       g2.drawLine((int) oneThirdX, (int) (height - incrY - 7), (int) oneThirdX, (int) height - 7);
       g2.drawLine((int) twoThirdX, (int) (height - incrY - 7), (int) twoThirdX, (int) height - 7);
 
       // displaying player 0 information
       drawPlayerScores(0, g2, skin, statistics.get(0), 1, 2, 3);
 
       // displaying player 1 information
       drawPlayerScores(1, g2, skin, statistics.get(1), 0, 2, 3);
 
       // displaying player 2 information
       drawPlayerScores(2, g2, skin, statistics.get(2), 0, 1, 3);
 
       // displaying player 3 information
       drawPlayerScores(3, g2, skin, statistics.get(3), 0, 1, 2);
 
     } else {
       throw new UnsupportedOperationException(statistics.size() + " number of players is NOT supported!");
     }
   }
 
   /***************** PRIVATE STATIC METHODS *******************/
 
   /**
    * Method to draw all player scores. Note that the pen
    * (Color, Fond, Stroke) will not be saved after this
    * method returns.
    *
    * @param currPlayerInd Current player index.
    * @param g2            Graphics object to use.
    * @param skin          Current skin.
    * @param stats         Player statistics bean.
    * @param otherPlayers  Indexes of other players.
    */
   private void drawPlayerScores(int currPlayerInd,
                                 Graphics2D g2,
                                 PrefSkin skin,
                                 PlayerStatistics stats,
                                 int... otherPlayers) {
     Map<String, Point2D.Float> locations = locationsMap.getLocationsMap(currPlayerInd);
     preparePlayerNamePen(g2, skin);
     Point.Float point = locations.get(ScoreBoardLocationsMap.PLAYER_NAME);
     g2.drawString(stats.getPlayerNameLetter(), (float) point.getX(), (float) point.getY());
     preparePlayerScorePen(g2, skin);
     point = locations.get(ScoreBoardLocationsMap.PLAYER_MOUNT);
     g2.drawString(getStringFromInt(stats.getMountain()), (float) point.getX(), (float) point.getY());
     point = locations.get(ScoreBoardLocationsMap.PLAYER_BULLET);
     g2.drawString(getStringFromInt(stats.getBullet()), (float) point.getX(), (float) point.getY());
     for (int other : otherPlayers) {
       point = locations.get(ScoreBoardLocationsMap.VISTS_FOR + other);
       g2.drawString(stats.getVistsStringForPlayer(other), (float) point.getX(), (float) point.getY());
     }
     if (results.isFinalScoresReady()) {
       for (int other : otherPlayers) {
         drawVistSaldo(g2, stats.getVistSaldoMap().get(other),
                       locations.get(ScoreBoardLocationsMap.VIST_SALDO_FOR + other), false);
       }
       drawVistSaldo(g2, stats.getVistSaldoMap().get(currPlayerInd),
                     locations.get(ScoreBoardLocationsMap.VIST_SALDO), true);
       boolean isVertical = (otherPlayers.length == 3);
       if (currPlayerInd == 0 || currPlayerInd == 2) {
         isVertical = !isVertical;
       }
       drawNewMountain(g2, stats, locations.get(ScoreBoardLocationsMap.PLAYER_MOUNT), isVertical);
       drawNewBullet(g2, stats, locations.get(ScoreBoardLocationsMap.PLAYER_BULLET), isVertical);
       preparePlayerTotalsPen(g2, skin);
       drawFinalMountain(g2, stats, locations.get(ScoreBoardLocationsMap.FINAL_MOUNT));
       drawFinalScore(g2, stats, locations.get(ScoreBoardLocationsMap.FINAL_SCORE));
     }
   }
 
   /**
    * Draws a number with an oval or a rectangle around it at the
    * given position (x, y) - used for displaying players vist saldo.
    *
    * @param g2         Graphics2D to use.
    * @param saldo      Number to draw.
    * @param point      Coordinates.
    * @param totalSaldo True indicates that this is a total saldo,
    *                   therefore, a rectangle is drawn around the number;
    *                   false draws an oval instead.
    */
   private static void drawVistSaldo(Graphics2D g2, final Integer saldo,
                                     final Point2D.Float point, boolean totalSaldo) {
     final String str = saldo.toString();
     final int width = 16 + str.length() * 14;
     final int adjustX = 10 + (saldo < 0 ? 4 : 0);
     final float x = point.x;
     final float y = point.y;
     g2.drawString(str, x, y);
     if (totalSaldo) {
       g2.drawRect((int) x - adjustX, (int) y - 16, width, 20);
     } else {
       g2.drawOval((int) x - adjustX, (int) y - 16, width, 20);
     }
   }
 
   /**
    * Draws new bullet value (target bullet).
    *
    * @param g2       Graphics2D to use.
    * @param stats    Player statistics object.
    * @param point    Coordinates of the original bullet string.
    * @param vertical If true, indicates vertical positioning
    *                 of the string; false - horizontal positioning.
    */
   private void drawNewBullet(Graphics2D g2, PlayerStatistics stats,
                              final Point2D.Float point, final boolean vertical) {
     final String str = getStringFromInt(results.getTargetBullet());
     final float width = (float) Utilities.determineSizeOfString(g2, stats.getBullet().toString()).getWidth();
     final float x = point.x;
     final float y = point.y;
     Stroke tempStroke = g2.getStroke();
     g2.setStroke(new BasicStroke(2));
     g2.draw(new Line2D.Float(x, y - 2f, x + width + 2f, y - 8f));
     g2.setStroke(tempStroke);
     if (vertical) {
       g2.drawString(str, x + 6f, y + 20f);
     } else {
       g2.drawString(str, x + 7f + width, y);
     }
   }
 
   /**
    * Draws new mountain value.
    *
    * @param g2       Graphics2D to use.
    * @param stats    Player statistics object.
    * @param point    Coordinates of the original mountain string.
    * @param vertical If true, indicates vertical positioning
    *                 of the string; false - horizontal positioning.
    */
   private static void drawNewMountain(Graphics2D g2, PlayerStatistics stats,
                                       final Point2D.Float point, final boolean vertical) {
     final String str = getStringFromInt(stats.getNewMountain());
     final float width = (float) Utilities.determineSizeOfString(g2, stats.getMountain().toString()).getWidth();
     final float x = point.x;
     final float y = point.y;
     Stroke tempStroke = g2.getStroke();
     g2.setStroke(new BasicStroke(2));
     g2.draw(new Line2D.Float(x, y - 2f, x + width + 2f, y - 8f));
     g2.setStroke(tempStroke);
     if (vertical) {
       g2.drawString(str, x + 6f, y + 20f);
     } else {
       g2.drawString(str, x + 7f + width, y);
     }
   }
 
   /**
    * Draws new mountain value.
    *
    * @param g2    Graphics2D to use.
    * @param stats Player statistics object.
    * @param point Point's coordinates.
    */
   private static void drawFinalMountain(Graphics2D g2, PlayerStatistics stats,
                                         final Point2D.Float point) {
     int mount = stats.getFinalMountainInVists();
     final String str = String.valueOf(mount);
     final int width = 16 + str.length() * 14;
     final int adjustX = 10 + (mount < 0 ? 4 : 0);
     final float x = point.x;
     final float y = point.y;
     g2.drawString(str, x, y);
     g2.drawRect((int) x - adjustX, (int) y - 16, width, 20);
   }
 
   /**
    * Draws final score and a thombus around it
    * at the given location.
    *
    * @param g2    Graphics2D to use.
    * @param stats Player statistics object.
    * @param point Point's coordinates.
    */
   private static void drawFinalScore(Graphics2D g2, PlayerStatistics stats,
                                      final Point2D.Float point) {
     final float x = point.x;
     final float y = point.y;
     final String score = stats.getFinalScoreInVists().toString();
     g2.drawString(score, x, y);
 
     final Dimension corrSize = Utilities.determineSizeOfString(g2, score);
     final float halfWidth = (float) corrSize.getWidth() / 2;
     final float halfHeight = (float) corrSize.getHeight() / 2;
     final float realCenterX = x + halfWidth;
     final float realCenterY = y - halfHeight + 5f;
     final float leftX = realCenterX - halfWidth - 15f;
     final float rightX = realCenterX + halfWidth + 15f;
     final float upY = realCenterY - halfHeight - 15f;
     final float downY = realCenterY + halfHeight + 15f;
 
     GeneralPath polygon = new GeneralPath(GeneralPath.WIND_EVEN_ODD, 4);
     polygon.moveTo(realCenterX, upY);
     polygon.lineTo(rightX, realCenterY);
     polygon.lineTo(realCenterX, downY);
     polygon.lineTo(leftX, realCenterY);
     polygon.closePath();
     g2.draw(polygon);
   }
 
   /**
    * Converts passed Integer to a String appending a '.'
    * ant the end; if the passed value is null an empty string
    * is returned.
    *
    * @param value Inetger value to convert.
    * @return String representation of the passed integer
    *         with a period at the end or an empty string
    *         if the passed integer is null.
    */
   private static String getStringFromInt(final Integer value) {
     return value == null ? "" : value.toString() + ".";
   }
 
   /**
    * Sets the color and stroke on the graphics object
    * for the score board lines painting.
    *
    * @param g2   Graphics object.
    * @param skin Current prefcount skin.
    */
   private static void prepareBoardLinePen(Graphics2D g2, PrefSkin skin) {
     g2.setStroke(skin.getBoardLineStroke());
     g2.setColor(skin.getBoardLineColor());
   }
 
   /**
    * Sets the color, stroke and font on the graphics
    * object for the player name painting.
    *
    * @param g2   Graphics object.
    * @param skin Current prefcount skin.
    */
   private static void preparePlayerNamePen(Graphics2D g2, PrefSkin skin) {
     g2.setColor(skin.getPlayerNameColor());
     g2.setFont(skin.getPlayerNameFont());
     g2.setStroke(skin.getPlayerNameStroke());
   }
 
   /**
    * Sets the color, stroke and font on the graphics
    * object for the player score painting.
    *
    * @param g2   Graphics object.
    * @param skin Current prefcount skin.
    */
   private static void preparePlayerScorePen(Graphics2D g2, PrefSkin skin) {
     g2.setColor(skin.getPlayerScoreColor());
     g2.setFont(skin.getPlayerScoreFont());
     g2.setStroke(skin.getPlayerScoreStroke());
   }
 
   /**
    * Sets the color, stroke and font on the graphics
    * object for the player (score) totals painting.
    *
    * @param g2   Graphics object.
    * @param skin Current prefcount skin.
    */
   private static void preparePlayerTotalsPen(Graphics2D g2, PrefSkin skin) {
     g2.setColor(skin.getPlayerTotalsColor());
     g2.setFont(skin.getPlayerTotalsFont());
     g2.setStroke(skin.getPlayerTotalsStroke());
   }
 
 }