/*******************************************************************************
    * 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.security.SecureRandom;
  import java.time.LocalDate;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import net.sourceforge.jhunters.pool.PoolStatus;
  
  /**
   * Competition Fixture.
   */
  public class FixtureList {
      /**
       * FixtureList Name.
       */
      protected static final String OBJECT_NAME = DataResource.FIXTURELIST_NAME.getValue();
  
      /**
       * List of FixtureSets.
       */
      private final List<FixtureSet> theFixtures;
  
      /**
       * The status of the list.
       */
      private PoolStatus theStatus;
  
      /**
       * Constructor.
       */
      public FixtureList() {
          theFixtures = new ArrayList<FixtureSet>();
      }
  
      /**
       * Obtain the status.
       * @return the status.
       */
      public PoolStatus getStatus() {
          return theStatus;
      }
  
      /**
       * Obtain the number of FixtureSets.
       * @return the # fixture sets.
       */
      public Integer size() {
          return theFixtures.size();
      }
  
      /**
       * Obtain the numbered fixtureSet.
       * @param pWeek the week #
       * @return the fixture set.
       */
      public FixtureSet getFixtureSet(final Integer pWeek) {
          return ((pWeek > 0) && (pWeek <= theFixtures.size()))
                                                                ? theFixtures.get(pWeek - 1)
                                                                : null;
      }
  
      /**
       * Reset fixtures.
       */
      protected void reset() {
          theFixtures.clear();
      }
  
      /**
       * Add fixtureSet.
       * @param pSet the fixture set.
       */
      protected void addFixtureSet(final FixtureSet pSet) {
          /* Add to the fixture set list */
          theFixtures.add(pSet);
      }
  
      /**
      * Set fixtures.
      * @param pSource the source fixtures.
      */
     protected void setFixtures(final Iterator<FixtureSet> pSource) {
         /* Reset the fixtures */
         reset();
 
         /* Loop through the source list */
         while (pSource.hasNext()) {
             FixtureSet mySet = pSource.next();
 
             /* Add the set */
             theFixtures.add(mySet);
         }
     }
 
     /**
      * Obtain fixture list.
      * @return the fixtures
      */
     private List<FixtureSet> getFixtures() {
         return theFixtures;
     }
 
     /**
      * Obtain fixtureIterator.
      * @return the iterator
      */
     public Iterator<FixtureSet> fixtureIterator() {
         return theFixtures.iterator();
     }
 
     /**
      * Set Bye player.
      * @param pPlayer the final player
      */
     protected void setByePlayer(final Player pPlayer) {
         /* Loop through the fixtureSets */
         Iterator<FixtureSet> myIterator = fixtureIterator();
         while (myIterator.hasNext()) {
             FixtureSet myCurr = myIterator.next();
 
             /* Set the bye player */
             myCurr.setByePlayer(pPlayer);
         }
     }
 
     /**
      * Randomise the fixtures.
      * @param pRandom the random generator
      */
     protected void randomise(final SecureRandom pRandom) {
         /* Randomise the fixture sets */
         Collections.shuffle(theFixtures, pRandom);
 
         /* Loop through the fixtureSets */
         Iterator<FixtureSet> myIterator = fixtureIterator();
         while (myIterator.hasNext()) {
             FixtureSet myCurr = myIterator.next();
 
             /* Randomise the fixtureSet */
             myCurr.randomise(pRandom);
         }
     }
 
     /**
      * Set dates.
      * @param pDate the base date.
      */
     protected void setDates(final LocalDate pDate) {
         /* Loop through the fixtureSets */
         int myWeekNo = 1;
         LocalDate myDate = pDate;
         Iterator<FixtureSet> myIterator = fixtureIterator();
         while (myIterator.hasNext()) {
             FixtureSet myCurr = myIterator.next();
 
             /* Set the dates */
             myCurr.setDates(myWeekNo, myDate);
 
             /* Shift values */
             myWeekNo++;
             myDate = myDate.plusWeeks(1);
         }
     }
 
     @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 FixtureList)) {
             return false;
         }
 
         /* Access as fixtureList */
         FixtureList myThat = (FixtureList) pThat;
 
         /* Test only on fixtures */
         return theFixtures.equals(myThat.getFixtures());
     }
 
     @Override
     public int hashCode() {
         return theFixtures.hashCode();
     }
 
     /**
      * validate the fixture list.
      * @param pParticipants the participants
      * @return the status
      */
     protected PoolStatus validate(final PlayerList pParticipants) {
         /* Create the fixture map */
         Map<String, List<String>> myMap = new HashMap<String, List<String>>();
         theStatus = PoolStatus.VALID;
 
         /* Loop through the fixture sets */
         Iterator<FixtureSet> myIterator = fixtureIterator();
         while (myIterator.hasNext()) {
             FixtureSet myCurr = myIterator.next();
 
             /* Validate the fixture */
             PoolStatus myStatus = myCurr.validate(pParticipants);
             if (!myStatus.isValid()) {
                 theStatus = PoolStatus.INVALID;
             }
 
             /* Loop through the fixtures */
             Iterator<Fixture> myFixIterator = myCurr.fixtureIterator();
             while (myFixIterator.hasNext()) {
                 Fixture myFixture = myFixIterator.next();
 
                 /* Ignore byes */
                 if (myFixture.isBye()) {
                     continue;
                 }
 
                 /* Access players */
                 Player myHome = myFixture.getHomePlayer();
                 Player myAway = myFixture.getAwayPlayer();
 
                 /* Register match-up */
                 registerMatch(myMap, myHome, myAway);
                 registerMatch(myMap, myAway, myHome);
             }
         }
 
         /* If we are valid */
         if (theStatus.isValid()) {
             /* Determine the number of fixtures */
             int myNumFixtures = pParticipants.size() - 1;
 
             /* Loop through the fixture map */
             Iterator<List<String>> myMapIterator = myMap.values().iterator();
             while (myMapIterator.hasNext()) {
                 List<String> myList = myMapIterator.next();
 
                 /* Note If the list is the wrong size */
                 if (myList.size() != myNumFixtures) {
                     theStatus = PoolStatus.INVALID;
                 }
             }
         }
 
         /* Return the status */
         return theStatus;
     }
 
     /**
      * register a match up.
      * @param pMap the fixture map
      * @param pFirst the first player
      * @param pSecond the second player
      */
     protected void registerMatch(final Map<String, List<String>> pMap,
                                  final Player pFirst,
                                  final Player pSecond) {
         /* Obtain the list */
         String myFirst = pFirst.getName();
         List<String> myList = pMap.get(myFirst);
         if (myList == null) {
             myList = new ArrayList<String>();
             pMap.put(myFirst, myList);
         }
 
         /* Add second player if not already in list */
         String mySecond = pSecond.getName();
         if (!myList.contains(mySecond)) {
             myList.add(mySecond);
         }
     }
 }