// 示意、非可编译；命名空间与头文件对齐 toolflow §7.4 / cpp-headers
#include <vyntek/toolflow/toolflow.hpp>
#include <vyntek/toolflow/registry.hpp>
#include <vyntek/toolflow/run_session.hpp>

using namespace vyntek::toolflow;

ToolRegistry registry;
register_fake_tools(registry);

auto flow = ToolFlow::Create("S01_Single");
auto* c = flow->AddTool(registry.Create("fake_constant", "Const"));
// 配置必填参数（示意）：输出固定 int32
c->SetProperty("Value", Value::Int32(42));
flow->AddOutput("Out", TypeDesc{Type::Int32});
flow->Link(c, "Output", flow->Output("Out"));

std::vector<Diagnostic> diags;
if (!flow->Validate(diags)) { /* 期望空 Error */ return; }

RunSession session(flow.get());
RunResult r = session.Run();
// 断言见下
int out = session.GetOutput<int>("Out");

auto flow = ToolFlow::Create("S02_Chain");
auto* acq  = flow->AddTool(registry.Create("fake_acq", "Acq"));
auto* pass = flow->AddTool(registry.Create("fake_passthrough", "Pass"));
auto* flag = flow->AddTool(registry.Create("fake_constant", "Flag"));

flow->AddOutput("Image", TypeDesc{Type::ImageGray8});
flow->AddOutput("Flag",  TypeDesc{Type::Int32});

flow->Link(acq,  "OutputImage", pass, "InputImage");
flow->Link(pass, "OutputImage", flow->Output("Image"));
flow->Link(flag, "Output",      flow->Output("Flag"));
// 坏链对照（勿留在成功配方）：flow->Link(pass, "OutputImage", acq, "InputImage");
// → Validate 期望 DiagnosticCode::OrderViolation

std::vector<Diagnostic> diags;
assert(flow->Validate(diags));
RunSession session(flow.get());
RunResult r = session.Run();

auto flow = ToolFlow::Create("S03_InspectFake");
auto* acq   = flow->AddTool(registry.Create("fake_acq", "Acq"));
auto* align = flow->AddTool(registry.Create("fake_pm_align", "Align"));
auto* pass  = flow->AddTool(registry.Create("fake_passthrough", "OutImg"));
auto* cnt   = flow->AddTool(registry.Create("fake_constant", "Count"));

flow->AddOutput("PoseX", TypeDesc{Type::Float64});   // 示意：从 Pose 最小字段拆出
flow->AddOutput("DefectCount", TypeDesc{Type::Int32});
flow->AddOutput("Preview", TypeDesc{Type::ImageGray8});

flow->Link(acq,   "OutputImage", align, "InputImage");
flow->Link(align, "OutputImage", pass,  "InputImage");  // 或 Share 输入
flow->Link(pass,  "OutputImage", flow->Output("Preview"));
flow->Link(cnt,   "Output",      flow->Output("DefectCount"));
// Pose → 终端：按 §5.5 最小字段路径（示意）
// flow->Link(align, "Pose.X", flow->Output("PoseX"));

assert(flow->Validate(/*diags*/));
RunSession session(flow.get());
RunResult r = session.Run();

// 输出观察：只读 LastRun / Outputs；不得 session.Run 由观察回调触发
auto preview = session.GetOutput<vyntek::imaging::PixelImageHandle>("Preview");
// 可选：OutputStore 订阅 EmptySnapshot / Unavailable（T10）— 见 output-inspection

#include <vyntek/toolflow/serialize.hpp>

// --- A) 未知 type_id ---
auto bad_unknown = ToolFlow::Load("fixtures/unknown_type.avtf", registry);
// fixtures 内 tools[].type_id = "type_id_not_registered"
assert(!bad_unknown);
// bad_unknown.error() 诊断列表含 DiagnosticCode::UnknownTypeId（Severity::Error）

// --- B) 已知 type、缺必填属性 ---
auto loaded = ToolFlow::Load("fixtures/missing_required.avtf", registry);
assert(loaded);  // Load 成功（type 已知；component_version 不拦）
std::vector<Diagnostic> diags;
bool ok = (*loaded)->Validate(diags);
assert(!ok);
assert(std::any_of(diags.begin(), diags.end(), [](const Diagnostic& d) {
  return d.code == DiagnosticCode::MissingRequiredProperty
      && d.severity == Severity::Error;
}));
// 不得出现「静默填默认后 Validate 成功」

