/*******************************************************************************
    * 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.Collections;
  import java.util.Comparator;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  
  import javafx.collections.FXCollections;
  import javafx.collections.ObservableList;
  import net.sourceforge.jhunters.pool.data.PlayerAnalysis.AnalysisComparator;
  
  /**
   * Competition Table.
   */
  public class CompetitionStandings {
      /**
       * The competition.
       */
      private final Competition theCompetition;
  
      /**
       * The competition Table.
       */
      private final AnalysisTable theTable;
  
      /**
       * Map of TieBreak tables.
       */
      private final Map<Integer, AnalysisTable> theTieBreakers;
  
      /**
       * The comparator.
       */
      private final Comparator<PlayerAnalysis> theComparator;
  
      /**
       * Constructor.
       * @param pCompetition the competition
       */
      public CompetitionStandings(final Competition pCompetition) {
          theCompetition = pCompetition;
          theTable = new AnalysisTable();
          theTieBreakers = new HashMap<Integer, AnalysisTable>();
          theComparator = new AnalysisComparator();
      }
  
      /**
       * Obtain the table.
       * @return the table
       */
      public ObservableList<PlayerAnalysis> getTable() {
          return theTable.getTable();
      }
  
      /**
       * Process fixtures.
       * @param pFixtures the fixtures
       */
      protected void processFixtures(final FixtureList pFixtures) {
          /* Clear the active status */
          theCompetition.setActive(Boolean.FALSE);
  
          /* Reset table and map */
          theTable.reset();
          theTieBreakers.clear();
  
          /* Loop through the fixture sets */
          Iterator<FixtureSet> myIterator = pFixtures.fixtureIterator();
          while (myIterator.hasNext()) {
              FixtureSet mySet = myIterator.next();
  
              /* Process fixture set */
              processFixtureSet(mySet);
          }
  
          /* Re-Loop through the fixture sets */
          myIterator = pFixtures.fixtureIterator();
          while (myIterator.hasNext()) {
              FixtureSet mySet = myIterator.next();
  
              /* Process fixture for tieBreakers */
             processTieBreakers(mySet);
         }
 
         /* propagate the tieBreaks */
         propagateTieBreaks();
 
         /* Sort the table */
         sortTable();
     }
 
     /**
      * Sort table.
      */
     protected void sortTable() {
         /* Resort the list */
         FXCollections.sort(theTable.getTable(), theComparator);
     }
 
     /**
      * Process fixtureSet.
      * @param pSet the fixture Set
      */
     private void processFixtureSet(final FixtureSet pSet) {
         /* Access competition startDate */
         LocalDate myDate = theCompetition.getStartDate();
 
         /* Loop through the fixtures */
         Iterator<Fixture> myIterator = pSet.fixtureIterator();
         while (myIterator.hasNext()) {
             Fixture myFixture = myIterator.next();
 
             /* Ignore byes */
             if (myFixture.isBye()) {
                 continue;
             }
 
             /* Process for home player */
             Player myPlayer = myFixture.getHomePlayer();
             PlayerAnalysis myAnalysis = theTable.getAnalysis(myPlayer);
             myAnalysis.analyseHomeFixture(myFixture);
 
             /* Process for away player */
             myPlayer = myFixture.getAwayPlayer();
             myAnalysis = theTable.getAnalysis(myPlayer);
             myAnalysis.analyseAwayFixture(myFixture);
 
             /* If the result is non-null */
             if (myFixture.getResult() != null) {
                 /* Competition is active */
                 theCompetition.setActive(Boolean.TRUE);
             }
 
             /* If we don't have a startDate */
             if (myDate == null) {
                 /* Set start date from fixture */
                 myDate = myFixture.getDate();
                 theCompetition.setStartDate(myDate);
             }
         }
     }
 
     /**
      * Process fixtureSet tieBreakers.
      * @param pSet the fixture Set
      */
     private void processTieBreakers(final FixtureSet pSet) {
         /* Loop through the fixtures */
         Iterator<Fixture> myIterator = pSet.fixtureIterator();
         while (myIterator.hasNext()) {
             Fixture myFixture = myIterator.next();
 
             /* Ignore byes */
             if (myFixture.isBye()) {
                 continue;
             }
 
             /* Access relevant analyses */
             Player myHomePlayer = myFixture.getHomePlayer();
             PlayerAnalysis myHome = theTable.getAnalysis(myHomePlayer);
             Player myAwayPlayer = myFixture.getAwayPlayer();
             PlayerAnalysis myAway = theTable.getAnalysis(myAwayPlayer);
 
             /* If we need a tieBreak */
             if (myHome.getPoints().equals(myAway.getPoints())) {
                 /* Access tieBreak Table */
                 AnalysisTable myTieBreak = getTieBreak(myHome.getPoints());
 
                 /* Analyse for tieBreaks */
                 myHome = myTieBreak.getAnalysis(myHomePlayer);
                 myHome.analyseHomeFixture(myFixture);
                 myAway = myTieBreak.getAnalysis(myAwayPlayer);
                 myAway.analyseAwayFixture(myFixture);
             }
         }
     }
 
     /**
      * Obtain tieBreak table.
      * @param pPoints the points.
      * @return the table
      */
     private AnalysisTable getTieBreak(final Integer pPoints) {
         /* Access existing entry */
         AnalysisTable myTable = theTieBreakers.get(pPoints);
 
         /* If we need a new entry */
         if (myTable == null) {
             /* Create new analysis and store in the map */
             myTable = new AnalysisTable();
             theTieBreakers.put(pPoints, myTable);
         }
 
         /* Return the table */
         return myTable;
     }
 
     /**
      * propagate TieBreaker.
      */
     private void propagateTieBreaks() {
         /* Loop through the entries */
         Iterator<AnalysisTable> myIterator = theTieBreakers.values().iterator();
         while (myIterator.hasNext()) {
             AnalysisTable myCurr = myIterator.next();
 
             /* Sort the table */
             Collections.sort(myCurr.getTable(), theComparator);
 
             /* propagate tieBreaks */
             myCurr.updateTieBreaker(theTable);
         }
     }
 
     /**
      * Obtain tie-Break table.
      * @param pPoints the points for the table
      * @return the tie-break table
      */
     public ObservableList<PlayerAnalysis> getTieBreakTable(final Integer pPoints) {
         /* Access the table */
         AnalysisTable myTable = theTieBreakers.get(pPoints);
 
         /* If we have a table that is inactive */
         if ((myTable != null)
             && !myTable.isActive()) {
             /* Discard the table */
             myTable = null;
         }
 
         /* return the table */
         return myTable == null
                                ? null
                                : myTable.getTable();
     }
 }