import java.io.*;
/**
 * GolfPool is an application to find the winner of a golf pool.
 *
 * @author  J. Dalbey
 * @version 0.1
 */
public final class GolfPool
{

    /**
     *  Entry point for the application.  Read the data file
     *  name from the command line.
     *  
     *  @param args command line arguments, first argument is 
     *  name of data file.
     */
    public static void main(String[] args)
    {
        // Create instance of GolfPool
        GolfPool app = new GolfPool();
        // IF no argument given THEN
        if (args.length == 0)
        {
            // PRINT missing data file message
            System.out.println("Please provide the name of the golf scores file.");
        }
        // ELSE
        else
        {
            // CALL run with filename
            app.run(args[0]);
        } // END IF        
    }

    /** Read data file and compute winner and display results.
    @param filename the name of the data file to be processed
     */
    public void run(String filename)
    {
        // OPEN File for filename
        File datafile = new File(filename);
        Reader rdr = null;
        // TRY
        try
        {
            // CREATE Reader from File
            rdr = new FileReader(datafile);

            // CALL readGolfScores with Reader
            AverageList averages = new AverageList();
            averages.readGolfScores(rdr);
            // IF doesWinnerExist THEN
            if (averages.doesWinnerExist())
            {
                // CALL computeAverages
                averages.computeAverages();
                // CALL determineWinner
                averages.determineWinner();
                // CALL getWinner
                Golfer winner = averages.getWinner();
                // PRINT winner's name, average, rounds
                System.out.println("Winning golfer: " + winner.name);
                System.out.println("Average score: " + winner.getAverage());
                System.out.println("Number of rounds: " + winner.getRounds());
            }
            // ELSE
            else
            {
                // PRINT no eligible winner
                System.out.println("No eligible winner");
            } // END IF        
        }
        // CATCH File not found
        catch (FileNotFoundException ex)
        {
            // PRINT incorrect filename message
            System.out.println("Sorry, a file named " + filename +
                " could not be found in the current directory. " +
                " Check the spelling and try again.");
        } // END TRY
    }
}
import java.util.*;
import java.io.*;
/**
 * AverageList is a list of golfers and their average score for
 * all rounds played.
 *
 * @author  J. Dalbey
 * @version 0.1
 */
public final class AverageList
{
    List<Golfer> list = new ArrayList<Golfer>();
    Golfer winner;
    /**
     * Constructor for objects of class AverageList
     */
    public AverageList()
    {
    }

    /** Read golf scores from specified Reader, and accumulate
     * the total for each golfer.  Also count the number of scores read
     * for each golfer.
     * @param rdr Reader from which scores will be obtained
     */
    public void readGolfScores(Reader rdr)
    {
        // CREATE scanner from rdr
        Scanner scan = new Scanner(rdr);
        // WHILE scanner has more lines LOOP
        while (scan.hasNextLine())
        {
            // READ next line from scanner
            String line = scan.nextLine();
            // SPLIT line into fields using ; as delimiter
            String[] splitLine = line.split(";");
            // CREATE a golfer from first field
            Golfer golfer = new Golfer(splitLine[0]);
            int score = Integer.parseInt(splitLine[2]);
            // IF list doesn't contain golfer THEN
            if (!list.contains(golfer))
            {
                // CALL addScore with third field
                golfer.addScore(score);
                // ADD golfer to list
                list.add(golfer);
            }
            // ELSE
            else
            {
                // Get golfer from list
                int index = list.indexOf(golfer);
                golfer = list.get(index);
                // CALL addScore with third field
                golfer.addScore(score);
            } // ENDIF    
        }// END LOOP            
    }

    /** Calculate average for each golfer
     */
    public void computeAverages()
    {
        // FOR each golfer in list LOOP
        for (Golfer golfer: list)
        {
            // CALL calculateAverage
            golfer.calculateAverage();
        } // END LOOP            
    }

