Extended car class

/*

 Łap Daria :)
    
To rozszerzona wersja klasy Car zawiera następujące ulepszenia i nowe funkcjonalności:

- Dodano hierarchię klas dla silników (abstrakcyjna klasa bazowa Silnik i klasy pochodne SilnikBenzynowy i SilnikDiesel).
- Użyto std::unique_ptr do zarządzania obiektem silnika, co zapewnia automatyczne zarządzanie pamięcią.
- Dodano enumerację TypNapedu do reprezentacji różnych typów napędu.
- Wprowadzono wektor FWyposazenie do przechowywania listy elementów wyposażenia.
- Rozszerzono konstruktor o dodatkowe parametry.
- Dodano metodę UstawSilnik do przypisywania silnika do samochodu.
- Wprowadzono metodę DodajWyposazenie do dodawania elementów wyposażenia.
- Rozbudowano metodę Przyspiesz, uwzględniając moc silnika i zużycie paliwa.
- Dodano metodę Zatankuj z obsługą wyjątków w przypadku próby przelania zbiornika.
- Znacznie rozszerzono metodę PobierzInformacje, aby zawierała więcej szczegółów o samochodzie.
- Dodano prywatną metodę pomocniczą NapedToString do konwersji typu napędu na string.

Ta wersja klasy jest bardziej elastyczna, bezpieczna i bogata w funkcjonalności, 
co czyni ją bardziej profesjonalną i gotową do użycia w bardziej złożonych aplikacjach
  
*/

#include <System.hpp>
#include <vector>
#include <memory>
#include <stdexcept>

// Abstract base class for engines
class Engine {
public:
    virtual double GetPower() const = 0;
    virtual ~Engine() = default;
};

class PetrolEngine : public Engine {
private:
    double FPower;
public:
    PetrolEngine(double APower) : FPower(APower) {}
    double GetPower() const override { return FPower; }
};

class DieselEngine : public Engine {
private:
    double FPower;
public:
    DieselEngine(double APower) : FPower(APower) {}
    double GetPower() const override { return FPower; }
};

class Car {
public:
    enum class DriveType { FrontWheel, RearWheel, AllWheel };

private:
    String FBrand;
    String FModel;
    int FYearOfManufacture;
    double FSpeed;
    double FFuel;
    const double FTankCapacity;
    DriveType FDriveType;
    std::unique_ptr<Engine> FEngine;
    std::vector<String> FEquipment;

public:
    Car(const String& ABrand, const String& AModel, int AYearOfManufacture, 
        double ATankCapacity, DriveType ADriveType)
        : FBrand(ABrand), FModel(AModel), FYearOfManufacture(AYearOfManufacture),
          FSpeed(0), FFuel(ATankCapacity), 
          FTankCapacity(ATankCapacity), FDriveType(ADriveType) {}

    // Set the engine for the car
    void SetEngine(std::unique_ptr<Engine> AEngine) {
        FEngine = std::move(AEngine);
    }

    // Add an equipment item to the car
    void AddEquipment(const String& AItem) {
        FEquipment.push_back(AItem);
    }

    // Increase the car's speed
    void Accelerate(double ADelta) {
        if (FFuel > 0 && FEngine) {
            FSpeed += ADelta * (FEngine->GetPower() / 100.0);
            FFuel -= ADelta * 0.01;  // Example fuel consumption
        }
        if (FSpeed < 0) FSpeed = 0;
        if (FFuel < 0) FFuel = 0;
    }

    // Decrease the car's speed
    void Decelerate(double ADelta) {
        FSpeed -= ADelta;
        if (FSpeed < 0) FSpeed = 0;
    }

    // Refuel the car
    void Refuel(double AAmount) {
        if (FFuel + AAmount > FTankCapacity) {
            throw std::runtime_error("Tank overflow!");
        }
        FFuel += AAmount;
    }

    // Get detailed information about the car
    String GetInformation() const {
        String info = String().sprintf(L"Car: %s %s\n"
                                       L"Year of manufacture: %d\n"
                                       L"Current speed: %.2f km/h\n"
                                       L"Fuel: %.2f / %.2f l\n"
                                       L"Drive type: %s\n"
                                       L"Engine power: %.2f HP\n"
                                       L"Equipment: ",
            FBrand.c_str(), FModel.c_str(), FYearOfManufacture, FSpeed,
            FFuel, FTankCapacity, DriveTypeToString(FDriveType).c_str(),
            FEngine ? FEngine->GetPower() : 0.0);

        for (const auto& item : FEquipment) {
            info += item + L", ";
        }
        if (!FEquipment.empty()) {
            info = info.SubString(1, info.Length() - 2);  // Remove last comma and space
        }
        return info;
    }

private:
    // Convert DriveType enum to String
    static String DriveTypeToString(DriveType ADriveType) {
        switch (ADriveType) {
            case DriveType::FrontWheel: return L"Front-wheel drive";
            case DriveType::RearWheel: return L"Rear-wheel drive";
            case DriveType::AllWheel: return L"All-wheel drive";
            default: return L"Unknown";
        }
    }
};