/*******************************************************************************
    * 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.data;
  
  import java.time.LocalDate;
  import java.util.Comparator;
  import java.util.Iterator;
  
  import javafx.beans.Observable;
  import javafx.beans.property.ObjectProperty;
  import javafx.beans.property.SimpleObjectProperty;
  import javafx.collections.FXCollections;
  import javafx.collections.ObservableList;
  import net.sourceforge.jhunters.pool.PoolStatus;
  
  /**
   * Competition.
   */
  public class Competition
          implements Comparable<Competition> {
      /**
       * Object name.
       */
      protected static final String OBJECT_NAME = DataResource.COMPETITION_NAME.getValue();
  
      /**
       * Participant List Name.
       */
      protected static final String PARTICIPANT_LIST = "Participants";
  
      /**
       * Participant Name.
       */
      protected static final String PARTICIPANT_NAME = "Participant";
  
      /**
       * Competition Name.
       */
      private final ObjectProperty<String> theName;
  
      /**
       * Competition Start Date.
       */
      private final ObjectProperty<LocalDate> theStartDate;
  
      /**
       * Competition Player Count.
       */
      private final ObjectProperty<Integer> thePlayerCount;
  
      /**
       * Competition Active.
       */
      private final ObjectProperty<Boolean> theActive;
  
      /**
       * ParticipantList.
       */
      private final PlayerList theParticipants;
  
      /**
       * FixtureList.
       */
      private final FixtureList theFixtures;
  
      /**
       * CompetitionMatrix.
       */
      private final CompetitionMatrix theMatrix;
  
      /**
       * The status of the list.
       */
      private PoolStatus theStatus;
  
      /**
       * Table.
       */
      private final CompetitionStandings theTable;
  
      /**
       * Constructor.
       */
      public Competition() {
          theName = new SimpleObjectProperty<String>(this, CompetitionField.NAME.toString());
         theStartDate = new SimpleObjectProperty<LocalDate>(this, CompetitionField.STARTDATE.toString());
         thePlayerCount = new SimpleObjectProperty<Integer>(this, CompetitionField.PLAYERS.toString());
         theActive = new SimpleObjectProperty<Boolean>(this, CompetitionField.ACTIVE.toString());
         theParticipants = new PlayerList();
         theFixtures = new FixtureList();
         theTable = new CompetitionStandings(this);
         theMatrix = new CompetitionMatrix();
     }
 
     /**
      * Set named property.
      * @param pName the name of the property.
      * @param pValue the value of the property.
      */
     protected void setNamedProperty(final String pName,
                                     final String pValue) {
         if (pName.equals(CompetitionField.NAME.toString())) {
             setName(pValue);
         } else if (pName.equals(CompetitionField.STARTDATE.toString())) {
             setStartDate(DataParser.parseDate(pValue));
         }
     }
 
     /**
      * Obtain the name property.
      * @return the competition name property.
      */
     public ObjectProperty<String> nameProperty() {
         return theName;
     }
 
     /**
      * Obtain the startDate property.
      * @return the startDate property.
      */
     public ObjectProperty<LocalDate> startDateProperty() {
         return theStartDate;
     }
 
     /**
      * Obtain the player count property.
      * @return the player count property.
      */
     public ObjectProperty<Integer> playerCountProperty() {
         return thePlayerCount;
     }
 
     /**
      * Obtain the active property.
      * @return the active property.
      */
     public ObjectProperty<Boolean> activeProperty() {
         return theActive;
     }
 
     /**
      * Obtain the name.
      * @return the player name.
      */
     public String getName() {
         return theName.getValue();
     }
 
     /**
      * Obtain startDate.
      * @return the startDate
      */
     protected LocalDate getStartDate() {
         return theStartDate.getValue();
     }
 
     /**
      * Is the player active?
      * @return true/false.
      */
     public Boolean isActive() {
         return theActive.getValue();
     }
 
     /**
      * Obtain participants.
      * @return the participants
      */
     public PlayerList getParticipants() {
         return theParticipants;
     }
 
     /**
      * Obtain fixture list.
      * @return the fixture list
      */
     public FixtureList getFixtureList() {
         return theFixtures;
     }
 
     /**
      * Obtain the number of FixtureSets.
      * @return the # fixture sets.
      */
     public Integer getNumWeeks() {
         return theFixtures.size();
     }
 
     /**
      * Obtain the player count.
      * @return the # players.
      */
     public Integer getPlayerCount() {
         return thePlayerCount.getValue();
     }
 
     /**
      * Obtain the numbered fixtureSet.
      * @param pWeek the week #
      * @return the fixture set.
      */
     public FixtureSet getFixtureSet(final Integer pWeek) {
         return theFixtures.getFixtureSet(pWeek);
     }
 
     /**
      * Obtain participants iterator.
      * @return the iterator
      */
     protected Iterator<Player> participantIterator() {
         return theParticipants.playerIterator();
     }
 
     /**
      * Obtain fixture list.
      * @return the fixture list
      */
     protected Iterator<FixtureSet> fixtureIterator() {
         return theFixtures.fixtureIterator();
     }
 
     /**
      * Obtain table.
      * @return the table
      */
     public CompetitionStandings getTable() {
         return theTable;
     }
 
     /**
      * Obtain matrix.
      * @return the matrix
      */
     public CompetitionMatrix getMatrix() {
         return theMatrix;
     }
 
     /**
      * Obtain the status.
      * @return the status.
      */
     public PoolStatus getStatus() {
         return theStatus;
     }
 
     /**
      * Set the name.
      * @param pName the name.
      */
     public void setName(final String pName) {
         theName.setValue(pName == null
                                        ? null
                                        : pName.trim());
     }
 
     /**
      * Set the startDate.
      * @param pDate the date.
      */
     public void setStartDate(final LocalDate pDate) {
         theStartDate.setValue(pDate);
     }
 
     /**
      * Set the active flag.
      * @param pValue the new value.
      */
     protected void setActive(final Boolean pValue) {
         theActive.setValue(pValue);
     }
 
     /**
      * Set the status.
      * @param pStatus the status.
      */
     protected void setStatus(final PoolStatus pStatus) {
         theStatus = pStatus;
     }
 
     /**
      * Set the participants.
      * @param pParticipants the participants
      */
     protected void setParticipants(final Iterator<Player> pParticipants) {
         /* Copy the players */
         theParticipants.setPlayers(pParticipants);
 
         /* Set player count */
         thePlayerCount.setValue(theParticipants.size());
 
         /* Reset the fixture list and table */
         theFixtures.reset();
         theMatrix.setPlayers(theParticipants.getPlayers());
     }
 
     /**
      * Set the fixture list.
      * @param pFixtures the fixture list
      */
     protected void setFixtures(final Iterator<FixtureSet> pFixtures) {
         /* Copy the fixtures */
         theFixtures.setFixtures(pFixtures);
     }
 
     /**
      * update dates.
      */
     public void updateDates() {
         /* Update the dates */
         theFixtures.setDates(getStartDate());
     }
 
     @Override
     public String toString() {
         return getName();
     }
 
     @Override
     public boolean equals(final Object pThat) {
         /* Handle trivial cases */
         if (this == pThat) {
             return true;
         }
         if (pThat == null) {
             return false;
         }
 
         /* Handle wrong class */
         if (!(pThat instanceof Competition)) {
             return false;
         }
 
         /* Access as competition */
         Competition myThat = (Competition) pThat;
 
         /* Test on name */
         if (!DataSet.isEqual(getName(), myThat.getName())) {
             return false;
         }
 
         /* Test on participants */
         if (!theParticipants.equals(myThat.getParticipants())) {
             return false;
         }
 
         /* Test on fixture list */
         return theFixtures.equals(myThat.getFixtureList());
     }
 
     @Override
     public int hashCode() {
         int myHash = (theParticipants.hashCode() * DataSet.HASH_PRIME)
                      + theFixtures.hashCode();
         return (myHash * DataSet.HASH_PRIME)
                + theName.hashCode();
     }
 
     @Override
     public int compareTo(final Competition pThat) {
         /* Check for equality and null competition */
         if (equals(pThat)) {
             return 0;
         }
         if (pThat == null) {
             return -1;
         }
 
         /* Access names */
         String myName = getName();
         String myOther = pThat.getName();
 
         /* Check for null names */
         if (myName == null) {
             return 1;
         }
         if (myOther == null) {
             return -1;
         }
 
         /* Compare names */
         return myName.compareTo(myOther);
     }
 
     /**
      * Comparator class.
      */
     public static final class CompetitionComparator
             implements Comparator<Competition> {
         @Override
         public int compare(final Competition pFirst,
                            final Competition pSecond) {
             return pFirst.compareTo(pSecond);
         }
     }
 
     /**
      * Obtain the outstanding fixtures as of base date.
      * @param pBase the base date
      * @return the outstanding fixtures.
      */
     public ObservableList<Fixture> getOutstandingFixtures(final LocalDate pBase) {
         /* Create a new list */
         ObservableList<Fixture> myOutstanding = FXCollections.observableArrayList(p -> new Observable[]
         { p.resultProperty() });
 
         /* Loop through the fixtureSets */
         Iterator<FixtureSet> myIterator = fixtureIterator();
         while (myIterator.hasNext()) {
             FixtureSet myCurr = myIterator.next();
 
             /* Obtain fixtures */
             myCurr.getFixtures(myOutstanding, pBase);
         }
 
         /* return the list */
         return myOutstanding;
     }
 
     /**
      * validate the competition.
      * @return the status
      */
     protected PoolStatus validate() {
         /* Access the name */
         String myName = getName();
         theStatus = ((myName == null)
                      || (myName.length() == 0))
                                                 ? PoolStatus.INVALID
                                                 : PoolStatus.VALID;
 
         /* If we are valid */
         if (theStatus.isValid()) {
             /* Validate the participants */
             theStatus = theParticipants.validate();
         }
 
         /* If we are valid */
         if (theStatus.isValid()) {
             /* Set active status on participants */
             theParticipants.setActive(Boolean.TRUE);
 
             /* validate the fixture list */
             theStatus = theFixtures.validate(theParticipants);
         }
 
         /* return the status */
         return theStatus;
     }
 
     /**
      * adjust the players.
      */
     protected void adjustPlayers() {
         /* re-sort the table */
         theTable.sortTable();
 
         /* adjust the matrix */
         theMatrix.adjustPlayers();
     }
 
     /**
      * process the fixtures.
      */
     public void processFixtures() {
         /* build the table */
         theTable.processFixtures(theFixtures);
 
         /* build the matrix */
         theMatrix.processFixtures(theFixtures);
     }
 
     /**
      * Competition fields.
      */
     public enum CompetitionField {
         /**
          * Name.
          */
         NAME,
 
         /**
          * StartDate.
          */
         STARTDATE,
 
         /**
          * # of players.
          */
         PLAYERS,
 
         /**
          * Active.
          */
         ACTIVE;
 
         /**
          * 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 = DataResource.getKeyForCompetitionField(this).getValue();
             }
 
             /* return the name */
             return theName;
         }
     }
 }