/*******************************************************************************
    * 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.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  
  import javafx.beans.Observable;
  import javafx.collections.FXCollections;
  import javafx.collections.ObservableList;
  import net.sourceforge.jhunters.pool.PoolStatus;
  
  /**
   * Competition List.
   */
  public class CompetitionList {
      /**
       * Object name.
       */
      protected static final String OBJECT_NAME = DataResource.COMPETITION_LIST.getValue();
  
      /**
       * List of competitions.
       */
      private final ObservableList<Competition> theCompetitions;
  
      /**
       * The status of the list.
       */
      private PoolStatus theStatus;
  
      /**
       * Constructor.
       */
      public CompetitionList() {
          /* Create the player list with an extractor to allow SortedList to work */
          theCompetitions = FXCollections.observableArrayList(p -> new Observable[] { p.nameProperty() });
      }
  
      /**
       * Obtain competitions.
       * @return the competitions
       */
      public ObservableList<Competition> getCompetitions() {
          return theCompetitions;
      }
  
      /**
       * Obtain competition iterator.
       * @return the iterator
       */
      public Iterator<Competition> competitionIterator() {
          return theCompetitions.iterator();
      }
  
      /**
       * Obtain the status.
       * @return the status.
       */
      public PoolStatus getStatus() {
          return theStatus;
      }
  
      /**
       * Reset fixtures.
       */
      protected void reset() {
          theCompetitions.clear();
      }
  
      /**
       * Add competition.
       * @param pComp the competition.
       */
      protected void addCompetition(final Competition pComp) {
          /* Add to the competition list */
          theCompetitions.add(pComp);
      }
  
      /**
       * Set competitions.
       * @param pSource the source competitions.
       */
     protected void setCompetitions(final Iterator<Competition> pSource) {
         /* Reset the fixtures */
         reset();
 
         /* Loop through the source list */
         while (pSource.hasNext()) {
             Competition myComp = pSource.next();
 
             /* Add the competition */
             addCompetition(myComp);
         }
     }
 
     /**
      * Get named competitions.
      * @param pName the name of the competition.
      * @return the competition
      */
     public Competition getCompetition(final String pName) {
         /* Loop through the competitions */
         Iterator<Competition> myIterator = theCompetitions.iterator();
         while (myIterator.hasNext()) {
             Competition myComp = myIterator.next();
 
             /* If this is the competition */
             if (pName.equals(myComp.getName())) {
                 return myComp;
             }
         }
 
         /* Not found */
         return null;
     }
 
     /**
      * Create unique player.
      * @return the unique player
      */
     private String createUniqueName() {
         /* Create the builder */
         StringBuilder myBuilder = new StringBuilder();
         myBuilder.append("Competition");
         int myLen = myBuilder.length();
 
         /* Loop through the list */
         int myIndex = 0;
         Competition myComp;
         String myName;
 
         /* Loop to find a unique name */
         do {
             /* Reset the buffer and adjust index */
             myBuilder.setLength(myLen);
             myIndex++;
 
             /* Create name */
             myBuilder.append(myIndex);
             myName = myBuilder.toString();
             myComp = getCompetition(myName);
 
             /* ReLoop if already exists */
         } while (myComp != null);
 
         /* Return the name */
         return myName;
     }
 
     /**
      * Create competition.
      * @param pPlayers the players
      * @return the competition
      */
     public Competition createCompetition(final PlayerList pPlayers) {
         /* Create unique name */
         String myName = createUniqueName();
 
         /* Create start date a week from now */
         LocalDate myDate = LocalDate.now().plusWeeks(1);
 
         /* Create the fixture generator */
         FixtureGenerator myGenerator = new FixtureGenerator();
         myGenerator.setPlayers(pPlayers);
 
         /* Generate the fixture list */
         FixtureList myFixtures = myGenerator.createFixtures(myDate);
 
         /* Create the competition */
         Competition myComp = new Competition();
         myComp.setName(myName);
         myComp.setParticipants(pPlayers.playerIterator());
         myComp.setFixtures(myFixtures.fixtureIterator());
         myComp.setStartDate(myDate);
 
         /* Add competition to the list */
         addCompetition(myComp);
 
         /* return the competition */
         return myComp;
     }
 
     /**
      * Remove a competition from the list.
      * @param pCompetition the competition.
      */
     public void removeCompetition(final Competition pCompetition) {
         theCompetitions.remove(pCompetition);
     }
 
     /**
      * adjust the players.
      */
     protected void adjustPlayers() {
         /* Loop through the competitions */
         Iterator<Competition> myIterator = competitionIterator();
         while (myIterator.hasNext()) {
             Competition myComp = myIterator.next();
 
             /* Adjust players for the competition */
             myComp.adjustPlayers();
         }
     }
 
     @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 CompetitionList)) {
             return false;
         }
 
         /* Access as competition list */
         CompetitionList myThat = (CompetitionList) pThat;
 
         /* Test only on competition list */
         return theCompetitions.equals(myThat.getCompetitions());
     }
 
     @Override
     public int hashCode() {
         return theCompetitions.hashCode();
     }
 
     /**
      * Validate competition list.
      * @return the status
      */
     public PoolStatus validate() {
         /* Create name map */
         Map<String, PoolStatus> myMap = new HashMap<String, PoolStatus>();
         theStatus = PoolStatus.VALID;
 
         /* Loop through the competitions */
         Iterator<Competition> myIterator = competitionIterator();
         while (myIterator.hasNext()) {
             Competition myComp = myIterator.next();
 
             /* Validate the competition */
             PoolStatus myStatus = myComp.validate();
             if (!myStatus.isValid()) {
                 theStatus = PoolStatus.INVALID;
             } else {
                 /* Check for preExistence */
                 String myName = myComp.getName();
                 PoolStatus myExisting = myMap.get(myName);
                 myMap.put(myName, myExisting == null
                                                     ? PoolStatus.VALID
                                                     : PoolStatus.DUPLICATE);
             }
         }
 
         /* If we are valid */
         if (theStatus.isValid()) {
             /* Loop through the players */
             myIterator = competitionIterator();
             while (myIterator.hasNext()) {
                 Competition myComp = myIterator.next();
 
                 /* Ignore invalid competitions */
                 if (!myComp.getStatus().isValid()) {
                     continue;
                 }
 
                 /* If the name is duplicate */
                 String myName = myComp.getName();
                 PoolStatus myStatus = myMap.get(myName);
                 if (!myStatus.isValid()) {
                     /* Set as duplicate */
                     theStatus = PoolStatus.DUPLICATE;
                     myComp.setStatus(theStatus);
                 }
             }
         }
 
         /* return the status */
         return theStatus;
     }
 }