#include <iostream>
#include <memory>
#include <string>

// Abstract base class: Request
class Request {
public:
    virtual void execute() = 0; // Pure virtual function
    virtual ~Request() = default;
};

// Concrete class: ResetRequest
class ResetRequest : public Request {
public:
    void execute() override {
        std::cout << "Executing Reset Request" << std::endl;
    }
};

// Concrete class: ClearDTCRequest
class ClearDTCRequest : public Request {
public:
    void execute() override {
        std::cout << "Executing Clear DTC Request" << std::endl;
    }
};

// Factory Class: RequestFactory
class RequestFactory {
public:
    static std::unique_ptr<Request> create(const std::string& data) {
        if (data == "Reset") {
            return std::make_unique<ResetRequest>();
        } else if (data == "ClearDTC") {
            return std::make_unique<ClearDTCRequest>();
        } else {
            return nullptr;
        }
    }
};

// Class: Service
class Service {
public:
    bool validateData(const std::string& data) {
        return !data.empty(); // Simple validation logic
    }

    void OnNewMessage(const std::string& data) {
        if (validateData(data)) {
            auto request = RequestFactory::create(data);
            if (request) {
                request->execute();
            } else {
                std::cout << "Invalid Request Type" << std::endl;
            }
        }
    }
};

// Class: Connection
class Connection {
public:
    void setOnMessageHandler(Service& service) {
        // Simulate receiving messages
        service.OnNewMessage("Reset");
        service.OnNewMessage("ClearDTC");
        service.OnNewMessage("InvalidRequest");
    }
};

int main() {
    Connection connection;
    Service service;

    connection.setOnMessageHandler(service);

    return 0;
}