#include <vyntek/imaging/handle.hpp>
#include <vyntek/imaging/factory.hpp>
#include <vyntek/toolflow/toolflow.hpp>
#include <vyntek/toolflow/run_session.hpp>

// 流：Acq → CloneThenWrite → Passthrough → Output 终端
auto flow = ToolFlow::Create("S05_Handle");
auto* acq  = flow->AddTool(registry.Create("fake_acq", "Acq"));
auto* wr   = flow->AddTool(registry.Create("fake_clone_write", "Write"));
auto* pass = flow->AddTool(registry.Create("fake_passthrough", "Share"));
flow->AddOutput("DisplayImage", TypeDesc{Type::ImageGray8});
flow->Link(acq,  "OutputImage", wr,   "InputImage");
flow->Link(wr,   "OutputImage", pass, "InputImage");
flow->Link(pass, "OutputImage", flow->Output("DisplayImage"));

RunSession session(flow.get());
RunResult r = session.Run();
auto handle = session.GetOutput<vyntek::imaging::PixelImageHandle>("DisplayImage");
assert(handle.access() == vyntek::imaging::Access::ReadOnly);
// headless：到此为止；句柄经绑定交给 UI 进程/线程（示意）

// 示意、非可编译；仅 ImageDisplay；像素来自 C++ 句柄经 PInvoke 绑定
// 对齐 csharp-binding / examples.md T12 / image-display
using var bound = ImagingBindings.AdoptReadOnly(nativeHandle); // opaque + Dispose
imageDisplay.SetImage(bound);  // 或 SetImage(projection)
// 取样 / Depth 选项等见 examples.md；不得在此启动 ToolFlow.Run / Cancel 相机

// --- Cancel ---
auto flow_c = ToolFlow::Create("S06_Cancel");
auto* slow = flow_c->AddTool(registry.Create("fake_cancel_check", "C"));
auto* after = flow_c->AddTool(registry.Create("fake_constant", "After"));
flow_c->Link(/*…*/);  // After 在 C 之后
RunSession s1(flow_c.get());
// 另一线程/测试钩：s1.RequestCancel();
RunResult rc = s1.Run();
// 期望：rc.ok==false；diagnostics 含 Cancelled；After 未 Run（LastRun 仍为未跑/跳过）

// --- abort_on_tool_failure ---
auto flow_a = ToolFlow::Create("S06_Abort");
flow_a->set_abort_on_tool_failure(true);
auto* ok1  = flow_a->AddTool(registry.Create("fake_acq", "A"));
auto* fail = flow_a->AddTool(registry.Create("fake_fail_always", "F"));
auto* ok2  = flow_a->AddTool(registry.Create("fake_constant", "Never"));
// Link A→…；F 失败；Never 在 F 后
RunResult ra = RunSession(flow_a.get()).Run();
// 期望：Aborted；Never 未 Run；不得把 F 的 Invalid 图假成功交给下游（H10）

// --- Busy ---
auto flow_b = ToolFlow::Create("S06_Busy");
auto* probe = flow_b->AddTool(registry.Create("fake_busy_probe", "Slow"));
RunSession s2(flow_b.get());
// 线程1：s2.Run() 进行中
// 线程2：RunResult rb = s2.Run();
// 期望：rb 失败；DiagnosticCode::Busy

auto loaded = ToolFlow::Load("recipes/inspect_fake.avtf", registry);
assert(loaded);  // 未知 type / SchemaTooNew 等见 S04
std::unique_ptr<ToolFlow> flow = std::move(*loaded);
RunSession session(flow.get());  // 与 §7.4.5 一致：session 不抢 flow 所有权
for (int i = 0; i < N; ++i) {
  // 可选：注入帧 / 依赖 fake_acq 自产
  RunResult r = session.Run();
  assert(r.ok);
  auto n = session.GetOutput<int>("DefectCount");
  // 记录 n；无 SetImage / 无窗口
}

