#include <algorithm>
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <vector>
using namespace std;

enum Size { SMALL, MEDIUM, LARGE };
const string TYPES[] = {"BIKE", "CAR", "TRUCK"};
enum Type { BIKE, CAR, TRUCK };
struct Vehicle { string plate; Type type; Size needs; };
struct VehicleFactory {  // the one place that knows which spot size each type needs
    static Vehicle create(const string& plate, Type type) { return {plate, type, type == BIKE ? SMALL : type == CAR ? MEDIUM : LARGE}; }
};

struct Spot {
    int level; string id; Size size; const Vehicle* vehicle = nullptr;
    Spot(int l, string i) : level(l), id(i), size(i[0] == 'S' ? SMALL : i[0] == 'M' ? MEDIUM : LARGE) {}
    bool fits(const Vehicle& v) const { return vehicle == nullptr && size >= v.needs; }
    string name() const { return "level " + to_string(level) + " spot " + id; }
};
struct Level {
    vector<Spot> spots;
    Level(int number, vector<string> ids) { for (auto& id : ids) spots.emplace_back(number, id); }
    bool isFull() const { for (auto& s : spots) if (!s.vehicle) return false; return true; }
};
struct Ticket { Vehicle vehicle; Spot* spot; int entryHour; };
struct SpotStrategy { virtual Spot* find(vector<Level>& levels, const Vehicle& v) = 0; virtual ~SpotStrategy() = default; };
struct PricingStrategy { virtual int fee(const Ticket& t, int exitHour) = 0; virtual ~PricingStrategy() = default; };
// Lowest level first; on that level, the smallest free spot that fits.
struct BestFit : SpotStrategy {
    Spot* find(vector<Level>& levels, const Vehicle& v) override {
        for (auto& level : levels) {
            Spot* best = nullptr;
            for (auto& s : level.spots)
                if (s.fits(v) && (!best || s.size < best->size)) best = &s;
            if (best) return best;
        }
        return nullptr;
    }
};

struct Hourly : PricingStrategy {
    int fee(const Ticket& t, int exitHour) override {
        int rate = t.vehicle.type == BIKE ? 10 : t.vehicle.type == CAR ? 20 : 40;
        return max(1, exitHour - t.entryHour) * rate;
    }
};

struct ParkingLot {
    vector<Level> levels;
    map<string, Ticket> tickets;
    unique_ptr<SpotStrategy> spots; unique_ptr<PricingStrategy> pricing;
    void park(const string& plate, Type type, int hour) {
        Vehicle v = VehicleFactory::create(plate, type);
        Spot* s = spots->find(levels, v);
        if (!s) { cout << plate << " " << TYPES[type] << " -> no spot\n"; return; }
        auto it = tickets.insert({plate, Ticket{v, s, hour}}).first;
        s->vehicle = &it->second.vehicle;
        cout << plate << " " << TYPES[type] << " -> " << s->name() << "\n";
    }
    void leave(const string& plate, int hour) {
        Ticket t = tickets.at(plate);
        t.spot->vehicle = nullptr;
        cout << plate << " leaves " << t.spot->name() << " after " << hour - t.entryHour << "h, fee " << pricing->fee(t, hour) << "\n";
        tickets.erase(plate);
    }
};

int main() {
    ParkingLot lot{{}, {}, make_unique<BestFit>(), make_unique<Hourly>()};
    lot.levels.emplace_back(1, vector<string>{"S1", "M1", "L1"});
    lot.levels.emplace_back(2, vector<string>{"M1", "L1"});
    lot.park("KA-01", BIKE, 0); lot.park("KA-02", CAR, 1); lot.park("KA-03", TRUCK, 1);
    cout << "level 1 full: " << (lot.levels[0].isFull() ? "true" : "false") << "\n";
    lot.park("KA-04", CAR, 2); lot.leave("KA-02", 4); lot.park("KA-05", CAR, 4);
    lot.park("KA-06", TRUCK, 5); lot.park("KA-07", TRUCK, 5);
}