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

// Product class: Computer
class Computer {
public:
    void setCPU(const std::string& cpu) {
        cpu_ = cpu;
    }
    void setRAM(const std::string& ram) {
        ram_ = ram;
    }
    void setStorage(const std::string& storage) {
        storage_ = storage;
    }
    void setGPU(const std::string& gpu) {
        gpu_ = gpu;
    }

    void showSpecs() const {
        std::cout << "Computer Specifications:\n"
                  << "  CPU: " << cpu_ << "\n"
                  << "  RAM: " << ram_ << "\n"
                  << "  Storage: " << storage_ << "\n"
                  << "  GPU: " << gpu_ << "\n";
    }

private:
    std::string cpu_;
    std::string ram_;
    std::string storage_;
    std::string gpu_;
};

// Abstract Builder
class ComputerBuilder {
public:
    virtual ~ComputerBuilder() = default;
    virtual void buildCPU() = 0;
    virtual void buildRAM() = 0;
    virtual void buildStorage() = 0;
    virtual void buildGPU() = 0;
    virtual std::shared_ptr<Computer> getResult() = 0;
};

// Concrete Builder: Gaming Computer
class GamingComputerBuilder : public ComputerBuilder {
public:
    GamingComputerBuilder() {
        computer_ = std::make_shared<Computer>();
    }

    void buildCPU() override {
        computer_->setCPU("Intel Core i9-13900K");
    }

    void buildRAM() override {
        computer_->setRAM("32GB DDR5 6000MHz");
    }

    void buildStorage() override {
        computer_->setStorage("2TB NVMe SSD");
    }

    void buildGPU() override {
        computer_->setGPU("NVIDIA RTX 4090 24GB");
    }

    std::shared_ptr<Computer> getResult() override {
        return computer_;
    }

private:
    std::shared_ptr<Computer> computer_;
};

// Concrete Builder: Office Computer
class OfficeComputerBuilder : public ComputerBuilder {
public:
    OfficeComputerBuilder() {
        computer_ = std::make_shared<Computer>();
    }

    void buildCPU() override {
        computer_->setCPU("Intel Core i5-13400");
    }

    void buildRAM() override {
        computer_->setRAM("16GB DDR4 3200MHz");
    }

    void buildStorage() override {
        computer_->setStorage("512GB NVMe SSD");
    }

    void buildGPU() override {
        computer_->setGPU("Integrated Intel UHD Graphics");
    }

    std::shared_ptr<Computer> getResult() override {
        return computer_;
    }

private:
    std::shared_ptr<Computer> computer_;
};

// 指挥者：控制建造过程
class Director {
public:
    void setBuilder(std::shared_ptr<ComputerBuilder> builder) {
        builder_ = builder;
    }

    void constructComputer() {
        builder_->buildCPU();
        builder_->buildRAM();
        builder_->buildStorage();
        builder_->buildGPU();
    }

    std::shared_ptr<Computer> getComputer() {
        return builder_->getResult();
    }

private:
    std::shared_ptr<ComputerBuilder> builder_;
};

// 客户端代码
int main() {
    // 创建指挥者和具体建造者
    Director director;
    auto gamingBuilder = std::make_shared<GamingComputerBuilder>();
    auto officeBuilder = std::make_shared<OfficeComputerBuilder>();

    // 建造一台游戏电脑
    director.setBuilder(gamingBuilder);
    director.constructComputer();
    auto gamingPC = director.getComputer();
    std::cout << "=== Gaming PC ===" << std::endl;
    gamingPC->showSpecs();
    std::cout << std::endl;

    // 建造一台办公电脑
    director.setBuilder(officeBuilder);
    director.constructComputer();
    auto officePC = director.getComputer();
    std::cout << "=== Office PC ===" << std::endl;
    officePC->showSpecs();

    return 0;
}