/*******************************************************************************
    * jhunters: Pool League
    * Copyright 2015 Tony Washer
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   ********************************************************************************/
  package net.sourceforge.jhunters.pool.ui;
  
  import java.util.Iterator;
  
  import org.w3c.dom.Element;
  
  import javafx.collections.FXCollections;
  import javafx.collections.ObservableList;
  import javafx.geometry.Pos;
  import javafx.scene.control.TableCell;
  import javafx.scene.control.TableColumn;
  import javafx.util.Callback;
  import net.sourceforge.jhunters.pool.data.Competition;
  import net.sourceforge.jhunters.pool.data.CompetitionStandings;
  import net.sourceforge.jhunters.pool.data.DataParser;
  import net.sourceforge.jhunters.pool.data.DataSet;
  import net.sourceforge.jhunters.pool.data.PlayerAnalysis;
  import net.sourceforge.jhunters.pool.data.PlayerAnalysis.AnalysisField;
  import net.sourceforge.jhunters.pool.ui.ReportPanel.TableSource;
  import net.sourceforge.jhunters.pool.ui.TableUtils.FieldTableColumn;
  import net.sourceforge.jhunters.pool.ui.TableUtils.FieldTableView;
  
  /**
   * League Table.
   */
  public class LeagueTable
          extends FieldTableView<PlayerAnalysis, AnalysisField>
          implements TableSource {
      /**
       * Width for player.
       */
      private static final int WIDTH_PLAYER = 120;
  
      /**
       * Width for value.
       */
      private static final int WIDTH_VALUE = 65;
  
      /**
       * League table format.
       */
      private static final String LEAGUE_FORMAT = GuiResource.REPORT_LEAGUE_TITLE.getValue();
  
      /**
       * TieBreak format.
       */
      private static final String TIEBREAK_FORMAT = GuiResource.REPORT_LEAGUE_TIEBREAKS.getValue();
  
      /**
       * TieBreak Table format.
       */
      private static final String TIEBREAK_TABLE_FORMAT = GuiResource.REPORT_LEAGUE_TIEBREAK_TABLE.getValue();
  
      /**
       * The Outstanding Table.
       */
      private final OutstandingTable theOutstanding;
  
      /**
       * Current dataSet.
       */
      private DataSet theDataSet;
  
      /**
       * Current competition.
       */
      private Competition theCompetition;
  
      /**
       * Current analysis list.
       */
      private ObservableList<PlayerAnalysis> theList;
  
      /**
       * Integer cell factory.
       */
      private final Callback<TableColumn<PlayerAnalysis, Integer>, TableCell<PlayerAnalysis, Integer>> theIntegerCellFactory;
  
      /**
       * Constructor.
       * @param pOutstanding the outstanding table
       */
      protected LeagueTable(final OutstandingTable pOutstanding) {
         /* Store parameters */
         theOutstanding = pOutstanding;
 
         /* Disallow editing */
         setEditable(false);
 
         /* Create the integer cell factory */
         theIntegerCellFactory = TableUtils.integerCellFactory();
 
         /* Access column list */
         ObservableList<TableColumn<PlayerAnalysis, ?>> myColumns = getColumns();
 
         /* Create the player column */
         TableColumn<PlayerAnalysis, String> myPlayerCol = new FieldTableColumn<PlayerAnalysis, AnalysisField, String>(AnalysisField.NAME);
         myPlayerCol.setCellValueFactory(p -> p.getValue().getPlayer().nameProperty());
         myPlayerCol.setCellFactory(TableUtils.itemCellFactory(Pos.CENTER_RIGHT));
         myPlayerCol.setMinWidth(WIDTH_PLAYER);
         myColumns.add(myPlayerCol);
 
         /* Create the played column */
         TableColumn<PlayerAnalysis, Integer> myPlayedCol = new FieldTableColumn<PlayerAnalysis, AnalysisField, Integer>(AnalysisField.PLAYED);
         myPlayedCol.setCellValueFactory(p -> p.getValue().playedProperty());
         myPlayedCol.setCellFactory(theIntegerCellFactory);
         myPlayedCol.setMinWidth(WIDTH_VALUE);
         myColumns.add(myPlayedCol);
 
         /* Create the won column */
         TableColumn<PlayerAnalysis, Integer> myWonCol = new FieldTableColumn<PlayerAnalysis, AnalysisField, Integer>(AnalysisField.WON);
         myWonCol.setCellValueFactory(p -> p.getValue().wonProperty());
         myWonCol.setCellFactory(theIntegerCellFactory);
         myWonCol.setMinWidth(WIDTH_VALUE);
         myColumns.add(myWonCol);
 
         /* Create the lost column */
         TableColumn<PlayerAnalysis, Integer> myLostCol = new FieldTableColumn<PlayerAnalysis, AnalysisField, Integer>(AnalysisField.LOST);
         myLostCol.setCellValueFactory(p -> p.getValue().lostProperty());
         myLostCol.setCellFactory(theIntegerCellFactory);
         myLostCol.setMinWidth(WIDTH_VALUE);
         myColumns.add(myLostCol);
 
         /* Create the for column */
         TableColumn<PlayerAnalysis, Integer> myForCol = new FieldTableColumn<PlayerAnalysis, AnalysisField, Integer>(AnalysisField.FOR);
         myForCol.setCellValueFactory(p -> p.getValue().forProperty());
         myForCol.setCellFactory(theIntegerCellFactory);
         myForCol.setMinWidth(WIDTH_VALUE);
         myColumns.add(myForCol);
 
         /* Create the played column */
         TableColumn<PlayerAnalysis, Integer> myAgainstCol = new FieldTableColumn<PlayerAnalysis, AnalysisField, Integer>(AnalysisField.AGAINST);
         myAgainstCol.setCellValueFactory(p -> p.getValue().againstProperty());
         myAgainstCol.setCellFactory(theIntegerCellFactory);
         myAgainstCol.setMinWidth(WIDTH_VALUE);
         myColumns.add(myAgainstCol);
 
         /* Create the difference column */
         TableColumn<PlayerAnalysis, Integer> myDiffCol = new FieldTableColumn<PlayerAnalysis, AnalysisField, Integer>(AnalysisField.DIFFERENCE);
         myDiffCol.setCellValueFactory(p -> p.getValue().differenceProperty());
         myDiffCol.setCellFactory(theIntegerCellFactory);
         myDiffCol.setMinWidth(WIDTH_VALUE);
         myColumns.add(myDiffCol);
 
         /* Create the points column */
         TableColumn<PlayerAnalysis, Integer> myPointsCol = new FieldTableColumn<PlayerAnalysis, AnalysisField, Integer>(AnalysisField.POINTS);
         myPointsCol.setCellValueFactory(p -> p.getValue().pointsProperty());
         myPointsCol.setCellFactory(theIntegerCellFactory);
         myPointsCol.setMinWidth(WIDTH_VALUE);
         myColumns.add(myPointsCol);
 
         /* Create the tieBreak column */
         TableColumn<PlayerAnalysis, Integer> myBreakCol = new FieldTableColumn<PlayerAnalysis, AnalysisField, Integer>(AnalysisField.TIEBREAK);
         myBreakCol.setCellValueFactory(p -> p.getValue().tieBreakerProperty());
         myBreakCol.setCellFactory(theIntegerCellFactory);
         myBreakCol.setMinWidth(WIDTH_VALUE);
         myColumns.add(myBreakCol);
     }
 
     /**
      * Set dataSet.
      * @param pData the dataSet
      */
     protected void setData(final DataSet pData) {
         /* Store the DataSet */
         theDataSet = pData;
     }
 
     /**
      * Set competition.
      * @param pCompetition the competition
      */
     protected void setCompetition(final Competition pCompetition) {
         /* Access the league table */
         theList = pCompetition != null
                                        ? pCompetition.getTable().getTable()
                                        : FXCollections.observableArrayList();
 
         /* Declare the list */
         theCompetition = pCompetition;
         setItems(theList);
     }
 
     @Override
     public void buildReport(final ReportBuilder pBuilder) {
         /* Build the main report */
         buildMainReport(pBuilder);
 
         /* Add the Outstanding Report */
         theOutstanding.buildReport(pBuilder);
     }
 
     @Override
     public void createWeb(final ReportBuilder pBuilder) {
         /* Build the main report */
         buildMainReport(pBuilder);
 
         /* Build TieBreaks */
         buildTieBreaks(pBuilder);
     }
 
     /**
      * build the main report.
      * @param pBuilder the builder
      */
     private void buildMainReport(final ReportBuilder pBuilder) {
         /* Set the heading */
         pBuilder.setHeading(LEAGUE_FORMAT, DataParser.formatDate(theDataSet.getLastChange()));
 
         /* Create a new table */
         buildTable(pBuilder, theList);
     }
 
     /**
      * build the TieBreaks.
      * @param pBuilder the builder
      */
     private void buildTieBreaks(final ReportBuilder pBuilder) {
         /* Set the heading */
         pBuilder.setHeading(TIEBREAK_FORMAT);
 
         /* Access leading player */
         PlayerAnalysis myLead = theList.get(0);
         CompetitionStandings myStandings = theCompetition.getTable();
 
         /* Loop through the tieBreaks */
         for (Integer myPoints = myLead.getPoints(); myPoints > 0; myPoints -= 2) {
             /* Access the table */
             ObservableList<PlayerAnalysis> myTable = myStandings.getTieBreakTable(myPoints);
             if (myTable != null) {
                 /* Set the heading */
                 pBuilder.setHeading(TIEBREAK_TABLE_FORMAT, myPoints);
                 buildTable(pBuilder, myTable);
             }
         }
     }
 
     /**
      * build the table.
      * @param pBuilder the builder
      * @param pTable the table
      */
     private void buildTable(final ReportBuilder pBuilder,
                             final ObservableList<PlayerAnalysis> pTable) {
         /* Create a new table */
         pBuilder.newTable();
 
         /* Set the column headings */
         pBuilder.setColumnHeading(AnalysisField.NAME.getShortName());
         pBuilder.setColumnHeading(AnalysisField.PLAYED.getShortName());
         pBuilder.setColumnHeading(AnalysisField.WON.getShortName());
         pBuilder.setColumnHeading(AnalysisField.LOST.getShortName());
         pBuilder.setColumnHeading(AnalysisField.FOR.getShortName());
         pBuilder.setColumnHeading(AnalysisField.AGAINST.getShortName());
         pBuilder.setColumnHeading(AnalysisField.DIFFERENCE.getShortName());
         pBuilder.setColumnHeading(AnalysisField.POINTS.getShortName());
         pBuilder.setColumnHeading(AnalysisField.TIEBREAK.getShortName());
 
         /* Loop through the players */
         boolean bFirst = true;
         Iterator<PlayerAnalysis> myIterator = pTable.iterator();
         while (myIterator.hasNext()) {
             PlayerAnalysis myAnalysis = myIterator.next();
 
             /* Create a new row */
             Element myRow = pBuilder.newRow();
 
             /* Add separator for first row */
             if (bFirst) {
                 pBuilder.addClassAttribute(myRow, ReportBuilder.CLASS_SEPARATOR);
                 bFirst = false;
             }
 
             /* Set the column headings */
             pBuilder.setCellPlayerRight(myAnalysis.playerProperty().getValue());
             pBuilder.setCellInteger(myAnalysis.playedProperty().getValue());
             pBuilder.setCellInteger(myAnalysis.wonProperty().getValue());
             pBuilder.setCellInteger(myAnalysis.lostProperty().getValue());
             pBuilder.setCellInteger(myAnalysis.forProperty().getValue());
             pBuilder.setCellInteger(myAnalysis.againstProperty().getValue());
             pBuilder.setCellInteger(myAnalysis.differenceProperty().getValue());
             pBuilder.setCellInteger(myAnalysis.pointsProperty().getValue());
             pBuilder.setCellInteger(myAnalysis.tieBreakerProperty().getValue());
         }
     }
 }