/*******************************************************************************
    * 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.time.LocalDate;
  import java.util.Iterator;
  
  import org.w3c.dom.Element;
  
  import javafx.beans.property.SimpleStringProperty;
  import javafx.beans.property.StringProperty;
  import javafx.beans.value.ObservableValue;
  import javafx.collections.FXCollections;
  import javafx.collections.ObservableList;
  import javafx.geometry.Pos;
  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.DataSet;
  import net.sourceforge.jhunters.pool.data.Fixture;
  import net.sourceforge.jhunters.pool.data.Fixture.FixtureField;
  import net.sourceforge.jhunters.pool.data.FixtureSet;
  import net.sourceforge.jhunters.pool.data.Player;
  import net.sourceforge.jhunters.pool.data.Result;
  import net.sourceforge.jhunters.pool.ui.ReportPanel.TableSource;
  import net.sourceforge.jhunters.pool.ui.TableUtils.FieldCell;
  import net.sourceforge.jhunters.pool.ui.TableUtils.FieldTableColumn;
  import net.sourceforge.jhunters.pool.ui.TableUtils.FieldTableView;
  
  /**
   * FixtureSet Table.
   */
  public class FixtureSetTable
          extends FieldTableView<Fixture, FixtureField>
          implements TableSource {
      /**
       * Width for player.
       */
      private static final int WIDTH_PLAYER = 150;
  
      /**
       * Width for result.
       */
      private static final int WIDTH_RESULT = 60;
  
      /**
       * Width for date.
       */
      protected static final int WIDTH_DATE = 100;
  
      /**
       * WeekBye value.
       */
      private static final StringProperty BYE_PROPERTY = new SimpleStringProperty(Player.PLAYER_BYE);
  
      /**
       * Week fixture format.
       */
      private static final String WEEK_FORMAT = GuiResource.REPORT_FIXTURES_TITLE.getValue();
  
      /**
       * Current dataSet.
       */
      private DataSet theDataSet;
  
      /**
       * Current competition.
       */
      private Competition theCompetition;
  
      /**
       * Current fixture list.
       */
      private ObservableList<Fixture> theList;
  
      /**
       * Constructor.
       */
      protected FixtureSetTable() {
          /* Allow editing */
          setEditable(true);
  
          /* Access column list */
          ObservableList<TableColumn<Fixture, ?>> myColumns = getColumns();
 
         /* Create the date column */
         TableColumn<Fixture, LocalDate> myDateCol = new FieldTableColumn<Fixture, FixtureField, LocalDate>(FixtureField.DATE);
         myDateCol.setCellValueFactory(p -> p.getValue().dateProperty());
         myDateCol.setCellFactory(TableUtils.dateCellFactory());
         myDateCol.setSortable(false);
         myDateCol.setEditable(false);
         myDateCol.setMinWidth(WIDTH_DATE);
         myColumns.add(myDateCol);
 
         /* Create the home column */
         TableColumn<Fixture, String> myHomeCol = new FieldTableColumn<Fixture, FixtureField, String>(FixtureField.HOME);
         myHomeCol.setCellValueFactory(new PlayerCellValueFactory(true));
         myHomeCol.setCellFactory(TableUtils.itemCellFactory(Pos.CENTER_RIGHT));
         myHomeCol.setMinWidth(WIDTH_PLAYER);
         myHomeCol.setSortable(false);
         myHomeCol.setEditable(false);
         myColumns.add(myHomeCol);
 
         /* Create the result column */
         TableColumn<Fixture, Result> myResultCol = new FieldTableColumn<Fixture, FixtureField, Result>(FixtureField.RESULT);
         myResultCol.setCellValueFactory(p -> p.getValue().resultProperty());
         myResultCol.setCellFactory(TableUtils.enumCellFactory(Result.class));
         myResultCol.setSortable(false);
         myResultCol.setMinWidth(WIDTH_RESULT);
         myColumns.add(myResultCol);
 
         /* Create the away column */
         TableColumn<Fixture, String> myAwayCol = new FieldTableColumn<Fixture, FixtureField, String>(FixtureField.AWAY);
         myAwayCol.setCellValueFactory(new PlayerCellValueFactory(false));
         myAwayCol.setCellFactory(TableUtils.itemCellFactory(Pos.CENTER_LEFT));
         myAwayCol.setMinWidth(WIDTH_PLAYER);
         myAwayCol.setSortable(false);
         myAwayCol.setEditable(false);
         myColumns.add(myAwayCol);
     }
 
     /**
      * 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) {
         /* Store the Competition */
         theCompetition = pCompetition;
     }
 
     /**
      * Set table data.
      * @param pFixtureSet the fixtureSet
      */
     protected void setFixtureSet(final FixtureSet pFixtureSet) {
         /* Access the fixture list */
         theList = pFixtureSet != null
                                       ? FXCollections.observableList(pFixtureSet.getFixtures())
                                       : FXCollections.observableArrayList();
 
         /* Declare the list */
         setItems(theList);
     }
 
     @Override
     public void buildReport(final ReportBuilder pBuilder) {
         /* Build the main report */
         buildMainReport(pBuilder);
     }
 
     @Override
     public void createWeb(final ReportBuilder pBuilder) {
         /* Build the main report */
         buildMainReport(pBuilder);
     }
 
     /**
      * build the main report.
      * @param pBuilder the builder
      */
     private void buildMainReport(final ReportBuilder pBuilder) {
         /* Loop through the fixtures */
         Iterator<FixtureSet> myIterator = theCompetition.getFixtureList().fixtureIterator();
         while (myIterator.hasNext()) {
             FixtureSet myFixtureSet = myIterator.next();
 
             /* Build the fixture report */
             buildSubReport(pBuilder, myFixtureSet);
         }
     }
 
     /**
      * Build fixture list.
      * @param pBuilder the builder
      * @param pFixtureSet the fixture Set
      */
     private void buildSubReport(final ReportBuilder pBuilder,
                                 final FixtureSet pFixtureSet) {
         /* Set the heading */
         int myWeek = pFixtureSet.getWeekNo();
         pBuilder.setHeading(WEEK_FORMAT, myWeek);
 
         /* Determine break point */
         int myBreak = theCompetition.getPlayerCount() >> 2;
 
         /* Create a new table */
         pBuilder.newTable();
 
         /* Set the column headings */
         pBuilder.setColumnHeading(FixtureField.DATE.toString());
         pBuilder.setColumnHeading(FixtureField.HOME.toString());
         pBuilder.setColumnHeading(FixtureField.RESULT.toString());
         pBuilder.setColumnHeading(FixtureField.AWAY.toString());
 
         /* Loop through the fixtures */
         int i = 0;
         Iterator<Fixture> myIterator = pFixtureSet.fixtureIterator();
         while (myIterator.hasNext()) {
             Fixture myFixture = myIterator.next();
 
             /* Determine whether we need a separator */
             boolean bSeparator = (i++ % myBreak) == 0;
             if (bSeparator) {
                 /* Create a new row */
                 Element myRow = pBuilder.newRow();
                 pBuilder.addClassAttribute(myRow, ReportBuilder.CLASS_SEPARATOR);
 
                 /* Add date to cell and set span */
                 Element myCell = pBuilder.setCellDate(myFixture.dateProperty().getValue());
                 myCell.setAttribute(ReportBuilder.ATTR_ROWSPAN, Integer.toString(myBreak));
             } else {
                 /* Create a new row */
                 pBuilder.newRow();
             }
 
             /* Set the cells */
             pBuilder.setCellPlayerRight(myFixture.homePlayerProperty().getValue());
             pBuilder.setCellResult(myFixture.resultProperty().getValue());
             pBuilder.setCellPlayerLeft(myFixture.awayPlayerProperty().getValue());
         }
 
         /* If the week is even */
         if ((myWeek & 1) == 0) {
             /* Create a page break */
             pBuilder.setPageBreak();
 
             /* else add some spaces */
         } else {
             pBuilder.setLineSpace();
         }
     }
 
     @Override
     public boolean preEditHook(final FieldCell<Fixture, FixtureField> pCell) {
         /* Access the details */
         Fixture myFixture = pCell.getTheRow();
         FixtureField myField = pCell.getTheField();
 
         /* Switch on field */
         switch (myField) {
             case NEWDATE:
                 return myFixture.getResult() == null;
             case RESULT:
                 return true;
             default:
                 return false;
         }
     }
 
     @Override
     public void postCommitHook(final FieldCell<Fixture, FixtureField> pCell) {
         /* Note that the data is updated */
         theDataSet.setUpdated(Boolean.TRUE);
 
         /* process fixtures */
         theCompetition.processFixtures();
     }
 
     /**
      * PlayerCellValue factory.
      */
     protected static final class PlayerCellValueFactory
             implements Callback<CellDataFeatures<Fixture, String>, ObservableValue<String>> {
         /**
          * Home/Away.
          */
         private final boolean isHome;
 
         /**
          * Constructor.
          * @param pHome is this for home (or away)
          */
         protected PlayerCellValueFactory(final boolean pHome) {
             isHome = pHome;
         }
 
         @Override
         public ObservableValue<String> call(final CellDataFeatures<Fixture, String> p) {
             Player myPlayer = isHome
                                      ? p.getValue().getHomePlayer()
                                      : p.getValue().getAwayPlayer();
             return myPlayer == null
                                     ? BYE_PROPERTY
                                     : myPlayer.nameProperty();
         }
     }
 }