// 示意薄 PInvoke 入口（对齐 csharp-binding）；编排仍在 C++，非第二套 ToolFlow
ToolFlowNative.RunOnce(sessionHandle); // opaque session handle；不在托管侧重写执行器
using var img = ToolFlowNative.GetOutputImage(sessionHandle, "Preview");
imageDisplay.SetImage(img);
// Cancel / 停相机按停止矩阵分派到编排/采集 API，不进 ImageDisplay

#include <vyntek/toolflow/registry.hpp>
#include <vyntek/toolflow/tool.hpp>
#include <vyntek/imaging/handle.hpp>

// 最小自定义 Tool（示意）
class ScaleGrayTool final : public ITool {
 public:
  std::string_view type_id() const override { return "demo_scale_gray"; }
  ToolRunStatus Run(RunContext& ctx) override {
    auto in = GetProperty("InputImage");  // ReadOnly 句柄
    // Clone → OpenWrite → 缩放填充 → CompleteAndOpenRead → ShareImage → SetProperty OutputImage
    // 定期 ctx.cancel_requested()；失败勿交出未 Complete 句柄
    return ToolRunStatus::Ok;
  }
  // id/name/enabled/properties/Get/Set … 按 §7.6.1
};

void register_demo_tools(ToolRegistry& r) {
  r.Register("demo_scale_gray", [](std::string_view name) {
    return std::make_unique<ScaleGrayTool>(name);
  });
  // 重复 Register 同 type_id → 拒绝
}

// 测试入口
ToolRegistry registry;
register_fake_tools(registry);   // §7.6.3 清单
register_demo_tools(registry);
auto* t = registry.Create("demo_scale_gray", "S");
assert(t);
auto missing = registry.Create("no_such_type", "X");
// 期望失败：UnknownTypeId

// 示意、非可编译；对齐 toolflow §9.3 / §9.4 嵌套示意 / §7.4.6 Encapsulation
auto inner = ToolFlow::Create("InnerLocate");
auto* acq  = inner->AddTool(registry.Create("fake_acq", "Acq"));
auto* pass = inner->AddTool(registry.Create("fake_passthrough", "Share"));
inner->AddOutput("FixturedImage", TypeDesc{Type::ImageGray8});
inner->Link(acq, "OutputImage", pass, "InputImage");
inner->Link(pass, "OutputImage", inner->Output("FixturedImage"));
assert(inner->Validate(/*diags*/));

auto outer = ToolFlow::Create("OuterMeasure");
auto* locate = outer->AddTool(std::move(inner));  // 嵌套；所有权转入 outer
auto* flag  = outer->AddTool(registry.Create("fake_constant", "WidthFlag"));
outer->AddOutput("Preview", TypeDesc{Type::ImageGray8});
outer->AddOutput("Flag", TypeDesc{Type::Int32});
// 合法：外层只链内层终端
outer->Link(locate->Output("FixturedImage"), outer->Output("Preview"));
// 或：outer->Link(outer->Tool("InnerLocate")->Output("FixturedImage"), …);
flag->SetProperty("Value", Value::Int32(1));
outer->Link(flag, "Output", outer->Output("Flag"));

std::vector<Diagnostic> diags;
assert(outer->Validate(diags));
RunResult r = RunSession(outer.get()).Run();
// 期望：r.ok；Preview / Flag 可读；内层私有 Acq 属性对外不可见

// --- Encapsulation 负例（勿留在成功配方）---
// outer->Link(…, /* 指向 */ "InnerLocate.Acq.OutputImage", …);
// 或 Validate 时发现外层 link 写内层私有路径
// → DiagnosticCode::Encapsulation（Severity::Error）；不留下半条边

// --- A) SourceDisabled ---
auto flow_d = ToolFlow::Create("S09b_Disabled");
auto* acq  = flow_d->AddTool(registry.Create("fake_acq", "Acq"));
auto* pass = flow_d->AddTool(registry.Create("fake_passthrough", "Pass"));
flow_d->AddOutput("Image", TypeDesc{Type::ImageGray8});
flow_d->Link(acq, "OutputImage", pass, "InputImage");
flow_d->Link(pass, "OutputImage", flow_d->Output("Image"));
acq->set_enabled(false);  // 或 flow 级 disabled 集合；语义对齐 §4.3
assert(flow_d->Validate(/*diags*/));  // 结构合法；禁用本身不必然 Validate 失败
RunResult rd = RunSession(flow_d.get()).Run();
// 期望：rd.ok==false；diagnostics 含 DiagnosticCode::SourceDisabled；
// Pass 不得假成功交出 Image；下游不得读到「假装有效」的帧

