第二部分：结构型组件

// 库 A：Logger 接口是 void log(const char* msg, int level)
// 库 B：Logger 接口是 void write(string_view msg, Level lvl)
// 你的代码里到处都是 Logger 引用 —— 每改一次接口 = 改 N 处调用

#include <string_view>
#include <functional>
#include <utility>
#include <type_traits>

enum class Level { Debug, Info, Warn, Error };

// ═══════════════════════════════════════
// 方案 A：类型擦除适配器（运行时）
// ═══════════════════════════════════════
class LoggerAdapter {
public:
    // 模板构造：接受任何签名兼容的东西
    template<typename T>
        requires (!std::same_as<std::decay_t<T>, LoggerAdapter>)
    explicit LoggerAdapter(T&& target)
        : logger_(std::forward<T>(target)) {}

    void log(std::string_view msg, Level lvl) {
        logger_(msg, lvl);  // 通过 std::function 间接调用
    }

private:
    std::function<void(std::string_view, Level)> logger_;
};

// 使用
struct ThirdPartyLoggerA {
    void log_to_file(const char* msg, int severity) {
        // ... 写文件
    }
};

// 一行搞定适配
auto adapted = LoggerAdapter(
    [&file_logger](std::string_view msg, Level lvl) {
        file_logger.log_to_file(msg.data(), static_cast<int>(lvl));
    }
);
adapted.log("hello", Level::Info);  // 直接调用

// ═══════════════════════════════════════
// 方案 B：concept 适配器（编译期，零开销）
// ═══════════════════════════════════════
#include <concepts>

template<typename T>
concept Loggable = requires(T& t, std::string_view msg, Level lvl) {
    { t.log(msg, lvl) } -> std::same_as<void>;
};

template<Loggable Logger>
class ZeroCostAdapter {
public:
    explicit ZeroCostAdapter(Logger& logger) : logger_(logger) {}

    void log(std::string_view msg, Level lvl) {
        logger_.log(msg, lvl);  // 编译期内联，零开销
    }

private:
    Logger& logger_;  // 引用，没堆分配
};

template<typename Signature>
class inplace_function;  // 略，用 boost::function 或自己实现

// 或者直接用这个简化版（只接受无捕获 lambda）
template<typename F>
class InplaceAdapter {
    [[no_unique_address]] F fn_;  // 空类型零大小，lambda 内联
public:
    explicit InplaceAdapter(F fn) : fn_(fn) {}
    void log(std::string_view msg, Level lvl) { fn_(msg, lvl); }
};
// 编译产物：和手写循环完全相同的汇编代码

// 场景：项目里用三种不同的 logger
auto console = ConsoleLogger{};
auto file    = FileLogger{"/var/log/app.log"};
auto remote  = RemoteLogger{"192.168.1.1:9090"};

// 统一适配
std::vector<LoggerAdapter> loggers;
loggers.emplace_back([&console](auto msg, auto lvl) {
    console.write(msg, lvl);
});
loggers.emplace_back([&file](auto msg, auto lvl) {
    file.log_to_file(msg.data(), static_cast<int>(lvl));
});
loggers.emplace_back([&remote](auto msg, auto lvl) {
    remote.send(msg.data(), lvl);
});

// 四处调用，不再关心底层是什么
for (auto& logger : loggers) {
    logger.log("connection lost", Level::Error);
}

// widget.h
#include <third/party/giant/header1.hpp>
#include <third/party/giant/header2.hpp>
#include <third/party/giant/header3.hpp>  // 每个 5000+ 行

class Widget {
    GiantImpl impl;  // 改了 GiantImpl 一行 → 所有 include widget.h 的都重编
};
// 全量重编译：10 分钟

// widget.h — 引入后
class Widget {
    struct Impl;           // 前置声明
    std::unique_ptr<Impl> pImpl;  // 只暴露指针
};
// 改了 Impl → 只有 widget.cpp 重编译 → 3 秒

// heavy_template.h
#pragma once
#include <memory>

template<typename T>
class HeavyTemplate {
    struct Impl;
    std::unique_ptr<Impl> pImpl;  // 模板参数对客户端透明
public:
    void process(T value);
};

class SimpleLogger {
public:
    void log(string_view msg) { write_to_file(msg); }
};

// ═══════════════════════════════════════
// 方案 A：动态装饰器（运行时叠加）
// ═══════════════════════════════════════

