Fixture

/*******************************************************************************
 * 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 javafx.beans.property.ObjectProperty;
import javafx.beans.property.SimpleObjectProperty;
import net.sourceforge.jhunters.pool.PoolStatus;

/**
 * Individual Fixture.
 */
public class Fixture {
    /**
     * Fixture Name.
     */
    protected static final String OBJECT_NAME = DataResource.FIXTURE_NAME.getValue();

    /**
     * Null indication.
     */
    public static final String NULL = DataResource.FIXTURE_NULL.getValue();

    /**
     * Versus indication.
     */
    public static final String MATCH_VERSUS = DataResource.FIXTURE_VERSUS.getValue();

    /**
     * Blank character.
     */
    private static final char CHAR_BLANK = ' ';

    /**
     * Open bracket character.
     */
    private static final char CHAR_OPEN = '(';

    /**
     * Close bracket character.
     */
    private static final char CHAR_CLOSE = ')';

    /**
     * Date of fixture.
     */
    private final ObjectProperty<LocalDate> theDate;

    /**
     * Home Player.
     */
    private final ObjectProperty<Player> theHomePlayer;

    /**
     * Away Player.
     */
    private final ObjectProperty<Player> theAwayPlayer;

    /**
     * Result of fixture.
     */
    private final ObjectProperty<Result> theResult;

    /**
     * New Date of fixture.
     */
    private final ObjectProperty<LocalDate> theNewDate;

    /**
     * Fixture Status.
     */
    private final ObjectProperty<PoolStatus> theStatus;

    /**
     * Constructor.
     */
    public Fixture() {
        /* Allocate properties */
        theDate = new SimpleObjectProperty<LocalDate>(this, FixtureField.DATE.toString());
        theHomePlayer = new SimpleObjectProperty<Player>(this, FixtureField.HOME.toString());
        theAwayPlayer = new SimpleObjectProperty<Player>(this, FixtureField.AWAY.toString());
        theResult = new SimpleObjectProperty<Result>(this, FixtureField.RESULT.toString());
        theNewDate = new SimpleObjectProperty<LocalDate>(this, FixtureField.NEWDATE.toString());
        theStatus = new SimpleObjectProperty<PoolStatus>(this, FixtureField.STATUS.toString());
    }

    @Override
    public String toString() {
        /* Access details */
        LocalDate myDate = getDate();
        LocalDate myNewDate = getNewDate();
        Player myHome = getHomePlayer();
        Player myAway = getAwayPlayer();
        Result myResult = getResult();

        /* build display string */
        StringBuilder myBuilder = new StringBuilder();
        myBuilder.append(myDate == null
                                       ? NULL
                                       : DataParser.formatDate(myDate));
        myBuilder.append(CHAR_BLANK);
        myBuilder.append(myHome == null
                                       ? Player.PLAYER_BYE
                                       : myHome);
        myBuilder.append(CHAR_BLANK);
        myBuilder.append(myResult == null
                                         ? MATCH_VERSUS
                                         : myResult);
        myBuilder.append(CHAR_BLANK);
        myBuilder.append(myAway == null
                                       ? Player.PLAYER_BYE
                                       : myAway);
        if (myNewDate != null) {
            myBuilder.append(CHAR_BLANK);
            myBuilder.append(CHAR_OPEN);
            myBuilder.append(DataParser.formatDate(myNewDate));
            myBuilder.append(CHAR_CLOSE);
        }
        return myBuilder.toString();
    }

    /**
     * Set named property.
     * @param pPlayers the player list.
     * @param pName the name of the property.
     * @param pValue the value of the property.
     */
    protected void setNamedProperty(final PlayerList pPlayers,
                                    final String pName,
                                    final String pValue) {
        if (pName.equals(FixtureField.HOME.toString())) {
            setHomePlayer(pPlayers.getNamedPlayer(pValue));
        } else if (pName.equals(FixtureField.AWAY.toString())) {
            setAwayPlayer(pPlayers.getNamedPlayer(pValue));
        } else if (pName.equals(FixtureField.DATE.toString())) {
            setDate(DataParser.parseDate(pValue));
        } else if (pName.equals(FixtureField.NEWDATE.toString())) {
            setNewDate(DataParser.parseDate(pValue));
        } else if (pName.equals(FixtureField.RESULT.toString())) {
            setResult(DataParser.parseResult(pValue));
        }
    }

    /**
     * Obtain the date property.
     * @return the date property.
     */
    public ObjectProperty<LocalDate> dateProperty() {
        return theDate;
    }

    /**
     * Obtain the new date property.
     * @return the new date property.
     */
    public ObjectProperty<LocalDate> newDateProperty() {
        return theNewDate;
    }

    /**
     * Obtain the homePlayer property.
     * @return the homePlayer property.
     */
    public ObjectProperty<Player> homePlayerProperty() {
        return theHomePlayer;
    }

    /**
     * Obtain the awayPlayer property.
     * @return the away player property.
     */
    public ObjectProperty<Player> awayPlayerProperty() {
        return theAwayPlayer;
    }

    /**
     * Obtain the result property.
     * @return the result property.
     */
    public ObjectProperty<Result> resultProperty() {
        return theResult;
    }

    /**
     * Obtain the status property.
     * @return the status.
     */
    public ObjectProperty<PoolStatus> statusProperty() {
        return theStatus;
    }

    /**
     * Obtain the date.
     * @return the date.
     */
    protected LocalDate getDate() {
        return theDate.getValue();
    }

