/***********************************************
 *  CS2510 Spring 2011 
 *  Lecture #16
 *  Type Parameters, Generics, adn Function-Classes
 ***********************************************/

import tester.*;

// Represents a Puppy (Awww....)
class Puppy{
    String name;
    String eyecolor;
    boolean boy;
    
    Puppy(String name, String eyecolor, boolean boy) {
        this.name = name;
        this.eyecolor = eyecolor;
        this.boy = boy;
    }
}

// Represents something that can be "traversed" that
//   contains Xs
interface Traverse<X>{
    // Is this thing empty?
    public boolean emptyHuh();
    // Get the first of this thing
    public X getFirst();
    // Get the rest of this thing
    public Traverse<X> getRest();
}

// Represents a List of Xs
interface ILo<X> extends Traverse<X>{
    // Compute the length of this List of X
    public int length();
    
    // Transform all the elements of this List of X into
    //   a new List of Y
    public <Y> ILo<Y> transformAll(IMap<X,Y> mapper);
}

// Represents an empty List of Xs
class MtLo<X> implements ILo<X>{
    MtLo(){}
    
    // Compute the length of this List of X
    public int length(){ return 0; }
    
    // Transform all the elements of this List of X into
    //   a new List of Y
    public <Y> ILo<Y> transformAll(IMap<X,Y> mapper){
        return new MtLo<Y>();
    }
    // Is this list empty?
    public boolean emptyHuh(){
        return true;
    }
    // Get the first of this List
    public X getFirst(){
        throw new RuntimeException("No First Yahoo");
    }
    // Get the rest of this List
    // Note: it's safe to have the return type of ILo<X>
    //   even though it overrides the Traverse<X> method
    public ILo<X> getRest(){
        throw new RuntimeException("No Rest Yahoo");
    }
}

// Represents a nonempty List of Xs
class ConsLo<X> implements ILo<X>{
    X first;
    ILo<X> rest;
    
    ConsLo(X first, ILo<X> rest){
        this.first = first;
        this.rest = rest;
    }
    
    /** Template
     *    Fields:
     *      ... this.first ...  -- X
     *      ... this.rest ...   -- ILo<X>
     * 
     *    Methods:
     *      ... this.length() ...                  -- int
     *      ... this.transformAll(IMap<X,Y>)       -- ILo<Y>
     *    
     *    Methods for Fields:
     *      ... this.rest.length()...              -- int
     *      ... this.rest.transformAll(IMap<X,Y>)  -- ILo<Y>
     */
    
    // Calculate the length of this List of Xs
    public int length(){ return 1 + this.rest.length(); }
    
    // Transform all the elements of this List of X into
    //   a new List of Y
    public <Y> ILo<Y> transformAll(IMap<X,Y> mapper){
        // Template
        //   ... mapper.transform(X) -- Y
        //   ... this.first -- X
        //   ... this.rest  -- ILo<X>
        return new ConsLo<Y>(mapper.transform(this.first),
                this.rest.transformAll(mapper));
    }
    
    // Is this List empty?
    public boolean emptyHuh(){
        return false;
    }
    // Get the first of this List
    public X getFirst(){
        return this.first;
    }
    // Get the rest of this List
    // Note: Again, it's safe to have the return type of ILo<X>
    //   even though it overrides the Traverse<X> method
    public ILo<X> getRest(){
        return this.rest;
    }
}

// A Class to represent various algorithms (functions/methods)
class Algo{
    
    // Compute the length of the given Traverse of X
    public <X> int length(Traverse<X> lox){
        if(lox.emptyHuh()){
            return 0;
        }else{
            return 1 + this.length(lox.getRest());
        }
    }
}

// Represents a method that transforms Xs into Ys
interface IMap<X, Y>{
    // Transforms the given X into a Y
    public Y transform(X x);
}

// Represents the function from Puppys to their names
//    [Puppy -> String]
class PuppyName implements IMap<Puppy, String>{
    // Get the Puppy's name
    public String transform(Puppy p){
        return p.name;
    }
}

// Examples and Tests
class LectureExamples{
    IMap<Puppy, String> pup = new PuppyName();
    
    Algo algo = new Algo();
    
    ILo<String> mtS = new MtLo<String>();
    ILo<Puppy> mtP = new MtLo<Puppy>();
    
    Puppy fred = new Puppy("Fred", "baby-blue", false);
    Puppy java = new Puppy("Java", "red", true);
    
    ILo<Puppy> gavins_dogs = new ConsLo<Puppy>(this.fred,
            new ConsLo<Puppy>(this.java, this.mtP));
    
    ILo<String> gavins_strings = new ConsLo<String>("Fred",
            new ConsLo<String>("Java", this.mtS));

    // Boxing/unboxing examples
    int mine = new Integer(5) + 7;
    Integer yours = 5 * 3;
    ILo<Integer> my_ints = new ConsLo<Integer>(7, new MtLo<Integer>());
    
    // Tests for our methods...
    void testAll(Tester t){
        t.checkExpect(this.gavins_dogs.transformAll(pup), this.gavins_strings);
        t.checkExpect(this.gavins_dogs.length(), 2);
        t.checkExpect(this.gavins_dogs.transformAll(pup).length(), 2);
        t.checkExpect(this.algo.length(this.gavins_dogs.transformAll(pup)), 2);
        t.checkExpect(this.algo.length(this.gavins_dogs), 2);
        t.checkExpect(this.algo.length(this.gavins_strings), 2);
    }
}