// 统一接口
struct ILogger {
    virtual ~ILogger() = default;
    virtual void log(std::string_view msg) = 0;
};

// 核心实现
class FileLogger : public ILogger {
    void log(std::string_view msg) override {
        // write to file ...
    }
};

// 装饰器基类
class LoggerDecorator : public ILogger {
protected:
    std::unique_ptr<ILogger> inner_;
public:
    explicit LoggerDecorator(std::unique_ptr<ILogger> inner)
        : inner_(std::move(inner)) {}
};

// 时间戳装饰器
class TimestampDecorator : public LoggerDecorator {
    using LoggerDecorator::LoggerDecorator;
public:
    void log(std::string_view msg) override {
        auto now = std::time(nullptr);
        char buf[32];
        std::strftime(buf, sizeof(buf), "[%T] ", std::localtime(&now));
        inner_->log(std::string(buf) + std::string(msg));
    }
};

// 高亮装饰器
class ColorDecorator : public LoggerDecorator {
    std::string color_;
    using LoggerDecorator::LoggerDecorator;
public:
    ColorDecorator(std::unique_ptr<ILogger> inner, std::string color)
        : LoggerDecorator(std::move(inner)), color_(std::move(color)) {}
    void log(std::string_view msg) override {
        inner_->log(color_ + std::string(msg) + "\033[0m");
    }
};

// 使用：运行时自由组合
auto logger = std::make_unique<TimestampDecorator>(
    std::make_unique<ColorDecorator>(
        std::make_unique<FileLogger>(),
        "\033[31m"
    )
);
logger->log("something went wrong");
// 输出：[14:30:05] \033[31m something went wrong \033[0m

// ═══════════════════════════════════════
// 方案 B：静态装饰器（编译期叠加，零开销）
// ═══════════════════════════════════════

// 不需要虚基类！核心 logger 就是一个普通类
class CoreLogger {
public:
    void log(std::string_view msg) const {
        // write to file ...
    }
};

// 时间戳装饰（CRTP）
template<typename Inner>
class TimestampDecorator {
    [[no_unique_address]] Inner inner_;  // 空类型零开销
public:
    void log(std::string_view msg) const {
        auto now = std::time(nullptr);
        char buf[32];
        std::strftime(buf, sizeof(buf), "[%T] ", std::localtime(&now));
        inner_.log(std::string(buf) + std::string(msg));
    }
};

// 高亮装饰
template<typename Inner>
class ColorDecorator {
    [[no_unique_address]] Inner inner_;
    std::string_view color_;
public:
    explicit ColorDecorator(std::string_view color) : color_(color) {}
    void log(std::string_view msg) const {
        inner_.log(std::string(std::string(color_) + std::string(msg) + "\033[0m"));
    }
};

// 使用：运行时也能组合，但类型在编译期确定
// 内层：ColorDecorator<CoreLogger>
// 外层：TimestampDecorator<ColorDecorator<CoreLogger>>
auto decor = TimestampDecorator(
    ColorDecorator<CoreLogger>("\033[31m")
);
// CoreLogger 是空类型 → ColorDecorator<CoreLogger> 也是空类型
// → TimestampDecorator 也是空类型 → sizeof = 1（零开销！）
decor.log("optimized call");
// 编译后：所有调用内联，生成的汇编和手写调用链一样

// 一行声明装饰器组合
template<typename Core, template<typename> typename... Decorators>
using make_decorator_chain = /* 递归包装 */;

// 使用：
// using MyLogger = make_decorator_chain<CoreLogger,
//     TimestampDecorator, HighlightDecorator, TracingDecorator>;
// 编译器生成：TracingDecorator<HighlightDecorator<TimestampDecorator<CoreLogger>>>

class Button {
    void render() { /* 画按钮 */ }
};

class Panel {
    std::vector<Button> buttons_;
    // 想加 Label？加 TextBox？改 Panel 的 vector？
    // 嵌套 Panel？（Panel 里放 Panel？）
};

Panel::render() {
  for (auto& child : children) {
    child->render();  // 无论 child 是 Leaf 还是 Composite
    }
  }

// ═══════════════════════════════════════
// 方案 A：虚函数 + unique_ptr
// ═══════════════════════════════════════

#include <memory>
#include <vector>
#include <algorithm>

