/*******************************************************************************
    * 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.DayOfWeek;
  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 javafx.beans.property.IntegerProperty;
  import javafx.beans.property.SimpleIntegerProperty;
  import javafx.collections.ObservableList;
  import net.sourceforge.jhunters.pool.PoolStatus;
  
  /**
   * Set of fixtures for a particular week.
   */
  public class FixtureSet {
      /**
       * FixtureSet Name.
       */
      protected static final String OBJECT_NAME = DataResource.FIXTURESET_NAME.getValue();
  
      /**
       * WeekNo field.
       */
      private static final String FIELD_WEEKNO = DataResource.FIXTURESET_WEEKNO.getValue();
  
      /**
       * List of fixtures.
       */
      private final List<Fixture> theFixtures;
  
      /**
       * Week number.
       */
      private final IntegerProperty theWeekNo;
  
      /**
       * The status of the set.
       */
      private PoolStatus theStatus;
  
      /**
       * Constructor.
       */
      protected FixtureSet() {
          theFixtures = new ArrayList<Fixture>();
          theWeekNo = new SimpleIntegerProperty(this, FIELD_WEEKNO);
      }
  
      /**
       * Set named property.
       * @param pName the name of the property.
       * @param pValue the value of the property.
       */
      protected void setNamedProperty(final String pName,
                                      final String pValue) {
          if (pName.equals(FIELD_WEEKNO)) {
              setWeekNo(DataParser.parseInteger(pValue));
          }
      }
  
      @Override
      public String toString() {
          /* build display string */
          StringBuilder myBuilder = new StringBuilder();
  
          /* Loop through the fixtures */
          Iterator<Fixture> myIterator = fixtureIterator();
          while (myIterator.hasNext()) {
              Fixture myFixture = myIterator.next();
  
              myBuilder.append(myFixture.toString());
              myBuilder.append('\n');
          }
          return myBuilder.toString();
      }
  
      /**
      * Add fixture.
      * @param pHome the home player.
      * @param pAway the away player
      */
     protected void addFixture(final Player pHome,
                               final Player pAway) {
         /* Create the fixture */
         Fixture myFixture = new Fixture();
         myFixture.setHomePlayer(pHome);
         myFixture.setAwayPlayer(pAway);
 
         /* Add to the fixture list */
         addFixture(myFixture);
     }
 
     /**
      * Add fixture.
      * @param pFixture the fixture to add.
      */
     protected void addFixture(final Fixture pFixture) {
         theFixtures.add(pFixture);
     }
 
     /**
      * Obtain weekNo property.
      * @return the weekNo property
      */
     public IntegerProperty weekNoProperty() {
         return theWeekNo;
     }
 
     /**
      * Obtain weekNo.
      * @return the weekNo
      */
     public Integer getWeekNo() {
         return theWeekNo.getValue();
     }
 
     /**
      * Obtain the status.
      * @return the status.
      */
     public PoolStatus getStatus() {
         return theStatus;
     }
 
     /**
      * Set the weekNo.
      * @param pWeekNo the weekNo
      */
     private void setWeekNo(final Integer pWeekNo) {
         theWeekNo.setValue(pWeekNo);
     }
 
     /**
      * Obtain fixture list.
      * @return the fixtures
      */
     public List<Fixture> getFixtures() {
         return theFixtures;
     }
 
     /**
      * Add fixtures to the list.
      * @param pList the list to add to
      * @param pNow the limiting date
      */
     protected void getFixtures(final ObservableList<Fixture> pList,
                                final LocalDate pNow) {
         /* Loop through the fixtures */
         Iterator<Fixture> myIterator = fixtureIterator();
         while (myIterator.hasNext()) {
             Fixture myCurr = myIterator.next();
 
             /* If this is not a bye and date is in the past */
             if (!myCurr.isBye()
                 && pNow.compareTo(myCurr.getDate()) >= 0) {
                 pList.add(myCurr);
             }
         }
     }
 
     /**
      * Obtain fixtureIterator.
      * @return the iterator
      */
     public Iterator<Fixture> fixtureIterator() {
         return theFixtures.iterator();
     }
 
     /**
      * Set Bye player.
      * @param pPlayer the final player
      */
     protected void setByePlayer(final Player pPlayer) {
         /* Loop through the fixtures */
         Iterator<Fixture> myIterator = fixtureIterator();
         while (myIterator.hasNext()) {
             Fixture myCurr = myIterator.next();
 
             /* If this is the bye */
             if (myCurr.isBye()) {
                 myCurr.setByePlayer(pPlayer);
                 break;
             }
         }
     }
 
     /**
      * Randomise the fixtures.
      * @param pRandom the random generator
      */
     protected void randomise(final SecureRandom pRandom) {
         Collections.shuffle(theFixtures, pRandom);
     }
 
     /**
      * Set the dates of the fixture.
      * @param pWeekNo the Week Number
      * @param pDate the base date.
      */
     protected void setDates(final Integer pWeekNo,
                             final LocalDate pDate) {
         /* Store the week number */
         setWeekNo(pWeekNo);
 
         /* Determine the First Date */
         LocalDate myDate = pDate.with(DayOfWeek.TUESDAY);
         int mySplit = theFixtures.size() >> 1;
 
         /* Loop through the fixtures */
         int i = 1;
         Iterator<Fixture> myIterator = fixtureIterator();
         while (myIterator.hasNext()) {
             Fixture myCurr = myIterator.next();
 
             /* Set Date and time */
             myCurr.setDate(myDate);
 
             /* If we need to reset */
             if (i++ == mySplit) {
                 /* Shift date */
                 myDate = myDate.plusDays(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 FixtureSet)) {
             return false;
         }
 
         /* Access as fixtureSet */
         FixtureSet myThat = (FixtureSet) pThat;
 
         /* Test on weekNo */
         if (!DataSet.isEqual(getWeekNo(), myThat.getWeekNo())) {
             return false;
         }
 
         /* Test on fixtures */
         return theFixtures.equals(myThat.getFixtures());
     }
 
     @Override
     public int hashCode() {
         return (theFixtures.hashCode() * DataSet.HASH_PRIME)
                + theWeekNo.hashCode();
     }
 
     /**
      * validate the fixtureSet.
      * @param pParticipants the participants
      * @return the status
      */
     protected PoolStatus validate(final PlayerList pParticipants) {
         /* Create name map */
         Map<String, PoolStatus> myMap = new HashMap<String, PoolStatus>();
         theStatus = PoolStatus.VALID;
         int myByeCount = 0;
 
         /* Loop through the fixtures */
         Iterator<Fixture> myIterator = fixtureIterator();
         while (myIterator.hasNext()) {
             Fixture myCurr = myIterator.next();
 
             /* Validate the fixture */
             PoolStatus myStatus = myCurr.validate(pParticipants);
             if (!myStatus.isValid()) {
                 theStatus = PoolStatus.INVALID;
             } else {
                 /* Access players */
                 Player myHome = myCurr.getHomePlayer();
                 Player myAway = myCurr.getAwayPlayer();
 
                 /* Check for preExistence */
                 if (myHome != null) {
                     String myName = myHome.getName();
                     PoolStatus myExisting = myMap.get(myName);
                     myMap.put(myName, myExisting == null
                                                          ? PoolStatus.VALID
                                                          : PoolStatus.DUPLICATE);
                 }
                 if (myAway != null) {
                     String myName = myAway.getName();
                     PoolStatus myExisting = myMap.get(myName);
                     myMap.put(myName, myExisting == null
                                                          ? PoolStatus.VALID
                                                          : PoolStatus.DUPLICATE);
                 }
 
                 /* increment bye count if required */
                 if (myCurr.isBye()) {
                     myByeCount++;
                 }
             }
         }
 
         /* If we are valid */
         if (theStatus.isValid()) {
             /* Check for bad bye count */
             boolean badBye = myByeCount > 1;
 
             /* Loop through the fixtures again */
             myIterator = fixtureIterator();
             while (myIterator.hasNext()) {
                 Fixture myCurr = myIterator.next();
 
                 /* Ignore invalid fixtures */
                 if (!myCurr.getStatus().isValid()) {
                     continue;
                 }
 
                 /* Access players */
                 Player myHome = myCurr.getHomePlayer();
                 Player myAway = myCurr.getAwayPlayer();
 
                 /* Check for duplicate on home player */
                 if (myHome != null) {
                     PoolStatus myStatus = myMap.get(myHome.getName());
                     if (!myStatus.isValid()) {
                         /* Set as duplicate */
                         theStatus = PoolStatus.DUPLICATE;
                         myCurr.setStatus(theStatus);
                     }
                 } else if (badBye) {
                     /* Set as duplicate */
                     theStatus = PoolStatus.DUPLICATE;
                     myCurr.setStatus(theStatus);
                 }
 
                 /* Check for duplicate on away player */
                 if (myAway != null) {
                     PoolStatus myStatus = myMap.get(myAway.getName());
                     if (!myStatus.isValid()) {
                         /* Set as duplicate */
                         theStatus = PoolStatus.DUPLICATE;
                         myCurr.setStatus(theStatus);
                     }
                 } else if (badBye) {
                     /* Set as duplicate */
                     theStatus = PoolStatus.DUPLICATE;
                     myCurr.setStatus(theStatus);
                 }
             }
         }
 
         /* If we are valid */
         if (theStatus.isValid()) {
             /* Check expected fixture count */
             int myNumFixtures = 1 + ((pParticipants.size() - 1) / 2);
             if (myNumFixtures != theFixtures.size()) {
                 theStatus = PoolStatus.INVALID;
             }
         }
 
         /* return the status */
         return theStatus;
     }
 }