/*******************************************************************************
    * 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.util.Comparator;
  
  import javafx.beans.property.ObjectProperty;
  import javafx.beans.property.SimpleObjectProperty;
  
  /**
   * Player Performance Analysis.
   */
  public class PlayerAnalysis
          implements Comparable<PlayerAnalysis> {
      /**
       * The player.
       */
      private final ObjectProperty<Player> thePlayer;
  
      /**
       * Matches played.
       */
      private final ObjectProperty<Integer> theMatchesPlayed;
  
      /**
       * Matches won.
       */
      private final ObjectProperty<Integer> theMatchesWon;
  
      /**
       * Matches lost.
       */
      private final ObjectProperty<Integer> theMatchesLost;
  
      /**
       * Frames won.
       */
      private final ObjectProperty<Integer> theFramesFor;
  
      /**
       * Frames lost.
       */
      private final ObjectProperty<Integer> theFramesAgainst;
  
      /**
       * Frames difference.
       */
      private final ObjectProperty<Integer> theFramesDifference;
  
      /**
       * Points.
       */
      private final ObjectProperty<Integer> thePoints;
  
      /**
       * The tie breaker.
       */
      private final ObjectProperty<Integer> theTieBreaker;
  
      /**
       * Constructor.
       * @param pPlayer the player
       */
      protected PlayerAnalysis(final Player pPlayer) {
          /* Allocate properties */
          thePlayer = new SimpleObjectProperty<Player>(this, AnalysisField.NAME.toString(), pPlayer);
          theMatchesPlayed = new SimpleObjectProperty<Integer>(this, AnalysisField.PLAYED.toString());
          theMatchesWon = new SimpleObjectProperty<Integer>(this, AnalysisField.WON.toString());
          theMatchesLost = new SimpleObjectProperty<Integer>(this, AnalysisField.LOST.toString());
          theFramesFor = new SimpleObjectProperty<Integer>(this, AnalysisField.FOR.toString());
          theFramesAgainst = new SimpleObjectProperty<Integer>(this, AnalysisField.AGAINST.toString());
          theFramesDifference = new SimpleObjectProperty<Integer>(this, AnalysisField.DIFFERENCE.toString());
          thePoints = new SimpleObjectProperty<Integer>(this, AnalysisField.POINTS.toString());
          theTieBreaker = new SimpleObjectProperty<Integer>(this, AnalysisField.TIEBREAK.toString());
  
          /* initialise values */
          reset();
      }
  
      /**
       * Reset.
       */
      protected void reset() {
          /* reset properties */
          theMatchesPlayed.set(0);
         theMatchesWon.set(0);
         theMatchesLost.set(0);
         theFramesFor.set(0);
         theFramesAgainst.set(0);
         theFramesDifference.set(0);
         thePoints.set(0);
         theTieBreaker.set(0);
     }
 
     /**
      * Obtain the player property.
      * @return the player property.
      */
     public ObjectProperty<Player> playerProperty() {
         return thePlayer;
     }
 
     /**
      * Obtain the matches played property.
      * @return the matches played property.
      */
     public ObjectProperty<Integer> playedProperty() {
         return theMatchesPlayed;
     }
 
     /**
      * Obtain the matches won property.
      * @return the matches won property.
      */
     public ObjectProperty<Integer> wonProperty() {
         return theMatchesWon;
     }
 
     /**
      * Obtain the matches lost property.
      * @return the matches lost property.
      */
     public ObjectProperty<Integer> lostProperty() {
         return theMatchesLost;
     }
 
     /**
      * Obtain the frames for property.
      * @return the frames for property.
      */
     public ObjectProperty<Integer> forProperty() {
         return theFramesFor;
     }
 
     /**
      * Obtain the frames against property.
      * @return the frames against property.
      */
     public ObjectProperty<Integer> againstProperty() {
         return theFramesAgainst;
     }
 
     /**
      * Obtain the frames difference property.
      * @return the frames difference property.
      */
     public ObjectProperty<Integer> differenceProperty() {
         return theFramesDifference;
     }
 
     /**
      * Obtain the points property.
      * @return the points property.
      */
     public ObjectProperty<Integer> pointsProperty() {
         return thePoints;
     }
 
     /**
      * Obtain the tie-breaker property.
      * @return the tie-breaker property.
      */
     public ObjectProperty<Integer> tieBreakerProperty() {
         return theTieBreaker;
     }
 
     /**
      * Get Player.
      * @return the player
      */
     public Player getPlayer() {
         return thePlayer.getValue();
     }
 
     /**
      * Get Points.
      * @return the points
      */
     public Integer getPoints() {
         return thePoints.getValue();
     }
 
     /**
      * Get Tie-Breaker.
      * @return the tie-breaker
      */
     protected Integer getTieBreaker() {
         return theTieBreaker.getValue();
     }
 
     /**
      * Get Frames Difference.
      * @return the frame difference
      */
     protected Integer getFramesDifference() {
         return theFramesDifference.getValue();
     }
 
     /**
      * Set Tie-Breaker value.
      * @param pValue the value
      */
     protected void setTieBreaker(final Integer pValue) {
         theTieBreaker.setValue(pValue);
     }
 
     /**
      * Is the player active?
      * @return true/false
      */
     protected boolean isActive() {
         return theMatchesPlayed.getValue() > 0;
     }
 
     /**
      * Analysis Home fixture.
      * @param pFixture the fixture
      */
     protected void analyseHomeFixture(final Fixture pFixture) {
         /* Obtain result */
         Result myResult = pFixture.getResult();
 
         /* If the match has been played */
         if (myResult != null) {
             /* Analyse the result */
             analyseResult(myResult);
         }
     }
 
     /**
      * Analysis Away fixture.
      * @param pFixture the fixture
      */
     protected void analyseAwayFixture(final Fixture pFixture) {
         /* Obtain result */
         Result myResult = pFixture.getResult();
 
         /* If the match has been played */
         if (myResult != null) {
             /* Analyse the result */
             analyseResult(myResult.reverse());
         }
     }
 
     /**
      * Add value.
      * @param pProperty the property
      * @param pValue the value to add
      */
     private void addValue(final ObjectProperty<Integer> pProperty,
                           final Integer pValue) {
         Integer myValue = pProperty.getValue();
         pProperty.set(myValue + pValue);
     }
 
     /**
      * Analysis result.
      * @param pResult the result
      */
     protected void analyseResult(final Result pResult) {
         /* Increment matches played */
         addValue(theMatchesPlayed, 1);
 
         /* Adjust win/loss */
         if (pResult.isWin()) {
             addValue(theMatchesWon, 1);
         } else {
             addValue(theMatchesLost, 1);
         }
 
         /* Adjust frames for/against */
         addValue(theFramesFor, pResult.getFramesFor());
         addValue(theFramesAgainst, pResult.getFramesAgainst());
         addValue(theFramesDifference, pResult.getFramesDifference());
 
         /* Adjust points */
         addValue(thePoints, pResult.getPoints());
     }
 
     @Override
     public boolean equals(final Object pThat) {
         /* Handle trivial cases */
         if (pThat == this) {
             return true;
         }
         if (pThat == null) {
             return false;
         }
 
         /* Check for class */
         if (!(pThat instanceof PlayerAnalysis)) {
             return false;
         }
 
         /* Access as PlayerAnalysis */
         PlayerAnalysis myThat = (PlayerAnalysis) pThat;
 
         /* Check fields */
         return thePlayer.getValue().equals(myThat.thePlayer.getValue());
     }
 
     @Override
     public int hashCode() {
         return thePlayer.getValue().hashCode();
     }
 
     @Override
     public int compareTo(final PlayerAnalysis pThat) {
         /* Compare points */
         int myResult = tieBreakCompareTo(pThat);
         if (myResult != 0) {
             return myResult;
         }
 
         /* Just compare players */
         return getPlayer().compareTo(pThat.getPlayer());
     }
 
     /**
      * Compare for tieBreaks.
      * @param pThat the object to compare to
      * @return -1,0,1 as this object is less than, equal or greater than the passed object
      */
     protected int tieBreakCompareTo(final PlayerAnalysis pThat) {
         /* Compare points */
         int myResult = pThat.getPoints() - getPoints();
         if (myResult != 0) {
             return myResult;
         }
 
         /* Compare tie-breaker */
         myResult = getTieBreaker() - pThat.getTieBreaker();
         if (myResult != 0) {
             return myResult;
         }
 
         /* Compare frames difference */
         return pThat.getFramesDifference() - getFramesDifference();
     }
 
     /**
      * Comparator class.
      */
     protected static final class AnalysisComparator
             implements Comparator<PlayerAnalysis> {
         @Override
         public int compare(final PlayerAnalysis pFirst,
                            final PlayerAnalysis pSecond) {
             return pFirst.compareTo(pSecond);
         }
     }
 
     /**
      * Analysis fields.
      */
     public enum AnalysisField {
         /**
          * Name.
          */
         NAME("Name"),
 
         /**
          * Played.
          */
         PLAYED("P"),
 
         /**
          * Won.
          */
         WON("W"),
 
         /**
          * Lost.
          */
         LOST("L"),
 
         /**
          * For.
          */
         FOR("F"),
 
         /**
          * Lost.
          */
         AGAINST("A"),
 
         /**
          * Difference.
          */
         DIFFERENCE("D"),
 
         /**
          * TieBreak.
          */
         TIEBREAK("T"),
 
         /**
          * Points.
          */
         POINTS("Pts");
 
         /**
          * The Short name.
          */
         private final String theShortName;
 
         /**
          * The String name.
          */
         private String theName;
 
         /**
          * Constructor.
          * @param pShort the short name
          */
         private AnalysisField(final String pShort) {
             theShortName = pShort;
         }
 
         /**
          * Obtain the short name.
          * @return the short name
          */
         public String getShortName() {
             return theShortName;
         }
 
         @Override
         public String toString() {
             /* If we have not yet loaded the name */
             if (theName == null) {
                 /* Load the name */
                 theName = DataResource.getKeyForAnalysisField(this).getValue();
             }
 
             /* return the name */
             return theName;
         }
     }
 }