class UIComponent {
public:
    virtual ~UIComponent() = default;
    virtual void render() const = 0;
    virtual void add(std::unique_ptr<UIComponent> child) {}
    virtual void remove(const UIComponent* child) {}
};

// 叶子节点
class Button : public UIComponent {
    std::string label_;
    int x_, y_;
public:
    Button(std::string label, int x, int y)
        : label_(std::move(label)), x_(x), y_(y) {}
    void render() const override {
        // draw button at (x_, y_)
    }
};

class Label : public UIComponent {
    std::string text_;
public:
    explicit Label(std::string text) : text_(std::move(text)) {}
    void render() const override {
        // draw text
    }
};

// 组合节点
class Panel : public UIComponent {
    std::vector<std::unique_ptr<UIComponent>> children_;
public:
    void render() const override {
        for (const auto& child : children_) {
            child->render();  // 多态调用：可能是 Leaf 也可能是 Panel
        }
    }

    void add(std::unique_ptr<UIComponent> child) override {
        children_.push_back(std::move(child));
    }

    void remove(const UIComponent* child) override {
        std::erase_if(children_, [child](const auto& ptr) {
            return ptr.get() == child;
        });
    }
};

// 使用
auto root = std::make_unique<Panel>();
auto panel = std::make_unique<Panel>();
panel->add(std::make_unique<Button>("OK", 10, 20));
panel->add(std::make_unique<Label>("Hello"));
root->add(std::move(panel));
root->add(std::make_unique<Button>("Cancel", 10, 60));

root->render();  // 递归渲染整棵树

// ═══════════════════════════════════════
// 方案 B：arena allocator（减少碎片）
// ═══════════════════════════════════════

// 经典 Composite 每次 add() = 一次 heap 分配
// 大量小节点 → 内存碎片 → 缓存 miss
//
// Arena 策略：预分配一大块内存，所有节点从同一块分

class ArenaComposite {
    struct Node {
        enum class Kind { Leaf, Composite };
        Kind kind;
        void (*render_fn)(void*);  // 函数指针（无虚表开销）
        union {
            struct {
                Node** children;
                size_t count;
                size_t capacity;
            } composite;
            // leaf data 通过 render_fn 闭包捕获
        };
    };

    std::vector<Node> nodes_{}; // 密集存储
    std::vector<std::byte> arena_{}; // 预分配堆

    template<typename T, typename... Args>
    T* alloc(Args&&... args) {
        auto ptr = reinterpret_cast<T*>(
            arena_.data() + arena_offset_
        );
        new (ptr) T(std::forward<Args>(args)...);
        arena_offset_ += sizeof(T);
        return ptr;
    }
    size_t arena_offset_ = 0;
};

// 传统版本：10000 个节点 → x 个独立 malloc
// Arena 版本：10000 个节点 → 1 个 malloc

using ComponentNode = std::variant<Button, Label, Panel>;
// Panel 内部存 std::vector<ComponentNode>
// render() 用 std::visit 分发
// 优点：无虚表、无堆分配（variant 内嵌）
// 缺点：递归 variant 需要辅助包装（Panel 含自身引用）

// 项目里引入了三个第三方库
#include <some_json_lib/json.hpp>
#include <another_db/connection.hpp>
#include <logging_framework/log.hpp>

// 业务代码里到处都是第三方类型
void handle_request(std::string_view raw) {
    auto json = json_lib::parse(raw);           // 第三方类型
    auto conn = db::Connection("localhost");     // 第三方类型
    auto result = conn.query(json.to_string());  // 到处混用
    logging::Logger::global()->log(result);      // 又一个第三方
}

// 想把 json_lib 换成 rapidjson？
// → 416 个文件需要改，34K 处调用

// ═══════════════════════════════════════
// app_facade.hpp — 简洁的门面头文件
// ═══════════════════════════════════════
#pragma once
#include <memory>
#include <string>
#include <string_view>
#include <optional>

namespace app {

// 前向声明，不暴露第三方头文件
struct ConfigResult {
    bool   ok;
    std::string value;
    std::optional<std::string> error;
};

class AppFacade {
public:
    AppFacade();
    ~AppFacade();

    // 禁止拷贝，允许移动
    AppFacade(const AppFacade&) = delete;
    AppFacade& operator=(const AppFacade&) = delete;
    AppFacade(AppFacade&&) noexcept;
    AppFacade& operator=(AppFacade&&) noexcept;