// --- B) InvalidBinding（主断言）---
auto flow_b = ToolFlow::Create("S09b_BadBind");
auto* c = flow_b->AddTool(registry.Create("fake_constant", "C"));
flow_b->AddOutput("Out", TypeDesc{Type::Int32});
// 端点缺失：属性名不存在 / 方向非法（输出←输出、输入→输入）/ 残缺 link
// flow_b->Link(c, "NoSuchProp", flow_b->Output("Out"));
// 或 Load("fixtures/invalid_binding.avtf") 后 Validate
std::vector<Diagnostic> diags;
bool ok = flow_b->Validate(diags);  // 或 Link 立即失败
assert(!ok);
assert(std::any_of(diags.begin(), diags.end(), [](const Diagnostic& d) {
  return d.code == DiagnosticCode::InvalidBinding
      && d.severity == Severity::Error;
}));
// 不留下半条边；与 TypeMismatch / OrderViolation / Encapsulation 分码

// --- A) IoFailure ---
auto truncated = ToolFlow::Load("fixtures/truncated.avtf", registry);
assert(!truncated);
// truncated.error() 诊断含 DiagnosticCode::IoFailure（Severity::Error）
// 对照：未知 type → UnknownTypeId；过高 schema → SchemaTooNew；本项为 IO/截断

// auto save_fail = flow->Save("/root/no_write/out.avtf"); // 示意
// 期望：失败；IoFailure

// --- B) 停相机 ≠ 自动 Cancel（停止矩阵独立步骤）---
auto flow = ToolFlow::Create("S09c_StopCam");
auto* slow = flow->AddTool(registry.Create("fake_busy_probe", "Slow"));
// … 合法最小链 …
RunSession session(flow.get());
// 线程1：RunResult r = session.Run();  // 在途
// 宿主：StopCamera() / CloseAcquisition();  // 采集层；见 camera-acquisition / session-lifecycle
// 期望：session **未**被自动 RequestCancel；r 可跑至工具边界正常结束（或宿主再显式 Cancel）
// 诊断：不得仅因停相机而出现 Cancelled（除非宿主显式既停采集又 RequestCancel）

// 示意：两子流先各自 Validate，再放入外层列表并链终端（§9.2）
auto locate = ToolFlow::Create("Locate");
// … AddTool fake_acq → passthrough；AddOutput FixturedImage / Pose（示意）…
assert(locate->Validate(/*…*/));

auto defect = ToolFlow::Create("Defect");
defect->AddInput("Image", TypeDesc{Type::ImageGray8});
// … 内部 fake 检测；AddOutput OkNg / DefectCount …
assert(defect->Validate(/*…*/));

auto job = ToolFlow::Create("Job");
auto* loc = job->AddTool(std::move(locate));
auto* def = job->AddTool(std::move(defect));
job->Link(loc->Output("FixturedImage"), def->Input("Image"));
// 可选：Pose 终端同理
job->AddOutput("DefectCount", TypeDesc{Type::Int32});
// job->Link(def->Output("DefectCount"), job->Output("DefectCount"));

assert(job->Validate(/*…*/));
RunResult r = RunSession(job.get()).Run();
// 期望：执行序 Locate → Defect；r.ok；终端赋值生效；无环边

// 示意、非可编译；对齐 output-inspection T10 / test-contracts TC-OUT-*（Arden · R9）
using namespace vyntek::toolflow;

ToolRegistry registry;
register_fake_tools(registry);

// --- A: KeepLatest ---
auto flow = ToolFlow::Create("S10_OutObserve");
auto* c = flow->AddTool(registry.Create("fake_constant", "Const"));
c->SetProperty("Value", Value::Int32(1));
flow->AddOutput("Out", TypeDesc{Type::Int32});
flow->Link(c, "Output", flow->Output("Out"));
// session_opts.retain = KeepLatest;  // 示意

