/***********************************************
 *  CS2510 Fall 2011 
 *  Lecture #22.1
 *  More Loops; Iterator
 ***********************************************/

import java.util.*;
import tester.*;
import world.*;

class Algos {
    
    // Converts everything in the list to lower case
    static void lowerCaseify(ArrayList<String>  list) {
        int x = 0;
        while(x < list.size()) {
            list.set(x,list.get(x).toLowerCase());
            x = x + 1;
        }
    }
}

// The List interface which can be iterated
interface IList<X> extends Iterable<X> {
    // Is it empty?
    boolean isEmpty();
    // Return the first element
    X getFirst();
    // Return the rest of the list
    IList<X> getRest();
}

// The empty list element
class MtList<X> implements IList<X>{
    // It is empty
    public boolean isEmpty() {
        return true;
    }
    
    // No elements, error
    public X getFirst() {
        throw new RuntimeException("No elements");
    }
    
    // No elements, error
    public IList<X> getRest() {
        throw new RuntimeException("No elements means no more list of elements either");
    }
    
    // Returns an iterator over this list
    public Iterator<X> iterator() {
        return new ListIter<X>(this);
    }
    
}

// The Cons list element
class ConsList<X> implements IList<X> {
    X first;
    IList<X> rest;
    
    ConsList (X first, IList<X> rest) {
        this.first = first;
        this.rest = rest;
    }
    
    // Not empty
    public boolean isEmpty() {
        return false;
    }
    
    // Returns this element
    public X getFirst() {
        return this.first;
    }
    
    // Returns the rest of the list
    public IList<X> getRest() {
        return this.rest;
    }

    // Returns an iterator over this list
    public Iterator<X> iterator() {
        return new ListIter<X>(this);
    }
}

// An iterator for our list class
class ListIter<X> implements Iterator<X> {
    IList<X> l;
    ListIter(IList<X> l) {
        this.l = l;
    }
    
    // Returns true if there is a next element
    public boolean hasNext() {
        return ! l.isEmpty();
    }
    
    // Returns the current element in the list
    // EFFECT: Increments to the next element in the list
    public X next() {
        X tmp = l.getFirst();
        l = l.getRest();
        return tmp;
    }
    
    // remove : unsupported, throws error
    public void remove() {
        throw new UnsupportedOperationException("Can't remove");
    }
}

// A Pirate class to use in our lists
class Pirate {
    String name;
    boolean pegleg;
    int numeyes;
    Pirate(String name, boolean pegleg, int numeyes) {
        this.name = name;
        this.pegleg = pegleg;
        this.numeyes = numeyes;
    }
}


class LoopExamples {
    // A test of our lowerCaseify
    void testAlgos(Tester t) {
        ArrayList<String> l = new ArrayList<String>();
        l.add("HI");
        l.add("I");
        l.add("LIKE");
        l.add("UPPER");
        l.add("CASE");
        ArrayList<String> lower = new ArrayList<String>();
        lower.add("hi");
        lower.add("i");
        lower.add("like");
        lower.add("upper");
        lower.add("case");
        Algos.lowerCaseify(l);
        t.checkExpect(l,lower);
    }
    
    // A test to make sure our iterator does what we expect
    void testIterator(Tester t) {
        Pirate p1 = new Pirate("Black Beard",true,1);
        Pirate p2 = new Pirate("Jack Sparrow",false,3);
        Pirate p3 = new Pirate("Sticky Beard",true,2);
        IList<Pirate> plist = new ConsList<Pirate>(p1,new ConsList<Pirate>(p2,new ConsList<Pirate>(p3,new MtList<Pirate>())));
        
        IList<Pirate> travis = plist;
        for (Pirate p : plist) {
            t.checkExpect(p, travis.getFirst());
            travis = travis.getRest();
        }
        for (Pirate p : plist) {
            System.out.println(p.name);
        }
    }
}