    /** Find lowest average in the list.
     * Assumes computerAverages() has been called.
     */
    public void determineWinner()
    {
        // SET winner to a golfer with average of infinity
        winner = new Golfer("");
        winner.addScore(Integer.MAX_VALUE);
        winner.calculateAverage();
        // FOR each golfer in list LOOP
        for (Golfer golfer: list)
        {
            // IF golfer >= 3 rounds THEN
            if (golfer.getRounds() >= 3)
            {
                // compare golfer to winner
                // IF golfer < winner THEN
                if (golfer.compareTo(winner) < 0)
                {
                    // SET winner to golfer
                    winner = golfer;
                } // END IF
            } // END IF
        } // END LOOP        
    }

    /** Return the winning golfer.
     * Assumes doesWinnerExist is true
     * Assumes determineWinner has been called.
     * @return golfer who won
     */
    public Golfer getWinner()
    {
        return winner;
    }

    /** Determine if there is an eligible winner.
     * @return false if no golfer has played three rounds, true otherwise
     */
    public boolean doesWinnerExist()
    {
        // SET result to false
        boolean result = false;
        // FOR each golfer in list LOOP
        for (Golfer golfer: list)
        {
            // IF golfer >= 3 rounds THEN
            if (golfer.getRounds() >= 3)
            {
                // SET result to true
                result = true;
            } // END IF
        } // END LOOP
        // return result;        
        return result;
    }

    /** For unit testing: accessor to list size */
    int size()
    {
        return list.size();
    }
}

/**
 * Golfer is a record of the statistics for a golfer for a month.
 *
 * @author  J. Dalbey
 * @version 0.1
 */
public final class Golfer implements Comparable<Golfer>
{
    final String name;
    private int numberRounds;
    private long totalScore;
    private double averageScore;

    /**
     * Constructor for objects of class Golfer
     */
    public Golfer(String name)
    {
        this.name = name;
    }

    /**
     * Add one score to total
     * @param roundScore the score to be added to the total
     * @pre roundScore > 0
     */
    public void addScore(int roundScore)
    {    
        // Increment totalScore by roundScore
        totalScore += roundScore;
        // Increment numberRounds by 1   
        numberRounds += 1;
    }

    /**
     * Calculate average score.
     * @pre addScore has been called at least once.
     */
    public void calculateAverage()
    {
        // Compute averageScore as totalScore / numberRounds        
        averageScore = (double) totalScore / numberRounds;
    }

    /**
     * Compare two golfers.  Lowest average wins, 
     * ties go to player with most rounds.
     * @param other golfer to be compared to this one.
     * @return 0 if the two golfers are equal, -1 if this golfer is smaller, 
     * +1 if this golfer is larger.
     */
    public int compareTo(Golfer other)
    {
        // SET result to 0
        int result = 0;
        // IF averageScore < other's THEN
        if (averageScore < other.averageScore)
        {
            // SET result to -1
            result = -1;
        }
        // ELSE
        else
        {
            // IF averageScore > other's THEN
            if (averageScore > other.averageScore)
            {
                // SET result to 1
                result = 1;
            }
            // ELSE
            else
            {                
                // IF numberRounds > other's THEN
                if (numberRounds > other.numberRounds)
                {
                    // SET result to -1; he's the winner
                    result = -1;
                }
                // ELSE
                else
                {
                    // IF numberRounds > other's THEN
                    if (numberRounds < other.numberRounds)
                    {
                        // SET result to 1
                        result = 1;
                    }// ENDIF
                }// ENDIF
            }// ENDIF
        }// ENDIF
        // RETURN result        
        return result;
    }

    /** Accessors */
    public int getRounds()
    {
        return numberRounds;
    }

    public double getAverage()
    {
        return averageScore;
    }

    /** Compare two golfers for equality.  
     * @return true if they have the same name.
     */
    @Override
    public boolean equals(Object aThat)
    {
        if ( this == aThat ) return true;
        if ( !(aThat instanceof Golfer) ) return false;
        Golfer that = (Golfer)aThat;
        return this.name.equals(that.name);
    }
}