/*******************************************************************************
    * 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.beans.value.ObservableValue;
  import javafx.collections.FXCollections;
  import javafx.collections.ObservableList;
  import javafx.geometry.Pos;
  import javafx.scene.control.TableCell;
  import javafx.scene.control.TableColumn;
  import javafx.scene.control.TableColumn.CellDataFeatures;
  import javafx.util.Callback;
  import net.sourceforge.jhunters.pool.data.Competition;
  import net.sourceforge.jhunters.pool.data.CompetitionFixtures;
  import net.sourceforge.jhunters.pool.data.CompetitionFixtures.FixtureRecord;
  import net.sourceforge.jhunters.pool.data.CompetitionFixtures.PlayerFixtureField;
  import net.sourceforge.jhunters.pool.data.DataParser;
  import net.sourceforge.jhunters.pool.data.DataSet;
  import net.sourceforge.jhunters.pool.data.Player.PlayerField;
  import net.sourceforge.jhunters.pool.data.Result;
  import net.sourceforge.jhunters.pool.ui.ReportPanel.TableSource;
  import net.sourceforge.jhunters.pool.ui.TableUtils.FieldTableColumn;
  import net.sourceforge.jhunters.pool.ui.TableUtils.FieldTableView;
  
  /**
   * Matrix Table.
   */
  public class ResultsTable
          extends FieldTableView<CompetitionFixtures, PlayerFixtureField>
          implements TableSource {
      /**
       * Width for player.
       */
      protected static final int WIDTH_PLAYER = 100;
  
      /**
       * Width for value.
       */
      protected static final int WIDTH_VALUE = 32;
  
      /**
       * Width for fixture.
       */
      private static final int WIDTH_FIXTURE = 72;
  
      /**
       * Results format.
       */
      private static final String RESULTS_FORMAT = GuiResource.REPORT_RESULTS_TITLE.getValue();
  
      /**
       * Fixture cell factory.
       */
      private final Callback<TableColumn<CompetitionFixtures, FixtureRecord>, TableCell<CompetitionFixtures, FixtureRecord>> theFixtureCellFactory;
  
      /**
       * Current dataSet.
       */
      private DataSet theDataSet;
  
      /**
       * Current analysis list.
       */
      private ObservableList<CompetitionFixtures> theList;
  
      /**
       * Current # of fixture columns.
       */
      private int theNumColumns = 0;
  
      /**
       * Constructor.
       */
      protected ResultsTable() {
          /* Disallow editing */
          setEditable(false);
  
          /* Access column list */
          ObservableList<TableColumn<CompetitionFixtures, ?>> myColumns = getColumns();
  
          /* Create the player column */
         TableColumn<CompetitionFixtures, String> myPlayerCol = new FieldTableColumn<CompetitionFixtures, PlayerFixtureField, String>(PlayerFixtureField.NAME);
         myPlayerCol.setCellValueFactory(p -> p.getValue().getPlayer().nameProperty());
         myPlayerCol.setCellFactory(TableUtils.itemCellFactory(Pos.CENTER_RIGHT));
         myPlayerCol.setMinWidth(WIDTH_PLAYER);
         myColumns.add(myPlayerCol);
 
         /* Create the id column */
         TableColumn<CompetitionFixtures, String> myIdCol = new FieldTableColumn<CompetitionFixtures, PlayerFixtureField, String>(PlayerFixtureField.ID);
         myIdCol.setCellValueFactory(p -> p.getValue().idProperty());
         myIdCol.setCellFactory(TableUtils.itemCellFactory(Pos.CENTER));
         myIdCol.setMinWidth(WIDTH_VALUE);
         myColumns.add(myIdCol);
 
         /* Create the fixture cell factory */
         theFixtureCellFactory = TableUtils.itemCellFactory(Pos.CENTER);
     }
 
     /**
      * Adjust columns.
      */
     private void adjustColumns() {
         /* Determine required columns */
         int myNumColumns = theList.size();
         ObservableList<TableColumn<CompetitionFixtures, ?>> myColumns = getColumns();
 
         /* If we need to add columns */
         while (myNumColumns > theNumColumns) {
             /* Create the fixture column */
             TableColumn<CompetitionFixtures, FixtureRecord> myFixCol = new FieldTableColumn<CompetitionFixtures, PlayerFixtureField, FixtureRecord>(PlayerFixtureField.FIXTURE,
                     CompetitionFixtures.getIdForIndex(theNumColumns));
             myFixCol.setCellValueFactory(new FixtureCellValueFactory(theNumColumns));
             myFixCol.setCellFactory(theFixtureCellFactory);
             myFixCol.setMinWidth(WIDTH_FIXTURE);
             myColumns.add(myFixCol);
             theNumColumns++;
         }
 
         /* If we need to remove columns */
         while (myNumColumns < theNumColumns) {
             /* Remove last column */
             int iSize = myColumns.size();
             myColumns.remove(iSize - 1);
             theNumColumns--;
         }
     }
 
     /**
      * Set dataSet.
      * @param pData the dataSet
      */
     protected void setData(final DataSet pData) {
         /* Store the DataSet */
         theDataSet = pData;
     }
 
     /**
      * Set table data.
      * @param pCompetition the competition
      */
     protected void setCompetition(final Competition pCompetition) {
         /* Access the fixture list */
         theList = pCompetition != null
                                        ? pCompetition.getMatrix().getMatrix()
                                        : FXCollections.observableArrayList();
 
         /* Declare the list */
         setItems(theList);
 
         /* adjust the columns */
         if (pCompetition != null) {
             adjustColumns();
         }
     }
 
     @Override
     public void buildReport(final ReportBuilder pBuilder) {
         /* Build the main report */
         buildMainReport(pBuilder);
     }
 
     @Override
     public void createWeb(final ReportBuilder pBuilder) {
         /* Build the main report */
         buildRotatedReport(pBuilder);
     }
 
     /**
      * build the main report.
      * @param pBuilder the builder
      */
     private void buildMainReport(final ReportBuilder pBuilder) {
         /* Create a new table */
         pBuilder.newTinyTable();
 
         /* Set caption */
         pBuilder.setTableCaption(RESULTS_FORMAT, DataParser.formatDate(theDataSet.getLastChange()));
 
         /* Set the column headings */
         pBuilder.setColumnHeading(PlayerField.NAME.toString());
         pBuilder.setColumnHeading(PlayerFixtureField.ID.toString());
 
         /* Create the fixture columns */
         for (int i = 0; i < theNumColumns; i++) {
             /* Create the fixture column */
             pBuilder.setColumnHeading(CompetitionFixtures.getIdForIndex(i));
         }
 
         /* Loop through the players */
         boolean bFirst = true;
         Iterator<CompetitionFixtures> myIterator = theList.iterator();
         while (myIterator.hasNext()) {
             CompetitionFixtures myFixtures = 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(myFixtures.playerProperty().getValue());
             pBuilder.setCellId(myFixtures.idProperty().getValue());
 
             /* Create the fixture cells */
             for (int i = 0; i < theNumColumns; i++) {
                 /* Create the fixture column */
                 pBuilder.setCellObject(myFixtures.fixtureProperty(i).getValue());
             }
         }
     }
 
     /**
      * build the main report.
      * @param pBuilder the builder
      */
     private void buildRotatedReport(final ReportBuilder pBuilder) {
         /* Create a new table */
         pBuilder.newSmallTable();
 
         /* Set caption */
         pBuilder.setTableCaption(RESULTS_FORMAT, DataParser.formatDate(theDataSet.getLastChange()));
 
         /* Set the column headings */
         Element myHeader = pBuilder.setColumnHeading(PlayerField.NAME.toString());
         pBuilder.addClassAttribute(myHeader, "jhp-row-rotate-header");
 
         /* Create the fixture columns */
         Iterator<CompetitionFixtures> myIterator = theList.iterator();
         while (myIterator.hasNext()) {
             CompetitionFixtures myFixtures = myIterator.next();
 
             /* Create the fixture column */
             pBuilder.setRotatedColumnHeading(myFixtures.playerProperty().getValue().getName());
         }
 
         /* Loop through the players */
         boolean bFirst = true;
         myIterator = theList.iterator();
         while (myIterator.hasNext()) {
             CompetitionFixtures myFixtures = 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(myFixtures.playerProperty().getValue());
 
             /* Create the fixture cells */
             for (int i = 0; i < theNumColumns; i++) {
                 /* Create the fixture column */
                 FixtureRecord myFixture = myFixtures.fixtureProperty(i).getValue();
                 Result myResult = myFixture == null
                                                     ? null
                                                     : myFixture.getResult();
                 pBuilder.setCellNullResult(myResult);
             }
         }
     }
 
     /**
      * FixtureCellValue factory.
      */
     private static final class FixtureCellValueFactory
             implements Callback<CellDataFeatures<CompetitionFixtures, FixtureRecord>, ObservableValue<FixtureRecord>> {
         /**
          * Field value.
          */
         private final int theIndex;
 
         /**
          * Constructor.
          * @param pIndex the index
          */
         private FixtureCellValueFactory(final int pIndex) {
             theIndex = pIndex;
         }
 
         @Override
         public ObservableValue<FixtureRecord> call(final CellDataFeatures<CompetitionFixtures, FixtureRecord> p) {
             return p.getValue().fixtureProperty(theIndex);
         }
     }
 }