    // 简洁的 API — 调用方不需要知道底层用了什么库
    ConfigResult load_config(std::string_view path);
    bool         connect_db(std::string_view uri);
    std::string  query(std::string_view sql);
    void         log(std::string_view msg, int level);

private:
    struct Impl;
    std::unique_ptr<Impl> impl_;  // 所有第三方库躲在这里
};

} // namespace app

// ═══════════════════════════════════════
// app_facade.cpp — 第三方库的隔离区
// ═══════════════════════════════════════
#include "app_facade.hpp"
#include <simdjson.h>        // json 库
#include <sqlite_orm/sqlite_orm.h> // db 库
#include <spdlog/spdlog.h>   // 日志库

struct app::AppFacade::Impl {
    // 这些第三方类型只存在于 .cpp，不会泄漏到调用方
    std::unique_ptr<spdlog::logger> logger;
    std::unique_ptr<sqlite_orm::storage> db;
};

app::AppFacade::AppFacade() : impl_(std::make_unique<Impl>()) {
    impl_->logger = spdlog::stdout_color_mt("app");
}

app::AppFacade::~AppFacade() = default;

app::ConfigResult app::AppFacade::load_config(std::string_view path) {
    try {
        auto json = simdjson::padded_string(path);
        auto doc  = simdjson::dom::parser{}.parse(json);
        return ConfigResult{true, std::string(doc["key"].get_string()), std::nullopt};
    } catch (const std::exception& e) {
        return ConfigResult{false, "", e.what()};
    }
}

bool app::AppFacade::connect_db(std::string_view uri) {
    // 创建 sqlite_orm db 实例
    return true;
}

std::string app::AppFacade::query(std::string_view sql) {
    // 通过 db 执行查询
    return "{}";
}

void app::AppFacade::log(std::string_view msg, int level) {
    impl_->logger->log(static_cast<spdlog::level::level_enum>(level), msg);
}

Texture tex("huge_4k_texture.png");  // 10MB，加载要 200ms
// 程序启动就加载 → UI 卡白屏
// 但如果用户永远不打开那个文件 → 白加载了

// 本地调用：
auto result = db.query("SELECT * FROM users");
// 生产环境：
// 同样的代码，同样的接口，但对的是远程服务

void delete_user(User* u) {
    db.execute("DELETE FROM users WHERE id=?", u->id);
}
// 所有调用者都能删？需要权限检查

// ═══════════════════════════════════════
// 懒加载代理
// ═══════════════════════════════════════

class Texture {
public:
    virtual ~Texture() = default;
    virtual void draw(int x, int y) = 0;
    virtual int width() const = 0;
    virtual int height() const = 0;
};

class RealTexture : public Texture {
    std::vector<uint8_t> data_;
    int w_, h_;
public:
    RealTexture(std::string_view path) {
        // 实际加载图片：200ms，10MB
        load_from_file(path);
    }
    void draw(int x, int y) override { /* 渲染 */ }
    int width() const override { return w_; }
    int height() const override { return h_; }
};

class LazyTextureProxy : public Texture {
    mutable std::unique_ptr<RealTexture> real_;
    mutable std::once_flag load_flag_;
    std::string path_;
public:
    explicit LazyTextureProxy(std::string path) : path_(std::move(path)) {}

    void ensure_loaded() const {
        std::call_once(load_flag_, [this] {
            real_ = std::make_unique<RealTexture>(path_);
        });
    }

    void draw(int x, int y) override {
        ensure_loaded();  // 首次调用才加载
        real_->draw(x, y);
    }

    int width() const override {
        ensure_loaded();
        return real_->width();
    }

    int height() const override {
        ensure_loaded();
        return real_->height();
    }
};

// 使用：程序启动瞬间返回
auto tex = LazyTextureProxy("4k_bg.png");
// 几秒后，用户打开文件 → 首次调 draw() 才真正加载
tex.draw(0, 0);  // ← 这里才花 200ms

// ═══════════════════════════════════════
// 访问控制代理
// ═══════════════════════════════════════

class ProtectedDBProxy : public IDatabase {
    IDatabase& real_;
    const AuthContext& auth_;
public:
    ProtectedDBProxy(IDatabase& real, const AuthContext& auth)
        : real_(real), auth_(auth) {}

    void delete_user(int id) override {
        if (!auth_.has_permission("users:delete")) { // 访问控制
            throw std::runtime_error("access denied");
        }
        // 审计日志
        log_audit(auth_.user_id(), "delete_user", id);
        // 转发
        real_.delete_user(id);
    }

