/*
 *   Intro to Programming CSE 1310
 * University of Texas at Arlington
 */

package example1feb18whatcoins;

import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

/** What Coins Do You Have.
 * You will ask the user to tell you how much total change 
 * (in .01, .05, .10, and .25 US coins only) that they 
 * have with them and how many coins they have total to 
 * make up that amount of change.  Your program will then 
 * calculate a set of coins that could make up that amount 
 * of change.  The user can then input whether the program 
 * guessed right or wrong.  If the program guessed correctly, 
 * then the program ends.  If the program guessed incorrectly, 
 * then the program should go back and calculate a different 
 * set of coins that would make that same amount of change.  
 * Continue until either the program guesses correctly or 
 * the program cannot calculate a new set of coins.
 * @author jcmtiernan
 */
public class Example1Feb18WhatCoins 
{

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) 
    {
        double change = 0;
        int coins = 0;
        final double nickel = 5; // all calculations done in cents
        final double dime = 10;
        final double penny = 1;
        final double quarter = 25; 
        int numPennies = 0;     // number of pennies guessed                  
        int numNickels = 0;     // number of nickels
        int numDimes = 0;       // number of dimes
        int numQuarters = 0;    // number of quarters guessed
        
        int maxPennies = -1;     // number of pennies that could be in change amount                 
        int maxNickels = -1;     // number of nickels
        int maxDimes = -1;       // number of dimes
        int maxQuarters = -1;    // number of quarters  
        
        double checkChange = 0;    // change in current guess
        int checkCoins = 0;
        boolean guessed = false;
        // boolean failed = false;
        // boolean split = false;
        // boolean join = false;
        // int currCoinToMod = 4;      // 4 = quarters, 3 = dimes, 2 = nickels, 1 = pennies
        // int guessNumber = 0;

        Scanner input = new Scanner(System.in);    // Use Level.INFO to see logger output
        Logger.getGlobal().setLevel(Level.OFF);    // Use Level.OFF to turn off        
        /*
         * You will ask the user to tell you how much total change 
         * (in .01, .05, .10, and .25 US coins only) that they 
         * have with them and how many coins they have total to 
         * make up that amount of change.
        */
        System.out.println("I'm going to try to guess what combination of coins you have in your pocket (or purse or sofa cushion)");
        System.out.print("\nWhat is the total sum of all the coins you have? \n"
                + "Please enter as a dollar and cents amount, i.e. $dd.cc \n"
                + "Amount of change : $");
        change = input.nextDouble() * 100;
        Logger.getGlobal().info("The user entered "+change+" in change.\n");        
        System.out.print("\nWhat is the total number of coins you have? ");
        coins = input.nextInt();
        Logger.getGlobal().info("The user entered "+coins+" coins.\n\n");         

        
        // Calculate a set of coins that could make up that amount of change.
        //  Loop here
        
        /***  Dr. T's First try -- bad planning; done in bits and pieces
         *    Did not have an overall algorithm; and it didn't work
         * 
         * 
        // Find the largest # of quarters in the change amount
        // Remove that much value from change
        while (!guessed && !failed)
        {
            numQuarters = (int) (change / quarter);
            remChange = change - (numQuarters * quarter);
            Logger.getGlobal().info("Removing "+numQuarters+" quarters leaving "
                    + remChange +" in change.\n");
            numDimes = (int) (remChange / dime);
            remChange = remChange - (numDimes * dime);
            Logger.getGlobal().info("Removing "+numDimes+" dimes leaving "
                    + remChange +" in change.\n");        
            numNickels = (int) (remChange / nickel);
            remChange = remChange - (numNickels * nickel);
            Logger.getGlobal().info("Removing "+numNickels+" nickels leaving "
                    + remChange +" in change.\n");         
            numPennies = (int) (remChange / penny);
            remChange = remChange - (numPennies * penny);
            Logger.getGlobal().info("Removing "+numPennies+" pennies leaving "
                    + remChange +" in change.\n");   
            numCoins = numPennies + numNickels + numDimes + numQuarters;
            guessNumber++;

            split = false;
            join = false;
            if (numCoins == coins)
            {
                guessed = checkGuess(numQuarters, numDimes, numNickels, numPennies);
                // section to make new guesses
                // start by only modifying smallest coins
            }
            
            prevQuarters = numQuarters;
            prevDimes = numDimes;
            prevNickels = numNickels;
            prevPennies = numPennies;
            currCoinToMod--;
            if (numCoins > coins)
            {
                join = true;
            }
            else if (numCoins < coins)
            {
                split = true;
            }
            
            
            if (!guessed)
            {
                if (currCoinToMod == 1 && numNickels >= 1 && split)
                {
                    numNickels--;
                    numPennies += 5;
                    numCoins = numPennies + numNickels + numDimes + numQuarters;
                    Logger.getGlobal().info("currCoinToMod is "+currCoinToMod+" with "
                            + numQuarters+" quarters, "+numDimes+" dimes, "
                            + numNickels + " nickels, and "+numPennies+" pennies.");
                    if (numPennies < 1)
                        currCoinToMod--;                     
                }
                else if (currCoinToMod == 2 && numDimes >= 1 && split)
                {
                    numDimes--;
                    numNickels += 2;
                    numCoins = numPennies + numNickels + numDimes + numQuarters;
                    Logger.getGlobal().info("currCoinToMod is "+currCoinToMod+" with "
                            + numQuarters+" quarters, "+numDimes+" dimes, "
                            + numNickels + " nickels, and "+numPennies+" pennies.");  
                    if (numDimes < 1)
                        currCoinToMod--;                     
                }  
                else if (currCoinToMod == 3 && numQuarters >= 1 && split)
                {
                    numQuarters--;
                    numNickels += 1;
                    numDimes += 2;
                    numCoins = numPennies + numNickels + numDimes + numQuarters;
                    Logger.getGlobal().info("currCoinToMod is "+currCoinToMod+" with "
                            + numQuarters+" quarters, "+numDimes+" dimes, "
                            + numNickels + " nickels, and "+numPennies+" pennies."); 
                    if (numQuarters < 1)
                        currCoinToMod--;                    
                } 
                
                if (currCoinToMod == 2 && numDimes >= 2 && numNickels >= 1 && join)
                {
                    numDimes = numDimes - 2;
                    numNickels -= 1;
                    numQuarters++;
                    numCoins = numPennies + numNickels + numDimes + numQuarters;
                    Logger.getGlobal().info("currCoinToMod is "+currCoinToMod+" with "
                            + numQuarters+" quarters, "+numDimes+" dimes, "
                            + numNickels + " nickels, and "+numPennies+" pennies.");   
                    if (numDimes < 1)
                        currCoinToMod++;                    
                }  
                else if (currCoinToMod == 1 && numNickels >= 2 && join)
                {
                    numNickels -= 2;
                    numDimes += 1;
                    numCoins = numPennies + numNickels + numDimes + numQuarters;
                    Logger.getGlobal().info("currCoinToMod is "+currCoinToMod+" with "
                            + numQuarters+" quarters, "+numDimes+" dimes, "
                            + numNickels + " nickels, and "+numPennies+" pennies.");
                    if (numNickels < 1)
                        currCoinToMod++;
                }
                else if (currCoinToMod == 0 && numPennies >= 5 && join)
                {
                    numPennies -= 5;
                    numNickels += 1;
                    numCoins = numPennies + numNickels + numDimes + numQuarters;
                    Logger.getGlobal().info("currCoinToMod is "+currCoinToMod+" with "
                            + numQuarters+" quarters, "+numDimes+" dimes, "
                            + numNickels + " nickels, and "+numPennies+" pennies.");
                    if (numPennies < 5)
                        currCoinToMod++;
                }                
                
                
                if ((numNickels == 0 && currCoinToMod == 1) ||
                   (numDimes == 0 && currCoinToMod == 2) ||
                   (numQuarters == 0 && currCoinToMod == 3))
                {
                    currCoinToMod--;
                    Logger.getGlobal().info("Decrementing currCoinToMod to"+currCoinToMod);
                }
                
                if ((currCoinToMod < 0) || (currCoinToMod > 4)) 
                {
                    failed = true;
                    System.out.println("I cannot determine your coins.");
                }
            }
        
        }
        End of first try ***/
        
        /****  Second try
         *  After reflection, new approach
            Brute force approach with following algorithm:
            Calculate the maximum amount of each kind of coin that could 
                be in the final amount
            Use the maxs as the limit of a set of loops where we iterate
                through each kind of coin and have a flag for success
                Inside the inner loop, check to see if the total value and the
                    total count match the given value and count
                If yes, ask the user if this is their combo
                    If yes, flag as successful
                Else continue the loop
            At end of loops, if the success flag was not set, 
                give message to user
        */  
        
        // change and coins are the values user gave
        maxQuarters = (int) (change / quarter); // max # of quarters in amount given
        maxDimes = (int) (change / dime);
        maxNickels = (int) (change / nickel);
        maxPennies = (int) (change / penny);
        
        for (numQuarters = 0; numQuarters <= maxQuarters && !guessed; numQuarters++ )
            for (numDimes = 0; numDimes <= maxDimes && !guessed; numDimes++ )
                for (numNickels = 0; numNickels <= maxNickels && !guessed; numNickels++ )
                    for (numPennies = 0; numPennies <= maxPennies && !guessed; numPennies++ )
                    {
                        checkChange = (nickel * numNickels + penny * numPennies 
                                     + quarter * numQuarters + dime * numDimes) ;
                        checkCoins = numPennies + numNickels + numDimes + numQuarters;
                        
                        if (checkChange == change && checkCoins == coins)
                        {
                            guessed = checkGuess(numQuarters, numDimes, numNickels, numPennies);
                        }
                    }
        if (!guessed)
        {
            System.out.println("I cannot determine your coins.\n");
        }
            
    }
    
    public static boolean checkGuess(int numQuarters, int numDimes, 
            int numNickels, int numPennies )
    {
        Scanner input = new Scanner(System.in);
        String response;
        boolean guessed = false;
        System.out.println("\nHere is my guess.  You have \n");
        System.out.println(numQuarters+((numQuarters == 1)?" quarter,":" quarters,"));
        System.out.println(numDimes+((numDimes == 1)?" dime,":" dimes,"));
        System.out.println(numNickels+((numNickels == 1)?" nickel, and":" nickels, and"));
        System.out.println(numPennies+((numPennies == 1)?" penny.":" pennies.\n"));
        
        System.out.print("Is this correct?  Y / N : ");  
        response = input.next();
        if (response.equalsIgnoreCase("Y"))
        {
            System.out.println("\nYay! I guessed them! \n");
            guessed = true;
        }
        else
        {
            System.out.println("\nOK, let me try again.\n");
        }
        return guessed;
    }

}