/**
   Boston University, Department of Computer Science
   CS 112, Spring 2011
   Lab 02: Inheritance, Interfaces, Collections and Generics 
   Teaching Fellow: Diane H. Theriault, deht@cs.bu.edu
 */

import java.util.*;
import java.io.*;

public class PartyRunner {
  
   public static void main(String[] args)
   {
    System.out.println("Welcome to the Party!");

    // create some vehicles with passengers from Discovery Channel Shows.
    Set<Vehicle> caravan = new HashSet<Vehicle>();
    //This collection class does NOT maintain FCFS!

    addAmericanChopper(caravan);    
    addMythbusters(caravan);
    addDeadliestCatch(caravan);
    
    // Go to party
    Travel(caravan);
    
    // Rock the House
    Arrive(caravan);
  }

   static void addAmericanChopper(Set<Vehicle> caravan)
   {
    Motorcycle m1 = new Motorcycle("Paul Sr.");
    Motorcycle m2 = new Motorcycle("Pauli Junior");
    Motorcycle m3 = new Motorcycle("Mikey");     
    caravan.add(m1);
    caravan.add(m2);
    caravan.add(m3);
   }

   static void addMythbusters(Set<Vehicle> caravan)
   {
    Car c1 = new Car("Jamie");
    c1.addPassenger("Adam");

    Car c2 = new Car("Kari");
    c2.addPassenger("Grant");
    c2.addPassenger("Tory");
     
    caravan.add(c1);
    caravan.add(c2);
   }
   
   static void addDeadliestCatch(Set<Vehicle> caravan)
   {
     Ship s1 = new Ship("Phil Harris");

     //when you are finished modifying the Ship constructor, 
     //use this version instead:
     //Ship s1 = new Ship("Phil Harris", "Cornelia Marie");

    s1.addPassenger("Jake Harris");
    s1.addPassenger("Roger Jensen");

    Ship s2 = new Ship("Sig Hansen");
    //Ship s2 = new Ship("Sig Hansen", "Northwestern");
    s2.addPassenger("Bradford Davis");
    s2.addPassenger("Marco");
     
    caravan.add(s1);
    caravan.add(s2);
   }
   
   static void Travel(Set<Vehicle> caravan)
   {
     //this is one style of moving through an Iterable container
     for(Iterator<Vehicle> iter=caravan.iterator(); iter.hasNext(); )
     {
       Vehicle vehicle = iter.next();
       System.out.println(vehicle.getDriver() + "'s " + vehicle.getName() + " is on it's way! " + vehicle.Go()); 
     }
   }
   
   static void Arrive(Set<Vehicle> caravan)
   {
     //this is the other style of moving through an Iterable container
     for(Vehicle vehicle : caravan)
     {
        String [] partyGoers = vehicle.getManifest();
        if(partyGoers == null)
        {
          continue;
        }
        for(int i=0; i<partyGoers.length; i++)
        {
          System.out.println("Welcome to the party, " + partyGoers[i] + "!");
        }
     }     
   }
}



//This is the base class for the other objects we will be implementing
abstract class Vehicle
{
  protected String mName;  //the name of the object (Car, Boat, Airplane...)
  protected String mDriver; //the name of the person at the wheel

  //the constructor takes the name of the driver as an argument
  public Vehicle(String iDriver)
  {
    mDriver = iDriver;
  }
  
  //this returns the name of the object
  public String getName()
  {
    return mName;
  }

  //this returns the name of the driver
  public String getDriver()
  {
    return mDriver;
  }

  //this abstract method must be overloaded in subclasses, to return
  //a manifest of people traveling in this vehicle
  public abstract String[] getManifest();
  
  //this abstract method must be overloaded in subclasses, to return 
  //a String describing what the object does when it goes.
  public abstract String Go();
}

//This is an interface that requires conforming classes to implement one method.
//This interface is implemented by Car and Ship (but not by Motorcycle) 
interface MultipleOccupancy
{
  public boolean addPassenger(String iPassenger);
}

//This Motorcycle class is derived from the superclass, Vehicle.
//Use this implementation as a pattern for implementing the other classes
class Motorcycle extends Vehicle 
{
  public Motorcycle(String iDriver)
  {
    super(iDriver);
    mName = "Chopper";
  }
  public String[] getManifest()
  {
    String[] passengerList = new String[1];
    passengerList[0] = mDriver;
    return passengerList;
  }
  
  public String Go()
  {
    return new String("Vroom Vroom!");
  }
}

//The Car class is derived from Vehicle, and used by the Mythbusters.
//It implements the MultipleOccupancy interface.
//
//You must fill in the implementation of this class, including adding a 
//container for extra passengers, and populating the return value of 
//getManifest.
class Car extends Vehicle implements MultipleOccupancy
{
  public Car(String iDriver)
  {
    super(iDriver);
  }
  
  public String[] getManifest()
  {
    return null;
  }

  public String Go()
  {
    return null;
  }
  
  public boolean addPassenger(String iPassenger)
  {
    return true;
  }
}

//The Car class is derived from Vehicle, and used by the Mythbusters.
//It implements the MultipleOccupancy interface.
//
//You must fill in the implementation of this class, including adding a 
//container for extra passengers, and populating the return value of 
//getManifest.
//
//Also, change the implementation of the constructor so that you can pass
//in the name of the boat to use when you print everything out in 
//Travel()
class Ship extends Vehicle implements MultipleOccupancy
{

  public Ship(String iDriver)
  {
    super(iDriver);
  }
  
  public String[] getManifest()
  {
    return null;
  }

  public String Go()
  {
    return null;
  }
  
  public boolean addPassenger(String iPassenger)
  {
    return true;
  }
}