assert(flow->Validate(/*…*/));
RunSession session(flow.get());

std::vector<OutputSetEventKind> seen;
auto sub = session.SubscribeOutputs(
    [&](const OutputSetEvent& e) {
        seen.push_back(e.kind);
        // 禁止：在回调内 session.Run() / 重新采集 / 隐式链接赋值
    },
    /*replay_latest=*/true);

RunResult r1 = session.Run();           // 非空成功 → 期望 SnapshotReplaced
// 配置空成功替身（示意）：c->SetProperty("EmitEmpty", true);
RunResult r_empty = session.Run();      // 空成功 → 必须 EmptySnapshot（禁静默）

// 失败保留：先成功再 fail_once
auto* f = flow->AddTool(registry.Create("fake_fail_once", "Fail"));
// … 使本轮失败 …
RunResult r_fail = session.Run();       // 不替换上次成功快照；可与失败状态并存

// Unavailable：模拟保留/配额失败（观察侧注入，示意）
// expect Unavailable；业务路由仍可 ok，但不得把旧集合冒充本轮新结果

// Evict + 查看者寿命
auto opened = session.TryOpenLatest(/*tool/port 示意*/);
session.EvictRetained(/*…*/);           // 或预算回收 → Evicted
// opened 仍可用至自行关闭；TryOpenLatest 对新身份不可用

sub.reset();  // 断开只释放订阅，不清空运行时最近输出（KeepLatest）

// --- B: ReleaseAfterRouting ---
// session_opts.retain = ReleaseAfterRouting;
// Run 后路由完成即不保留；再 Subscribe 无法补取已回收历史

// 示意、非可编译；对齐 camera-acquisition / session-lifecycle / test-contracts TC-ACQ-* · TC-SESS-*（Arden · R10）
using namespace vyntek::imaging;

// --- A: 持帧 ImportNative ---
FakeSdkSession sdk(/*hold_frame=*/true);
auto img = adapter.ImportNativeReadOnly(sdk.CurrentFrame());  // TC-ACQ-01
bool ok = input.TryPostOwned(std::move(img));                 // TC-ACQ-03
assert(ok);
// Share 不重复 AddRef SDK；关闭最后句柄 → releaseAsync → 泵上 ReturnCompleted（TC-ACQ-05）

// --- B: 回调内 Copy ---
FakeSdkSession sdk2(/*hold_frame=*/false);
sdk2.OnFrame([](void* p, size_t n) {
  // 先取池+入口预算（TC-ACQ-04）；满则拒绝，禁止先拷再发现无容量
  auto owned = PixelImage::CopyFrom(p, n);
  if (!input.TryPostOwned(std::move(owned))) { /* 关闭未接管 */ }
  // 按协议立即归还临时 SDK 缓冲（TC-ACQ-02）
  // 禁止在回调内等 UI / 算法 / 同线程 ReturnCompleted（TC-ACQ-07）
});

// --- C: Latest 预览 ---
for (int i = 0; i < 10; ++i) { /* 连续 Post */ }
// Latest 槽只保留最新；被替换项立即关闭；禁止无限 Post 带图 dispatcher（TC-ACQ-06）

// --- D: 停流结束条件 ---
session.BeginStop(/*drain=*/true);  // Quiescing → … → Stopped（TC-SESS-01）
// 无新回调、队列空、会话拥有引用已关、SDK 归还完成

// --- E: 外保留 ---
auto exported = host.ExportToExternalWindow(latest);  // 会话外保留
auto r = session.BeginStop(/*destroy_sdk=*/true);
// expect：报告仍有外部保留；不得假称设备已归还（TC-SESS-02）

// --- F: 超时续清 ---
auto r_to = session.BeginStop(/*timeout=*/50ms);
// 返回未排空/故障摘要；底层清理仍继续（TC-SESS-03）

// --- G: ReturnFailed / 断线 ---
sdk.InjectReturnFailed();  // 或 InjectDisconnect()
// 可观察故障；不自动再 Release；泵继续其他项；停止结果汇总（TC-SESS-04）

