/*******************************************************************************
    * 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.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.List;
  
  import javafx.beans.property.ObjectProperty;
  import javafx.beans.property.SimpleObjectProperty;
  
  /**
   * Competition Table.
   */
  public class CompetitionFixtures
          implements Comparable<CompetitionFixtures> {
      /**
       * Outlook depth.
       */
      public static final int OUTLOOK_DEPTH = 5;
  
      /**
       * Base for Id.
       */
      private static final char CHAR_CBASE = 'A';
  
      /**
       * Index radix.
       */
      private static final int RADIX_INDEX = 26;
  
      /**
       * Player.
       */
      private final ObjectProperty<Player> thePlayer;
  
      /**
       * PlayerIndex.
       */
      private final ObjectProperty<Integer> theIndex;
  
      /**
       * PlayerId.
       */
      private final ObjectProperty<String> theId;
  
      /**
       * Fixture Records.
       */
      private final List<ObjectProperty<FixtureRecord>> theFixtures;
  
      /**
       * Outlook Records.
       */
      private final List<ObjectProperty<FixtureOutlook>> theOutlook;
  
      /**
       * Outlook Cache.
       */
      private final List<FixtureOutlook> theOutlookCache;
  
      /**
       * Constructor.
       * @param pPlayer the player.
       * @param pNumPlayers the number of players
       */
      protected CompetitionFixtures(final Player pPlayer,
                                    final int pNumPlayers) {
          thePlayer = new SimpleObjectProperty<Player>(this, PlayerFixtureField.NAME.toString(), pPlayer);
          theIndex = new SimpleObjectProperty<Integer>(this, PlayerFixtureField.INDEX.toString());
          theId = new SimpleObjectProperty<String>(this, PlayerFixtureField.ID.toString());
          theFixtures = new ArrayList<ObjectProperty<FixtureRecord>>();
          for (int i = 0; i < pNumPlayers; i++) {
              theFixtures.add(new SimpleObjectProperty<FixtureRecord>(this, PlayerFixtureField.FIXTURE.toString()));
          }
          theOutlook = new ArrayList<ObjectProperty<FixtureOutlook>>();
          for (int i = 0; i < OUTLOOK_DEPTH; i++) {
              theOutlook.add(new SimpleObjectProperty<FixtureOutlook>(this, PlayerFixtureField.OUTLOOK.toString()));
          }
          theOutlookCache = new ArrayList<FixtureOutlook>();
      }
  
     /**
      * Obtain the player property.
      * @return the player property.
      */
     public ObjectProperty<Player> playerProperty() {
         return thePlayer;
     }
 
     /**
      * Obtain the index property.
      * @return the player index property.
      */
     public ObjectProperty<Integer> indexProperty() {
         return theIndex;
     }
 
     /**
      * Obtain the id property.
      * @return the player id property.
      */
     public ObjectProperty<String> idProperty() {
         return theId;
     }
 
     /**
      * Obtain the player.
      * @return the player.
      */
     public Player getPlayer() {
         return thePlayer.getValue();
     }
 
     /**
      * Obtain the index.
      * @return the player index.
      */
     public Integer getIndex() {
         return theIndex.getValue();
     }
 
     /**
      * Obtain the id.
      * @return the player id.
      */
     private String getId() {
         return theId.getValue();
     }
 
     /**
      * Obtain the fixture record for the index.
      * @param pIndex the index
      * @return the fixture record property.
      */
     public ObjectProperty<FixtureRecord> fixtureProperty(final int pIndex) {
         return theFixtures.get(pIndex);
     }
 
     /**
      * Obtain the fixture outlook for the index.
      * @param pIndex the index
      * @return the fixture record property.
      */
     public ObjectProperty<FixtureOutlook> outlookProperty(final int pIndex) {
         return theOutlook.get(pIndex);
     }
 
     /**
      * get Id for index.
      * @param pIndex the index
      * @return the id
      */
     public static String getIdForIndex(final int pIndex) {
         /* Calculate indexes */
         int myId = pIndex;
         int myTopId = myId
                       / RADIX_INDEX;
         myId = myId
                % RADIX_INDEX;
 
         /* Build the name */
         StringBuilder myBuilder = new StringBuilder();
         if (myTopId > 0) {
             myBuilder.append((char) (CHAR_CBASE
                                      + myTopId));
         }
         myBuilder.append((char) (CHAR_CBASE + myId));
         return myBuilder.toString();
     }
 
     /**
      * ReSet the outlook cache.
      */
     protected void resetOutlook() {
         /* Record the index */
         theOutlookCache.clear();
     }
 
     /**
      * Set the index.
      * @param pIndex the index
      */
     protected void setIndex(final int pIndex) {
         /* Record the index */
         theIndex.setValue(pIndex);
         theId.setValue(getIdForIndex(pIndex));
     }
 
     /**
      * Set the result.
      * @param pResult the result
      * @param pOpponent the opponent
      */
     protected void setResult(final Result pResult,
                              final CompetitionFixtures pOpponent) {
         /* Record the fixture */
         ObjectProperty<FixtureRecord> myFixture = fixtureProperty(pOpponent.getIndex());
         myFixture.setValue(new FixtureRecord(pResult));
     }
 
     /**
      * Set the outlook.
      * @param pDate the date
      * @param pOpponent the opponent
      */
     protected void setOutlook(final LocalDate pDate,
                               final CompetitionFixtures pOpponent) {
         /* Record the fixture */
         ObjectProperty<FixtureRecord> myFixture = fixtureProperty(pOpponent.getIndex());
         myFixture.setValue(new FixtureRecord(pDate));
 
         /* Store in the outlook cache */
         theOutlookCache.add(new FixtureOutlook(pDate, pOpponent));
     }
 
     /**
      * determine outlook.
      */
     protected void determineOutlook() {
         /* Sort the outlook cache */
         Collections.sort(theOutlookCache);
 
         /* Loop through the cache */
         int i = 0;
         Iterator<FixtureOutlook> myIterator = theOutlookCache.iterator();
         while (myIterator.hasNext() && (i < OUTLOOK_DEPTH)) {
             FixtureOutlook myOutlook = myIterator.next();
 
             /* Store as outlook */
             ObjectProperty<FixtureOutlook> myFixture = outlookProperty(i++);
             myFixture.setValue(myOutlook);
         }
 
         /* If we stopped early */
         while (i < OUTLOOK_DEPTH) {
             /* Store null */
             ObjectProperty<FixtureOutlook> myFixture = outlookProperty(i++);
             myFixture.setValue(null);
         }
     }
 
     @Override
     public boolean equals(final Object pThat) {
         /* Handle trivial cases */
         if (pThat == this) {
             return true;
         }
         if (pThat == null) {
             return false;
         }
 
         /* Check for class */
         if (!(pThat instanceof CompetitionFixtures)) {
             return false;
         }
 
         /* Access as CompetitionFixtures */
         CompetitionFixtures myThat = (CompetitionFixtures) pThat;
 
         /* Check fields */
         return thePlayer.getValue().equals(myThat.thePlayer.getValue());
     }
 
     @Override
     public int hashCode() {
         return thePlayer.hashCode();
     }
 
     @Override
     public int compareTo(final CompetitionFixtures pThat) {
         return thePlayer.getValue().compareTo(pThat.thePlayer.getValue());
     }
 
     /**
      * Comparator class.
      */
     protected static final class FixtureComparator
             implements Comparator<CompetitionFixtures> {
         @Override
         public int compare(final CompetitionFixtures pFirst,
                            final CompetitionFixtures pSecond) {
             return pFirst.compareTo(pSecond);
         }
     }
 
     /**
      * FixtureRecord class.
      */
     public static final class FixtureRecord {
         /**
          * Date of game.
          */
         private final LocalDate theDate;
 
         /**
          * Result of game.
          */
         private final Result theResult;
 
         /**
          * Constructor.
          * @param pResult the result
          */
         private FixtureRecord(final Result pResult) {
             theResult = pResult;
             theDate = null;
         }
 
         /**
          * Constructor.
          * @param pDate the date
          */
         private FixtureRecord(final LocalDate pDate) {
             theDate = pDate;
             theResult = null;
         }
 
         /**
          * Obtain result.
          * @return the result
          */
         public Result getResult() {
             return theResult;
         }
 
         @Override
         public String toString() {
             return theResult != null
                                      ? theResult.toString()
                                      : DataParser.formatShortDate(theDate);
         }
     }
 
     /**
      * FixtureOutlook class.
      */
     public static final class FixtureOutlook
             implements Comparable<FixtureOutlook> {
         /**
          * Date of game.
          */
         private final LocalDate theDate;
 
         /**
          * Opponent for game.
          */
         private final CompetitionFixtures theOpponent;
 
         /**
          * Constructor.
          * @param pDate the date
          * @param pOpponent the opponent
          */
         private FixtureOutlook(final LocalDate pDate,
                                final CompetitionFixtures pOpponent) {
             theDate = pDate;
             theOpponent = pOpponent;
         }
 
         @Override
         public String toString() {
             StringBuilder myBuilder = new StringBuilder();
             myBuilder.append(DataParser.formatShortDate(theDate));
             myBuilder.append(' ');
             myBuilder.append(Fixture.MATCH_VERSUS);
             myBuilder.append(' ');
             myBuilder.append(theOpponent.getId());
             return myBuilder.toString();
         }
 
         @Override
         public boolean equals(final Object pThat) {
             /* Handle trivial cases */
             if (pThat == this) {
                 return true;
             }
             if (pThat == null) {
                 return false;
             }
 
             /* Check for class */
             if (!(pThat instanceof FixtureOutlook)) {
                 return false;
             }
 
             /* Access as FixtureOutlook */
             FixtureOutlook myThat = (FixtureOutlook) pThat;
 
             /* Check fields */
             return theDate.equals(myThat.theDate)
                    && theOpponent.equals(myThat.theOpponent);
         }
 
         @Override
         public int hashCode() {
             return (theDate.hashCode() * DataSet.HASH_PRIME)
                    + theOpponent.hashCode();
         }
 
         @Override
         public int compareTo(final FixtureOutlook pThat) {
             int iDiff = theDate.compareTo(pThat.theDate);
             if (iDiff != 0) {
                 return iDiff;
             }
             return theOpponent.compareTo(pThat.theOpponent);
         }
     }
 
     /**
      * PlayerFixture fields.
      */
     public enum PlayerFixtureField {
         /**
          * Name.
          */
         NAME,
 
         /**
          * Contact.
          */
         INDEX,
 
         /**
          * Selected.
          */
         ID,
 
         /**
          * Fixture.
          */
         FIXTURE,
 
         /**
          * Outlook.
          */
         OUTLOOK,
 
         /**
          * Contact.
          */
         CONTACT;
 
         /**
          * 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.getKeyForPlayerFixtureField(this).getValue();
             }
 
             /* return the name */
             return theName;
         }
     }
 }