/*******************************************************************************
    * 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 java.util.List;
  
  import javafx.beans.value.ChangeListener;
  import javafx.beans.value.ObservableValue;
  import javafx.collections.FXCollections;
  import javafx.collections.ObservableList;
  import javafx.event.ActionEvent;
  import javafx.event.EventHandler;
  import javafx.geometry.Pos;
  import javafx.print.PageOrientation;
  import javafx.scene.Node;
  import javafx.scene.control.Button;
  import javafx.scene.control.ChoiceBox;
  import javafx.scene.control.ComboBox;
  import javafx.scene.control.Label;
  import javafx.scene.control.Spinner;
  import javafx.scene.control.SpinnerValueFactory.IntegerSpinnerValueFactory;
  import javafx.scene.control.Tooltip;
  import javafx.scene.layout.HBox;
  import javafx.scene.layout.Priority;
  import javafx.scene.layout.Region;
  import javafx.scene.layout.VBox;
  import net.sourceforge.jhunters.pool.PoolException;
  import net.sourceforge.jhunters.pool.data.Competition;
  import net.sourceforge.jhunters.pool.data.CompetitionList;
  import net.sourceforge.jhunters.pool.data.DataSet;
  import net.sourceforge.jhunters.pool.data.FixtureSet;
  import net.sourceforge.jhunters.pool.ui.AppControl.WindowAdjustment;
  import net.sourceforge.jhunters.pool.ui.GuiIcons.IconId;
  import net.sourceforge.jhunters.pool.ui.ReportPanel.TableSource;
  
  /**
   * Competition Panel.
   */
  public class CompetitionPanel
          extends VBox {
      /**
       * The print button text.
       */
      private static final String PRINT_TEXT = GuiResource.BUTTON_PRINT.getValue();
  
      /**
       * The web button text.
       */
      private static final String WEB_TEXT = GuiResource.BUTTON_WEB.getValue();
  
      /**
       * The save button text.
       */
      private static final String SAVE_TEXT = GuiResource.BUTTON_SAVE.getValue();
  
      /**
       * The weekNo label text.
       */
      private static final String WEEKNO_TEXT = GuiResource.LABEL_WEEKNO.getValue();
  
      /**
       * The spinner width.
       */
      private static final int WIDTH_SPINNER = 80;
  
      /**
       * the Control.
       */
      private final AppControl theControl;
  
      /**
       * Competition select.
       */
      private final ComboBox<Competition> theCompetitionSelect;
  
      /**
       * View select.
       */
      private final ChoiceBox<ViewSelect> theViewSelect;
  
      /**
       * FixtureSet Spinner Configuration.
       */
      private final IntegerSpinnerValueFactory theFixtureSetConfig;
 
     /**
      * FixtureSet Spinner.
      */
     private final HBox theFixtureSetBox;
 
     /**
      * FixtureSet table.
      */
     private final FixtureSetTable theFixtureTable;
 
     /**
      * League table.
      */
     private final LeagueTable theLeagueTable;
 
     /**
      * Results table.
      */
     private final ResultsTable theResultsTable;
 
     /**
      * Outlook table.
      */
     private final OutlookTable theOutlookTable;
 
     /**
      * Outstanding table.
      */
     private final OutstandingTable theOutstandingTable;
 
     /**
      * Participant table.
      */
     private final ParticipantsTable theParticipantTable;
 
     /**
      * The current dataSet.
      */
     private DataSet theData;
 
     /**
      * Selected competition.
      */
     private Competition theCompetition;
 
     /**
      * Selected fixtureSet.
      */
     private FixtureSet theFixtureSet;
 
     /**
      * Visible Node.
      */
     private Node theCurView;
 
     /**
      * The save button.
      */
     private final Button theSaveButton;
 
     /**
      * Print button.
      */
     private final Button thePrintButton;
 
     /**
      * Source button.
      */
     private final Button theSourceButton;
 
     /**
      * The buttons view.
      */
     private final HBox theButtonsView;
 
     /**
      * Constructor.
      * @param pControl the control
      * @throws PoolException on error
      */
     protected CompetitionPanel(final AppControl pControl) throws PoolException {
         /* Store the control */
         theControl = pControl;
 
         /* Create a selection box for the competition */
         theCompetitionSelect = new ComboBox<Competition>();
 
         /* Handle changes of value */
         theCompetitionSelect.valueProperty().addListener(new ChangeListener<Competition>() {
             @Override
             public void changed(final ObservableValue<? extends Competition> pProperty,
                                 final Competition pOldValue,
                                 final Competition pNewValue) {
                 setCompetition(pNewValue);
             }
         });
 
         /* Create a fixtureSet spinner */
         theFixtureSetConfig = new IntegerSpinnerValueFactory(1, 1);
         Spinner<Integer> mySpinner = new Spinner<Integer>(theFixtureSetConfig);
         Label myLabel = new Label(WEEKNO_TEXT);
         mySpinner.setPrefWidth(WIDTH_SPINNER);
 
         /* Handle changes of value */
         theFixtureSetConfig.valueProperty().addListener(new ChangeListener<Integer>() {
             @Override
             public void changed(final ObservableValue<? extends Integer> pProperty,
                                 final Integer pOldValue,
                                 final Integer pNewValue) {
                 setFixtureSet(pNewValue);
             }
         });
 
         /* Create the Spinner HBox */
         theFixtureSetBox = new HBox();
         theFixtureSetBox.setAlignment(Pos.CENTER);
         theFixtureSetBox.setSpacing(2);
         theFixtureSetBox.getChildren().addAll(myLabel, mySpinner);
 
         /* Create the tables */
         theFixtureTable = new FixtureSetTable();
         theOutstandingTable = new OutstandingTable();
         theLeagueTable = new LeagueTable(theOutstandingTable);
         theResultsTable = new ResultsTable();
         theOutlookTable = new OutlookTable();
         theParticipantTable = new ParticipantsTable();
 
         /* Create the View selection and populate it */
         theViewSelect = new ChoiceBox<ViewSelect>();
         ObservableList<ViewSelect> myItems = theViewSelect.getItems();
         for (ViewSelect myView : ViewSelect.values()) {
             myItems.add(myView);
         }
         theViewSelect.setValue(ViewSelect.FIXTURES);
 
         /* Handle changes of value */
         theViewSelect.valueProperty().addListener(new ChangeListener<ViewSelect>() {
             @Override
             public void changed(final ObservableValue<? extends ViewSelect> pProperty,
                                 final ViewSelect pOldValue,
                                 final ViewSelect pNewValue) {
                 setView(pNewValue);
             }
         });
 
         /* Create print button */
         thePrintButton = new Button();
         thePrintButton.setGraphic(GuiIcons.getButtonIcon(IconId.PRINT));
         thePrintButton.setTooltip(new Tooltip(PRINT_TEXT));
         thePrintButton.setOnAction(new EventHandler<ActionEvent>() {
             @Override
             public void handle(final ActionEvent e) {
                 theControl.printNode(theCurView, theViewSelect.getValue());
             }
         });
 
         /* Create source button */
         theSourceButton = new Button();
         theSourceButton.setGraphic(GuiIcons.getButtonIcon(IconId.WEB));
         theSourceButton.setTooltip(new Tooltip(WEB_TEXT));
         theSourceButton.setOnAction(new EventHandler<ActionEvent>() {
             @Override
             public void handle(final ActionEvent e) {
                 theControl.createWeb(CompetitionPanel.this, theCompetition);
             }
         });
 
         /* Create the save button */
         theSaveButton = new Button();
         theSaveButton.setGraphic(GuiIcons.getButtonIcon(IconId.SAVE));
         theSaveButton.setTooltip(new Tooltip(SAVE_TEXT));
 
         /* Set save button action */
         theSaveButton.setOnAction(new EventHandler<ActionEvent>() {
             @Override
             public void handle(final ActionEvent e) {
                 theControl.saveToFile();
             }
         });
 
         /* Create a small HBox for the right corner */
         theButtonsView = new HBox();
         theButtonsView.setSpacing(2);
         theButtonsView.getChildren().addAll(theViewSelect, thePrintButton, theSourceButton);
 
         /* Grow the selection buttons to the size of the print icon */
         theViewSelect.setMaxHeight(Double.MAX_VALUE);
         theCompetitionSelect.setMaxHeight(Double.MAX_VALUE);
 
         /* Create an options sub-panel */
         HBox mySelect = new HBox();
         Region mySpacer1 = new Region();
         Region mySpacer2 = new Region();
         HBox.setHgrow(mySpacer1, Priority.ALWAYS);
         HBox.setHgrow(mySpacer2, Priority.ALWAYS);
         mySelect.getChildren().addAll(theCompetitionSelect, mySpacer1, theFixtureSetBox, mySpacer2, theButtonsView);
 
         /* create panel */
         VBox.setVgrow(theFixtureTable, Priority.ALWAYS);
         VBox.setVgrow(theLeagueTable, Priority.ALWAYS);
         VBox.setVgrow(theResultsTable, Priority.ALWAYS);
         VBox.setVgrow(theOutlookTable, Priority.ALWAYS);
         VBox.setVgrow(theOutstandingTable, Priority.ALWAYS);
         VBox.setVgrow(theParticipantTable, Priority.ALWAYS);
         getChildren().addAll(mySelect, theFixtureTable);
 
         /* Initialise the view */
         theCurView = theFixtureTable;
     }
 
     /**
      * Set data.
      * @param pData the dataSet
      */
     protected void setData(final DataSet pData) {
         /* Store the data */
         theData = pData;
 
         /* Ensure save button is in correct state */
         final ObservableList<Node> myChildren = theButtonsView.getChildren();
         myChildren.remove(theSaveButton);
         if (theData.isUpdated()) {
             myChildren.add(theSaveButton);
         }
 
         /* Add listener */
         theData.updatedProperty().addListener(
                 new ChangeListener<Boolean>() {
                     public void changed(final ObservableValue<? extends Boolean> pValue,
                                         final Boolean pOldState,
                                         final Boolean pNewState) {
                         if (pNewState) {
                             myChildren.add(theSaveButton);
                         } else {
                             myChildren.remove(theSaveButton);
                         }
                     }
                 });
 
         /* Update the dataSet references */
         theFixtureTable.setData(pData);
         theLeagueTable.setData(pData);
         theResultsTable.setData(pData);
         theOutstandingTable.setData(pData);
 
         /* Update the competitions */
         updateCompetitions();
     }
 
     /**
      * Update competitions.
      */
     protected void updateCompetitions() {
         /* Access the competition list */
         CompetitionList myCompList = theData.getCompetitions();
         List<Competition> myList = myCompList.getCompetitions();
 
         /* Obtain selected value */
         Competition mySelected = theCompetitionSelect.getValue();
 
         /* Clear existing values */
         ObservableList<Competition> myValues = theCompetitionSelect.getItems();
         myValues.clear();
 
         /* Loop through the competitions */
         Iterator<Competition> myIterator = myCompList.competitionIterator();
         while (myIterator.hasNext()) {
             Competition myCompetition = myIterator.next();
 
             /* Add the competition to the list */
             myValues.add(myCompetition);
         }
 
         /* If the selected value is not present in the list */
         if ((mySelected == null)
             || !myList.contains(mySelected)) {
             /* Obtain the first element in the list */
             mySelected = myList.isEmpty()
                                           ? null
                                           : myList.get(0);
         }
 
         /* Select the value */
         theCompetitionSelect.setValue(mySelected);
 
         /* Sort the values */
         FXCollections.sort(myValues);
     }
 
     /**
      * Set competition.
      * @param pCompetition the competition
      */
     private void setCompetition(final Competition pCompetition) {
         /* Store the competition */
         theCompetition = pCompetition;
 
         /* Update fixtures */
         if (pCompetition != null) {
             theCompetition.processFixtures();
         }
 
         /* Update the fixtureSet reference */
         theFixtureTable.setCompetition(pCompetition);
 
         /* Check to see whether the fixtureSet will change */
         Integer mySet = theFixtureSetConfig.getValue();
         boolean bChange = mySet != 1;
 
         /* Set the maximum number of weeks */
         theFixtureSetConfig.setMax(pCompetition != null
                                                         ? pCompetition.getNumWeeks()
                                                         : 1);
 
         /* select the first fixture set */
         theFixtureSetConfig.setValue(1);
 
         /* If the fixtureSet was already 1 then we need to manually select */
         if (!bChange) {
             setFixtureSet(1);
         }
 
         /* Update the league table */
         theLeagueTable.setCompetition(pCompetition);
 
         /* Update the results table */
         theResultsTable.setCompetition(pCompetition);
 
         /* Update the outlook table */
         theOutlookTable.setCompetition(pCompetition);
 
         /* Update the outstanding table */
         theOutstandingTable.setCompetition(pCompetition);
 
         /* Update the participant table */
         theParticipantTable.setCompetition(pCompetition);
     }
 
     /**
      * Set fixtureSet.
      * @param pFixtureSet the fixtureSet
      */
     private void setFixtureSet(final Integer pFixtureSet) {
         /* Obtain the fixtureSet */
         theFixtureSet = theCompetition != null
                                                ? theCompetition.getFixtureSet(pFixtureSet)
                                                : null;
 
         /* Declare the fixtureSet to the table */
         theFixtureTable.setFixtureSet(theFixtureSet);
     }
 
     /**
      * Set view.
      * @param pView the view
      */
     private void setView(final ViewSelect pView) {
         /* Remove existing view */
         ObservableList<Node> myChildren = getChildren();
         myChildren.remove(theCurView);
         WindowAdjustment myAdjust;
 
         /* Switch on view */
         switch (pView) {
             case FIXTURES:
                 myAdjust = new WindowAdjustment(theFixtureTable, theCurView);
                 theCurView = theFixtureTable;
                 theFixtureSetBox.setVisible(true);
                 break;
             case TABLE:
                 myAdjust = new WindowAdjustment(theLeagueTable, theCurView);
                 theCurView = theLeagueTable;
                 theFixtureSetBox.setVisible(false);
                 break;
             case RESULTS:
                 myAdjust = new WindowAdjustment(theResultsTable, theCurView);
                 theCurView = theResultsTable;
                 theFixtureSetBox.setVisible(false);
                 break;
             case OUTLOOK:
                 myAdjust = new WindowAdjustment(theOutlookTable, theCurView);
                 theCurView = theOutlookTable;
                 theFixtureSetBox.setVisible(false);
                 break;
             case OUTSTANDING:
                 myAdjust = new WindowAdjustment(theOutstandingTable, theCurView);
                 theCurView = theOutstandingTable;
                 theFixtureSetBox.setVisible(false);
                 break;
             case PARTICIPANTS:
             default:
                 myAdjust = new WindowAdjustment(theParticipantTable, theCurView);
                 theCurView = theParticipantTable;
                 theFixtureSetBox.setVisible(false);
                 break;
         }
 
         /* Add the view to the table */
         myChildren.add(theCurView);
 
         /* Adjust the stage */
         theControl.adjustStage(myAdjust);
     }
 
     /**
      * Obtain source for view.
      * @param pView the view
      * @return the corresponding source
      */
     protected TableSource getSource(final ViewSelect pView) {
         switch (pView) {
             case FIXTURES:
                 return theFixtureTable;
             case TABLE:
                 return theLeagueTable;
             case RESULTS:
                 return theResultsTable;
             case OUTSTANDING:
                 return theOutstandingTable;
             case PARTICIPANTS:
                 return theParticipantTable;
             default:
                 return null;
         }
     }
 
     /**
      * View selection.
      */
     protected enum ViewSelect {
         /**
          * Fixtures.
          */
         FIXTURES,
 
         /**
          * Table.
          */
         TABLE,
 
         /**
          * Outstanding.
          */
         OUTSTANDING,
 
         /**
          * Results.
          */
         RESULTS,
 
         /**
          * Outlook.
          */
         OUTLOOK,
 
         /**
          * Participants.
          */
         PARTICIPANTS;
 
         /**
          * The String name.
          */
         private String theName;
 
         @Override
         public String toString() {
             /* If we have not yet loaded the name */
             if (theName == null) {
                 /* Load the name */
                 theName = GuiResource.getKeyForViewSelect(this).getValue();
             }
 
             /* return the name */
             return theName;
         }
 
         /**
          * Determine orientation for printing.
          * @return the orientation
          */
         protected PageOrientation getOrientation() {
             switch (this) {
                 case RESULTS:
                     return PageOrientation.LANDSCAPE;
                 default:
                     return PageOrientation.PORTRAIT;
             }
         }
     }
 }