    std::vector<User> list_users() override {
        // 读操作不需要权限（业务逻辑决定）
        return real_.list_users();
    }
};

// ═══════════════════════════════════════
// 远程代理（简化版）
// ═══════════════════════════════════════

class RemoteDBProxy : public IDatabase {
    std::string endpoint_;
    std::unique_ptr<HttpClient> http_;
public:
    RemoteDBProxy(std::string endpoint)
        : endpoint_(std::move(endpoint))
        , http_(std::make_unique<HttpClient>()) {}

    std::vector<User> list_users() override {
        auto response = http_->get(endpoint_ + "/users");
        return deserialize_users(response.body);
    }

    void delete_user(int id) override {
        auto response = http_->delete_(endpoint_ + "/users/" + std::to_string(id));
        if (response.status != 200)
            throw std::runtime_error("remote error: " + response.body);
    }
};

// 首次加载走完整的初始化路径
// 后续调用只检查 load_flag_（原子变量，不拿锁）
// 等效开销：1 次原子 load（<1ns）

// patterns/structural/flyweight.hpp
#pragma once
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>

namespace patterns::flyweight {

/// 不可变的内在状态（共享部分）
struct TreeModel {
    std::string mesh_data;     // 模型顶点数据
    std::string texture_data;  // 纹理像素
    std::string bark_texture;

    TreeModel(std::string mesh, std::string tex, std::string bark)
        : mesh_data(std::move(mesh)), texture_data(std::move(tex)),
          bark_texture(std::move(bark)) {}

    // 不可拷贝 — 共享数据不应被复制
    TreeModel(const TreeModel&) = delete;
    TreeModel& operator=(const TreeModel&) = delete;
};

/// 享元工厂：管理共享对象池
template <typename Key, typename Shared>
class FlyweightPool {
public:
    template <typename... Args>
    std::shared_ptr<const Shared> acquire(const Key& key, Args&&... args) {
        auto it = pool_.find(key);
        if (it != pool_.end()) {
            return it->second;  // 已存在 → 返回共享实例
        }
        auto obj = std::make_shared<Shared>(std::forward<Args>(args)...);
        pool_.emplace(key, obj);
        return obj;
    }

    size_t size() const { return pool_.size(); }

    void clear() { pool_.clear(); }

private:
    std::unordered_map<Key, std::shared_ptr<const Shared>> pool_;
};

} // namespace patterns::flyweight

using TreePool = patterns::flyweight::FlyweightPool<std::string, TreeModel>;
TreePool trees;

// 第一次 "oak" → 创建新的 TreeModel
auto oak = trees.acquire("oak", "oak_mesh", "oak_tex", "rough");
// 第二次 "oak" → 返回同一个实例
auto oak2 = trees.acquire("oak", "", "", "");  // 后三个参数被忽略
// oak.get() == oak2.get() → true，共享同一个 TreeModel

// 渲染时：外在状态由调用方传入
struct TreeInstance {
    std::shared_ptr<const TreeModel> model;
    float x, y, z;    // 位置（外在）
    float scale;      // 缩放（外在）
    float rotation;   // 旋转（外在）
};

std::vector<TreeInstance> forest;
for (int i = 0; i < 10000; ++i) {
    forest.push_back({
        trees.acquire("oak"),  // 全部共享同一份模型
        randX(), randY(), randZ(),
        1.0f + randScale(),
        randRotation()
    });
}
// 10000 棵树，只有 1 个 TreeModel 对象

template <typename Key, typename Shared>
class ThreadSafeFlyweightPool {
    using ConstPtr = std::shared_ptr<const Shared>;
    std::shared_mutex mutex_;
    std::unordered_map<Key, ConstPtr> pool_;

public:
    template <typename... Args>
    ConstPtr acquire(const Key& key, Args&&... args) {
        {
            std::shared_lock lock(mutex_);
            auto it = pool_.find(key);
            if (it != pool_.end()) return it->second;
        }
        // 未命中：升级为写锁创建
        std::lock_guard lock(mutex_);
        auto it = pool_.find(key);
        if (it != pool_.end()) return it->second;  // 双检查
        auto obj = std::make_shared<Shared>(std::forward<Args>(args)...);
        pool_.emplace(key, obj);
        return obj;
    }
};