/* *********************
 *
 *   GolferScore - represents one player's score on an 18 hole golf course.
 *
 *   Author:   Shawn Brenneman and YOUR NAME
 *   Date:     2019-Apr 6
 *
 ***********************/
public class GolferScore {

//  instance data: 
    private final int NUM_HOLES = 18;
    private int[] par;
    private int[] score;
    private String golfer;
    private String courseName;

//  a contstructor which takes a golfer's name, a course name, and an array
//  containing the par for each hole (integers)
    public GolferScore(String golfer, String course, int[] parForEachHole){
        this.golfer = golfer;
        courseName = course;
        par = parForEachHole;
        score = new int[NUM_HOLES];
    }

//  ADD THIS METHOD -------------------------------------------------------
//  Overload the constructor to take an array of scores as well as
//  golfer's name, course name, and pars array



//  getters
    public String getGolfer() {
        return golfer;
    }
    public String getCourseName () {
        return courseName;
    }
    public int[] getPar() {
        return par;
    }
    public int[] getScore() {
        return score;
    }
    
//  ADD THIS METHOD -------------------------------------------------------
//  compareTo - compares totalCourseScore for two players



//  setScore - takes a holeNumber and a golfer's score for that hole, 
//             and sets it in the score array
    public void setScore(int holeNum, int strokes) {
        if (holeNum >0 && holeNum <= NUM_HOLES) {
            score[holeNum-1] = strokes;
        }
    }
    private int totalFrontNine() {
        int sum=0;

        for (int i=0; i<9; i++) {
            sum += score[i];
        }
        return sum;
    }
    private int parFrontNine() {
        int parSum = 0;
        for(int i=0; i<9; i++) {
            parSum += par[i];
        }
        return parSum; 
    }
    private int totalBackNine() {
        int sum=0;

        for (int i=9; i<NUM_HOLES; i++) {
            sum += score[i];
        }
        return sum;
    }
    private int parBackNine() {
        int parSum = 0;
        for(int i=9; i<NUM_HOLES; i++) {
            parSum += par[i];;
        }
        return parSum; 
    }
//  totalCoursePar - returns the total par for the course
    public int totalCoursePar() {
        return parFrontNine() + parBackNine();
    }
//  totalCourseScore - returns the total score for the course
    public int totalCourseScore() {
        return totalFrontNine() + totalBackNine();
    }
    private int scoreSum() {
        int strokeSum=0;
        for(int i=0; i<score.length; i++) {
            if (score[i] > 0) {
                strokeSum += score[i];
            }
        }
        return strokeSum; 
    }
//  parSumOfHolesPlayed - returns the total of par for holes that have been played
    public int parSumOfHolesPlayed() {
        int parSum=0;
        for(int i=0; i<score.length; i++) {
            if (score[i] > 0) {
                parSum += par[i];
            }
        }
        return parSum;
    }
//  isOverPar - answers if the total score of holes played so far is over par
    public boolean isOverPar() {
        return (scoreSum() > parSumOfHolesPlayed());
    }
//  isUnderPar - answers if the total score of holes played so far is under par
    public boolean isUnderPar() {
        return (scoreSum() < parSumOfHolesPlayed());
    }
//  isUnderPar - answers if the total score of holes played so far is the same as par
    public boolean isPar() {
        return (scoreSum() == parSumOfHolesPlayed());
    }
//  isOverPar - answers if the score for the given hole number is over par
//  NOTE: this is an overloaded method.  it takes a parameter, unlike the
//        previous isOverPar method. Also, this method checks to see if the 
//        given hole number is valid, otherwise, the method returns false.
//        This note applies to the next two methods as well.
    public boolean isOverPar(int holeNum) {
        boolean result = false;
        if (holeNum > 0 && holeNum <= 18) {
            result = (score[holeNum-1] > par[holeNum-1]);
        }
        return result; 
    }
//  isUnderPar - answers if the score for the given hole number is under par
//  NOTE: if a score is zero, it means the hole has not been played yet.
//        In that case, this method should return false.
    public boolean isUnderPar(int holeNum) {
        boolean result = false;
        if (holeNum > 0 && holeNum <= 18 && score[holeNum-1] != 0) {
            result = (score[holeNum-1] < par[holeNum-1]);
        }
        return result; 
    }
//  isPar - answers if the score for the given hole number is par
    public boolean isPar(int holeNum) {
        boolean result = false;
        if (holeNum > 0 && holeNum <= 18) {
            result = (score[holeNum-1] == par[holeNum-1]);
        }
        return result; 
    }
//  numHolesUnderPar - returns the number of holes played that are under par
//  NOTE: if a score is zero, that means the hole has not yet been played 
//        and should not be counted as under par.
    public int numHolesUnderPar() {
        int cnt=0; 
        for(int i=1; i<=NUM_HOLES; i++) {
            if (isUnderPar(i)){
                cnt++;
            }
        } 
        return cnt;
    }
//  numHolesOverPar - returns the number of holes played that are over par
    public int numHolesOverPar() {
        int cnt=0; 
        for(int i=1; i<=NUM_HOLES; i++) {
            if (isOverPar(i)){
                cnt++;
            }
        } 
        return cnt;
    }
//  numHolesPar - returns the number of holes played that are par
    public int numHolesPar() {
        int cnt=0; 
        for(int i=1; i<=NUM_HOLES; i++) {
            if (isPar(i)){
                cnt++;
            }
        } 
        return cnt;
    }
//  numBirdies - returns the number of holes played that are birdies
//  NOTE: a birdie is one under par. 
    public int numBirdies() {
        int cnt=0; 
        for(int i=0; i<par.length; i++) {
            if (score[i] + 1 == par[i]){
                cnt++;
            }
        } 
        return cnt;
    }
//  numBogeys - returns the number of holes played that are bogeys
//  NOTE: a bogey is one over par.
    public int numBogeys() {
        int cnt=0; 
        for(int i=0; i<par.length; i++) {
            if (score[i] - 1 == par[i]){
                cnt++;
            }
        } 
        return cnt;
    }
//  toString - returns a String representation of a Golf scorecard,
//             including the golfer's name, the course name, and a
//             table of hole number, par for each hole, score for each hole,
//             and totals for the whole course. A message, appropriate to
//             the total course score, says "Par", "x over Par", or 
//             "x under Par", where x is the correct number.
    public String toString() {
        String str = "\n";
        str += golfer +"'s score on " + courseName + "\n";
        str += "Hole:\t";
        for (int i=1; i<9; i++) {
            str += i + "  ";
        }
        for (int i=9; i<=NUM_HOLES; i++) {
            str += i + " ";
        } 
        str += "\tTotal";
        str += "\nPar:\t";
        for (int p:par) {
            str += p + "  ";
        }
        str += "\t   " + (parSumOfHolesPlayed() < 10?" ":"") + parSumOfHolesPlayed();
        str += "\nScore:\t";
        for (int s:score) {
            str += (s==0?"-":s) + "  ";
        }
        str += "\t   " + (totalCourseScore()<10?" ":"") + totalCourseScore();
        if (parSumOfHolesPlayed() == totalCourseScore()) {
            str += "  Par";        
        } else if (parSumOfHolesPlayed() > totalCourseScore()) {
            int diff = parSumOfHolesPlayed() - totalCourseScore();
            str += "  " + diff + " under Par";
        } else {
            int diff = totalCourseScore() - parSumOfHolesPlayed();
            str += "  " + diff + " over Par";
        }
        str += "\n";
        
        return str;
    }
}