/*
  Complete class implementation. Provide simpliest solution
  
  Implement car hierarchy along with accessor function and a CarRental
  class which contains the container to store them. The container
  shall own car hierarchy objects
  
  A car rental company wants to keep track of it's cars. Each vehicle
  has a license plate and a brand (e.g.BMW). The company has SUVs and
  Sedans. SUVs have an optional third-row seat that increase passenger
  capacity by 3. Sedans have an option sport package. Each car can be
  queried to inquire the number of passengers it can carry.
  
 */

// Brand: Ford, Toyota
// Toyota SUVs: Sequoia, Highlander, FourRunner
// Toyota Sedan: Corolla, Camry, Prius
// Ford SUVs: Bronco, Edge, Escape
// Ford Sedans: Fiesta, Focus, Fusion

#include <bits/stdc++.h>
using namespace std;

class Car
{
public:
    enum Brand {Ford, Toyota};

    string ToString(Brand b) 
    {
        switch(b)
        {
        case Ford: return "Ford";
        case Toyota: return "Toyota";
        default: return "Unknown Brand";                
        }
    }
    
    
    Brand   brand;
    int     numPassengers;    
    string  licensePlate;

    virtual string GetType() = 0;

    string GetBrand()         { return ToString(brand); }
    string LicensePlate()    { return licensePlate; }
    int NumberOfPassengers() { return numPassengers; }

    Car(Brand b, int numPass, const string& plateNum)
        : brand(b), numPassengers(numPass), licensePlate(plateNum)
    {
    }
};

class Sedan : public Car
{
public:

    enum Type {Corolla, Camry, Prius, Fiesta, Focus, Fusion};

    Type type;
    bool hasSportPackage;

    string GetType()
    {
        switch(type)
        {
        case Corolla: return "Corolla";            
        case  Camry: return "Camry";            
        case  Prius: return "Prius";            
        case  Fiesta: return "Fiesta";
        case  Focus: return "Focus";        
        case  Fusion: return "Fusion";
        default: return "Unknown Sedan Type";            
        }
    }
        
    Sedan(Brand b, Type t, int numPassengers, const string& plateNum, bool hasSportPackage_)
        : Car(b, numPassengers, plateNum), type(t), hasSportPackage(hasSportPackage_)
    {
    }    
};

class SUV : public Car
{
public:
    enum Type { Sequoia, Highlander, FourRunner, Bronco };

    Type type;    
    bool hasThirdRowSeat;


    string GetType()
    {
        switch(type)
        {
        case Sequoia:  return "Sequoia";
        case Highlander: return "Highlander";
        case FourRunner: return "FourRunner";
        case  Bronco: return "Bronco";
        default: return "Unknown SUV Type";            
        }
    }
    
        
    
    SUV(Brand b, Type t, int numPassengers, const string& plateNum, bool hasThirdRowSeat_)
        : Car(b, numPassengers, plateNum), type(t), hasThirdRowSeat(hasThirdRowSeat_)
    {
        if (hasThirdRowSeat)
            Car::numPassengers += 3;
     }    
};

class CarRental
{
public:
    enum Company {Budget, Alamo};

    CarRental(const string& dealer_, Company company_)
        : company(company_), dealer(dealer_)
    {}

    void addCar(Car* car)
    {
        cars.push_back(car);
    }    
    
    Company company;
    string dealer;
    
    vector<Car*> cars;

    void printCarInfo()
    {
        for(auto ptr: cars)
        {
            cout << "Dealer: " << dealer
                 << " Brand: " << ptr->GetBrand()
                 << " Type: " << ptr->GetType()
                 << " NumberOfPassengers: " << ptr->NumberOfPassengers()
                 << " LicensePlate: " << ptr->LicensePlate();

            if (SUV* suv = dynamic_cast<SUV*>(ptr); suv != nullptr)
            {
                if (suv->hasThirdRowSeat)
                    cout << " HasThirdRowSeat";
                else
                    cout << " NoThirdRowSeat";
            }

            if (Sedan* sedan = dynamic_cast<Sedan*>(ptr); sedan != nullptr)
            {
                if (sedan->hasSportPackage)
                    cout << " HasSportPackage";
                else
                    cout << " NoSportPackage";
            }
            
            cout << endl;            
        }
    }
};

int main(void)
{
    CarRental dealer1("dealer1", CarRental::Budget);
    {        
        Sedan* sedan1 = new Sedan(Car::Toyota, Sedan::Corolla, 4, "Cali123", false);
        SUV* suv1 = new SUV(Car::Ford, SUV::Sequoia, 5, "NY456", false);    
        dealer1.addCar(sedan1);
        dealer1.addCar(suv1);
    }
    dealer1.printCarInfo();    
    
    CarRental dealer2("dealer2", CarRental::Alamo);
    {
        Sedan* sedan1 = new Sedan(Car::Toyota, Sedan::Camry, 4, "Cali789", false);
        Sedan* sedan2 = new Sedan(Car::Ford, Sedan::Fiesta, 4, "CT123", true);
        SUV* suv1 = new SUV(Car::Ford, SUV::Bronco, 5, "NY456", false);
        SUV* suv2 = new SUV(Car::Toyota, SUV::Sequoia, 5, "NY789", true);
        dealer2.addCar(sedan1);
        dealer2.addCar(sedan2);
        dealer2.addCar(suv1);
        dealer2.addCar(suv2);
    }
    dealer2.printCarInfo();    
}