// --- H: 两端都停 ---
// 宿主要相机与 Run 一起停：必须显式
acquisition.StopAccepting();          // 停采集
run_session.RequestCancel();          // 显式 Cancel（TC-SESS-05 / TC-CTL-04）
// 禁止假设一次 SDK.Stop = 三层全停

// 示意、非可编译；对齐 memory-management / test-contracts TC-MEM-*（Arden · R11）
using namespace vyntek::imaging;

// --- A: 工厂接管 ---
auto rented = ImageBuffer::Rent(4096);           // TC-MEM-01 成功接管
// TakeOwnership 抛错路径：owner 仍由调用方释放（TC-MEM-02）
// ImportNative 抛错路径：不调 release（TC-MEM-03）

// --- B: 最后引用 ---
auto h1 = rented.Share();
auto h2 = rented.Share();
h1.Dispose();  // 仍 Active（TC-MEM-04）
// 关闭全部 handle + 访问 + 排队申请后才 Returning
// 禁止：持最后引用边 AwaitReturnCompleted（TC-MEM-05）

// --- C: pin ---
auto reader = rented.OpenRead().value();
auto pin = reader.Pin();
reader.Dispose();  // pin 仍阻写/归还；pin.access()==ReadOnly（TC-MEM-06）
pin.Dispose();

auto writer = rented.OpenWrite().value();
auto wpin = writer.Pin();
// writer.Complete() → InvalidOperation（写 pin 未放）（TC-MEM-07）
wpin.Dispose();
writer.Complete();

// --- D: 授予/取消与 Share/Dispose ---
// OpenRead/OpenWrite + CancelToken；发起 handle Dispose 不撤已入队申请（TC-MEM-08）
// Share 与 Dispose 竞争：成功子对象独立有效（TC-MEM-09）

// --- E: 初始化 / Invalid ---
{
  auto w = ImageBuffer::Rent(4096).OpenWrite().value();
  w.Dispose();  // 未 Complete → Invalid（TC-MEM-10）
}
// 类型化首次仅写 ROI → 拒绝；ROI 中止 → 整实体 Invalid（TC-MEM-11）
// Invalid 后带 expectedVersion 的 OpenWrite 拒绝；无期望版本完整写可恢复（TC-MEM-12）

// --- F: 归还隔离 ---
// 两实体并行归还；其一 releaseAsync 卡住/失败
// expect：恰好一次 release；不串行堵另一项；ReturnFailed 不自动重试、不回池（TC-MEM-13）

// 示意、非可编译；对齐 image-display / test-contracts TC-DISP-*（Arden · R12）
// 像素已由绑定层从 C++ 句柄投影为 IPixelImage

var update = viewer.SetImage(image);           // TC-DISP-01：登记+Share；未承诺已 OpenRead
// 调用方随后可关闭自有 handle；控件不接管（TC-DISP-02）

var retain = viewer.SetImage(rwImage, ImageInputRetention.RetainInput);
// 原地写须等读者退出（TC-DISP-03）

var snap = viewer.SetImage(rwImage, ImageInputRetention.Snapshot);
await snap.Completion; await snap.InputReleased;  // 释放后原图可写；屏幕可仍旧图（TC-DISP-04）
var detach = await retain.DetachInputAsync();     // Released 或 CpuBudgetExceeded 不毁当前（TC-DISP-05）

// Completion / InputReleased / ImageRendered / ReturnCompleted 分别断言，互不等价（TC-DISP-06）
// 注入 VersionMismatch / UnsupportedImage → Failed，旧画面保留（TC-DISP-07）

viewer.SetImage(gray);  pixel.TryGetGray8(...);   // 仅相符格式成功（TC-DISP-08）
viewer.SetImage(rgb);   pixel.TryGetRgb24(...);   // 无隐式转换
viewer.SetImage(bgr);   pixel.TryGetBgr24(...);
viewer.SetImage(depth); pixel.TryGetDepth16(...);

viewer.TryGetPixel(viewPos, out var p);           // ROI/负步长→逻辑坐标（TC-DISP-09）

// 卸载 → 取消候选；重挂载仍有效 Source = 新请求（TC-DISP-10）
// 预算不足 → Failed + 保留旧图（TC-DISP-11）
// Dispose / ClearImageAsync → 不停 Run、不停相机（TC-DISP-12 / TC-CTL-05）