    /**
     * Obtain the new date.
     * @return the new date.
     */
    private LocalDate getNewDate() {
        return theNewDate.getValue();
    }

    /**
     * Obtain the planned date.
     * @return the planned date.
     */
    protected LocalDate getPlannedDate() {
        LocalDate myDate = getNewDate();
        return myDate == null
                             ? getDate()
                             : myDate;
    }

    /**
     * Obtain the homePlayer.
     * @return the home player.
     */
    public Player getHomePlayer() {
        return theHomePlayer.getValue();
    }

    /**
     * Obtain the awayPlayer.
     * @return the away player.
     */
    public Player getAwayPlayer() {
        return theAwayPlayer.getValue();
    }

    /**
     * Obtain the result.
     * @return the result.
     */
    public Result getResult() {
        return theResult.getValue();
    }

    /**
     * Obtain the status.
     * @return the status.
     */
    public PoolStatus getStatus() {
        return theStatus.getValue();
    }

    /**
     * Is this a bye?
     * @return true/false.
     */
    public boolean isBye() {
        return getHomePlayer() == null || getAwayPlayer() == null;
    }

    /**
     * Set the date.
     * @param pDate the date.
     */
    protected void setDate(final LocalDate pDate) {
        theDate.setValue(pDate);
    }

    /**
     * Set the new date.
     * @param pDate the new date.
     */
    private void setNewDate(final LocalDate pDate) {
        theNewDate.setValue(pDate);
    }

    /**
     * Set the homePlayer.
     * @param pPlayer the player.
     */
    protected void setHomePlayer(final Player pPlayer) {
        theHomePlayer.setValue(pPlayer);
    }

    /**
     * Set the awayPlayer.
     * @param pPlayer the player.
     */
    protected void setAwayPlayer(final Player pPlayer) {
        theAwayPlayer.setValue(pPlayer);
    }

    /**
     * Set the result.
     * @param pResult the result.
     */
    public void setResult(final Result pResult) {
        theResult.setValue(pResult);
    }

    /**
     * Set the status.
     * @param pStatus the status.
     */
    protected void setStatus(final PoolStatus pStatus) {
        theStatus.setValue(pStatus);
    }

    /**
     * Set Bye player.
     * @param pPlayer the final player
     */
    protected void setByePlayer(final Player pPlayer) {
        /* If home player is bye */
        if (getHomePlayer() == null) {
            setHomePlayer(pPlayer);
        } else {
            setAwayPlayer(pPlayer);
        }
    }

    @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 Fixture)) {
            return false;
        }

        /* Access as fixture */
        Fixture myThat = (Fixture) pThat;

        /* Test on dates */
        if (!DataSet.isEqual(getDate(), myThat.getDate())) {
            return false;
        }
        if (!DataSet.isEqual(getNewDate(), myThat.getNewDate())) {
            return false;
        }

        /* Test on players */
        if (!DataSet.isEqual(getHomePlayer(), myThat.getHomePlayer())) {
            return false;
        }
        if (!DataSet.isEqual(getAwayPlayer(), myThat.getAwayPlayer())) {
            return false;
        }

        /* Test on result */
        return DataSet.isEqual(getResult(), myThat.getResult());
    }

    @Override
    public int hashCode() {
        int myHash = (theDate.hashCode() * DataSet.HASH_PRIME)
                + theNewDate.hashCode();
        myHash = (myHash * DataSet.HASH_PRIME)
                + theHomePlayer.hashCode();
        myHash = (myHash * DataSet.HASH_PRIME)
                + theAwayPlayer.hashCode();
        return (myHash * DataSet.HASH_PRIME)
                + theResult.hashCode();
    }

    /**
     * validate the fixture.
     * @param pParticipants the player list
     * @return the status
     */
    protected PoolStatus validate(final PlayerList pParticipants) {
        /* Must have date */
        LocalDate myDate = getDate();
        PoolStatus myStatus = (myDate == null)
                                              ? PoolStatus.INVALID
                                              : PoolStatus.VALID;

        /* If we are valid */
        if (myStatus.isValid()) {
            Player myHome = getHomePlayer();
            Player myAway = getAwayPlayer();

            /* Check home player is one of the participants */
            if ((myHome != null)
                    && (pParticipants.getNamedPlayer(myHome.getName()) == null)) {
                myStatus = PoolStatus.INVALID;
            }

            /* Check away player is one of the participants */
            if ((myAway != null)
                    && (pParticipants.getNamedPlayer(myAway.getName()) == null)) {
                myStatus = PoolStatus.INVALID;
            }

            /* Check that we do not have a double bye */
            if ((myHome == null) && (myAway == null)) {
                myStatus = PoolStatus.INVALID;
            }
        }

        setStatus(myStatus);
        return myStatus;
    }

    /**
     * Fixture fields.
     */
    public enum FixtureField {
        /**
         * Name.
         */
        DATE,

        /**
         * Home player.
         */
        HOME,

        /**
         * Away Player.
         */
        AWAY,

        /**
         * Result.
         */
        RESULT,

        /**
         * NewDate.
         */
        NEWDATE,

        /**
         * Status.
         */
        STATUS;

        /**
         * The String name.
         */
        private String theName;

        @Override
        public String toString() {
            /* If we have not yet loaded the name */
            if (theName == null) {
                /* Load the name */
                theName = DataResource.getKeyForFixtureField(this).getValue();
            }

            /* return the name */
            return theName;
        }
    }
}