/*******************************************************************************
    * 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.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import javafx.collections.FXCollections;
  import javafx.collections.ObservableList;
  import net.sourceforge.jhunters.pool.data.CompetitionFixtures.FixtureComparator;
  import net.sourceforge.jhunters.pool.data.CompetitionFixtures.FixtureRecord;
  import net.sourceforge.jhunters.pool.data.Player.PlayerComparator;
  
  /**
   * Competition matrix.
   */
  public class CompetitionMatrix {
      /**
       * The list of competition fixtures.
       */
      private final ObservableList<CompetitionFixtures> theFixtures;
  
      /**
       * The map of entries.
       */
      private final Map<Integer, CompetitionFixtures> theFixtureMap;
  
      /**
       * The comparator.
       */
      private final Comparator<CompetitionFixtures> theComparator;
  
      /**
       * Constructor.
       */
      protected CompetitionMatrix() {
          theFixtures = FXCollections.observableArrayList();
          theFixtureMap = new HashMap<Integer, CompetitionFixtures>();
          theComparator = new FixtureComparator();
      }
  
      /**
       * Set players.
       * @param pPlayers the list of players
       */
      protected void setPlayers(final List<Player> pPlayers) {
          /* Obtain a copy of the players and sort the list */
          List<Player> myList = new ArrayList<Player>(pPlayers);
          Collections.sort(myList, new PlayerComparator());
  
          /* Initialise counter and list size */
          int i = 0;
          int mySize = pPlayers.size();
  
          /* Loop through the players */
          Iterator<Player> myIterator = myList.iterator();
          while (myIterator.hasNext()) {
              Player myPlayer = myIterator.next();
  
              /* Create the fixtures */
              CompetitionFixtures myFixtures = new CompetitionFixtures(myPlayer, mySize);
              myFixtures.setIndex(i++);
              theFixtures.add(myFixtures);
              theFixtureMap.put(myPlayer.getId(), myFixtures);
          }
      }
  
      /**
       * Reset players.
       */
      protected void adjustPlayers() {
          /* Determine any re-map required */
          RemapMatrix myMapping = new RemapMatrix();
  
          /* If we need to reMap indices */
          if (myMapping.isReMapRequired()) {
              /* Adjust the fixtures */
              myMapping.adjustFixtures();
  
             /* Set new indices */
             myMapping.setNewIndices();
         }
     }
 
     /**
      * Obtain the matrix.
      * @return the matrix
      */
     public ObservableList<CompetitionFixtures> getMatrix() {
         return theFixtures;
     }
 
     /**
      * Obtain fixtures for player.
      * @param pPlayer the player
      * @return the fixtures
      */
     private CompetitionFixtures getFixtures(final Player pPlayer) {
         return theFixtureMap.get(pPlayer.getId());
     }
 
     /**
      * Process fixtures.
      * @param pFixtures the fixtures
      */
     protected void processFixtures(final FixtureList pFixtures) {
         /* Reset the outlook cache */
         resetOutlook();
 
         /* Loop through the fixture sets */
         Iterator<FixtureSet> myIterator = pFixtures.fixtureIterator();
         while (myIterator.hasNext()) {
             FixtureSet mySet = myIterator.next();
 
             /* Process fixture set */
             processFixtureSet(mySet);
         }
 
         /* determine the outlook */
         determineOutlook();
     }
 
     /**
      * Process fixtureSet.
      * @param pSet the fixture Set
      */
     private void processFixtureSet(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;
             }
 
             /* Process fixture */
             processFixture(myFixture);
         }
     }
 
     /**
      * Process fixture.
      * @param pFixture the fixture
      */
     protected void processFixture(final Fixture pFixture) {
         /* Access player details */
         CompetitionFixtures myHome = getFixtures(pFixture.getHomePlayer());
         CompetitionFixtures myAway = getFixtures(pFixture.getAwayPlayer());
 
         /* Obtain result details */
         Result myResult = pFixture.getResult();
         if (myResult != null) {
             /* Set results */
             myHome.setResult(myResult, myAway);
             myAway.setResult(myResult.reverse(), myHome);
 
             /* else not played yet */
         } else {
             LocalDate myDate = pFixture.getPlannedDate();
 
             /* Set date */
             myHome.setOutlook(myDate, myAway);
             myAway.setOutlook(myDate, myHome);
         }
     }
 
     /**
      * reset outlook.
      */
     private void resetOutlook() {
         /* Loop through the fixtures */
         Iterator<CompetitionFixtures> myIterator = theFixtures.iterator();
         while (myIterator.hasNext()) {
             CompetitionFixtures myFixtures = myIterator.next();
 
             /* determine outlook */
             myFixtures.resetOutlook();
         }
     }
 
     /**
      * determine outlook.
      */
     private void determineOutlook() {
         /* Loop through the fixtures */
         Iterator<CompetitionFixtures> myIterator = theFixtures.iterator();
         while (myIterator.hasNext()) {
             CompetitionFixtures myFixtures = myIterator.next();
 
             /* determine outlook */
             myFixtures.determineOutlook();
         }
     }
 
     /**
      * ReMapping definition.
      */
     private final class RemapMatrix {
         /**
          * ReMap definition.
          */
         private final List<Integer[]> theMap;
 
         /**
          * Constructor.
          */
         private RemapMatrix() {
             /* Create the map */
             theMap = new ArrayList<Integer[]>();
 
             /* ReSort the fixture list */
             FXCollections.sort(theFixtures, theComparator);
 
             /* Loop through the fixtures */
             int myIndex = 0;
             Iterator<CompetitionFixtures> myIterator = theFixtures.iterator();
             while (myIterator.hasNext()) {
                 CompetitionFixtures myFixtures = myIterator.next();
 
                 /* If re-mapping is required */
                 int myCurIndex = myFixtures.getIndex();
                 if (myIndex != myCurIndex) {
                     /* Create the map and record it */
                     Integer[] myMap = new Integer[]
                     { myCurIndex, myIndex };
                     theMap.add(myMap);
                 }
 
                 /* Increment index */
                 myIndex++;
             }
         }
 
         /**
          * Is reMap required?
          * @return true/false
          */
         private boolean isReMapRequired() {
             return !theMap.isEmpty();
         }
 
         /**
          * Adjust fixtures.
          */
         private void adjustFixtures() {
             /* Loop through the fixtures */
             Iterator<CompetitionFixtures> myIterator = theFixtures.iterator();
             while (myIterator.hasNext()) {
                 CompetitionFixtures myFixtures = myIterator.next();
 
                 /* Adjust the fixtures */
                 adjustFixtures(myFixtures);
             }
         }
 
         /**
          * Obtain values.
          * @param pFixtures the fixtures
          */
         private void adjustFixtures(final CompetitionFixtures pFixtures) {
             /* Create cache of values to be moved */
             FixtureRecord[] myCache = new FixtureRecord[theMap.size()];
 
             /* Loop through the maps */
             int i = 0;
             Iterator<Integer[]> myIterator = theMap.iterator();
             while (myIterator.hasNext()) {
                 Integer[] myMapping = myIterator.next();
 
                 /* Obtain the value */
                 myCache[i++] = pFixtures.fixtureProperty(myMapping[0]).getValue();
             }
 
             /* Perform second loop */
             i = 0;
             myIterator = theMap.iterator();
             while (myIterator.hasNext()) {
                 Integer[] myMapping = myIterator.next();
 
                 /* Set the value */
                 pFixtures.fixtureProperty(myMapping[1]).setValue(myCache[i++]);
             }
         }
 
         /**
          * Set new indices.
          */
         private void setNewIndices() {
             /* Loop through the fixtures */
             int myIndex = 0;
             Iterator<CompetitionFixtures> myIterator = theFixtures.iterator();
             while (myIterator.hasNext()) {
                 CompetitionFixtures myFixtures = myIterator.next();
 
                 /* Adjust the index */
                 myFixtures.setIndex(myIndex++);
             }
         }
     }
 }