/**
 * Demonstrates the use of basic functional objects, or functors, in a program.
 * This is my own work.
 * @date 01-26-2014
 * @author Adam Pyle
 * 
 */
public class hwk1 {

    /**
     * Check the given array numbers of the quality specified
     * @param <T> the datatype this method should expect
     * @param InputArr the array containing the numbers to be checked
     * @param type the class representing the specific type of number to check for
     * @return true if at least one number of the specified type is present, false otherwise
     */
    public static <T> boolean check(T[] InputArr, conditional<T> type)
    {
        for(int i=0;i<InputArr.length;i++)
        {
            if (type.Check(InputArr[i]))
            {
                return true;
            }
        }
        return false;
    }
    /**
     * main method.
     * @param args the command line arguments
     */
    public static void main(String[] args)
    {
            Integer first[]={1,2,3,-4,-3,0};
            Integer second[]={1,2,3,4,5};
            Integer third[]={3,11,17,19};
            Integer fourth[]={4,6,9,12,40,200};
        
        
            System.out.println("First Array: ");
            PrintArray(first);
            System.out.println();
            
            System.out.println("Second Array: ");
            PrintArray(second);
            System.out.println();
            
            System.out.println("Third Array: ");
            PrintArray(third);
            System.out.println();
            
            System.out.println("Fourth Array: ");
            PrintArray(fourth);
            System.out.println();
            
            System.out.println("Testing the first array for negatives... result: " + check(first, new Negative()));
            System.out.println("Testing the second array for negatives... result: " + check(second, new Negative()));
            System.out.println("Testing the third array for negatives... result: " + check(third, new Negative()));
            System.out.println("Testing the fourth array for negatives... result: " + check(fourth, new Negative()));
            
            System.out.println("Testing the first array for primes... result: " + check(first,new Prime()));
            System.out.println("Testing the second array for primes... result: " + check(second,new Prime()));
            System.out.println("Testing the third array for primes... result: " + check(third,new Prime()));
            System.out.println("Testing the fourth array for primes... result: " + check(fourth,new Prime()));
            
            System.out.println("Testing the first array for perfect squares... result: " + check(first,new PerfectSquare()));
            System.out.println("Testing the second array for perfect squares... result: " + check(second,new PerfectSquare()));
            System.out.println("Testing the third array for perfect squares... result: " + check(third,new PerfectSquare()));
            System.out.println("Testing the fourth array for perfect squares... result: " + check(fourth,new PerfectSquare()));
    }
    
    /**
     * Interface to ensure functor compatibility
     * @param <T> the expected type of the data
     */
        static public interface conditional<T>
        {
            /**
             * Checks the given data and determines whether it is an example of this type of number
             * @param input the data to be checked
             * @return true if @input meets the conditions for this type of number, false otherwise
             */
            public boolean Check(T input);
        }
        /**
         * represents a negative number
         */
        static class Negative implements conditional<Integer>
        {
            @Override
            public boolean Check(Integer input)
            {
                if (input<0)
                {
                    return true;
                }else{
                    return false;
                }
            }
        }
        
        /**
         * represents a prime number
         */
        static class Prime implements conditional<Integer>
        {
            @Override
            public boolean Check(Integer input)
            {
                for(int i=2;i<=input/2;i++)
                {
                    if(input % i == 0)
                    {
                        return false;
                    }
                }
                return true;
            }
        }
        
        /**
         * represents a perfect square
         */
        static class PerfectSquare implements conditional<Integer>
        {

            @Override
            public boolean Check(Integer input)
            {
                //find the root of input, whatever it is, and discard any decimal places.
                int root=(int) Math.sqrt(input);
                //if the integer root squared is equal to the original input, then the number was a perfect square.
                if(root*root==input)
                {
                    return true;
                }else{
                    return false;
                }
            }
            
        }
        
        /**
         * simple utility method to cut back on the print statements in main
         * @param input  the array to print
         */
        static void PrintArray(Integer[] input)
        {
            for(int i=0;i<input.length;i++)
            {
                System.out.print(input[i] + " ");
            }
        }
}