# PipelineContext 的引用解析
def _resolve_step_ref(self, value: str):
    if value.startswith("$") and "." not in value[1:]:
        # $step_id 简写 → 返回 step_result.output
        step_id = value[1:]
        result = self.get_output(step_id)
        return result.output

@dataclass
class StepResult:
    output: any = None              # 主要输出数据
    stats: dict = field(default_factory=dict)     # 统计信息
    metadata: dict = field(default_factory=dict)  # 元数据
    issues: list[QcIssue] = field(default_factory=list)  # QC 问题

# QcIssue 数据类 (models/qc.py)
@dataclass
class QcIssue:
    rule_id: str                    # 规则 ID，如 "invalid_geometry"
    severity: str                   # 严重等级：error/warning/info
    feature_index: int | None       # 问题要素的索引
    message: str                    # 问题描述
    geometry: any = None            # 问题几何
    details: dict = field(default_factory=dict)  # 详细信息

class PipelineContext:
    def resolve(self, value):
        """递归解析值中的所有引用"""
        if isinstance(value, str):
            return self._resolve_string(value)
        elif isinstance(value, dict):
            return {k: self.resolve(v) for k, v in value.items()}
        elif isinstance(value, list):
            return [self.resolve(item) for item in value]
        return value  # 数字、布尔等基本类型直接返回

    def _resolve_string(self, value: str):
        """解析字符串中的引用"""
        # 先尝试步骤引用
        resolved = self._resolve_step_ref(value)
        if resolved is not value:
            return resolved

        # 再处理变量替换
        return self._substitute_variables(value)

import re

class PipelineContext:
    # 匹配 $step_id 或 $step_id.attr
    _STEP_REF_PATTERN = re.compile(r'^\$([a-z0-9_-]+)(?:\.(\w+))?$')

    def _resolve_step_ref(self, value: str):
        """解析步骤引用 $step_id 或 $step_id.attr"""
        match = self._STEP_REF_PATTERN.match(value.strip())
        if not match:
            return value  # 不是步骤引用，原样返回

        step_id = match.group(1)   # 步骤 ID
        attr = match.group(2)      # 属性名（可能为 None）

        # 获取步骤结果
        if step_id not in self._step_outputs:
            raise VariableResolutionError(
                f"Referenced step '{step_id}' not found. "
                f"Available steps: {list(self._step_outputs.keys())}"
            )

        result = self._step_outputs[step_id]

        if attr is None:
            # $step_id 简写 → 返回 output
            return result.output
        elif hasattr(result, attr):
            # $step_id.attr → 返回指定属性
            return getattr(result, attr)
        else:
            raise VariableResolutionError(
                f"StepResult has no attribute '{attr}'. "
                f"Available: output, stats, metadata, issues"
            )

class PipelineContext:
    # 匹配 ${var_name}
    _VAR_PATTERN = re.compile(r'\$\{(\w+)\}')

    def _substitute_variables(self, value: str):
        """替换字符串中的 ${var} 变量引用"""
        def replacer(match):
            var_name = match.group(1)
            if var_name not in self.variables:
                raise VariableResolutionError(
                    f"Variable '$}' not defined. "
                    f"Available variables: {list(self.variables.keys())}"
                )
            return str(self.variables[var_name])

        result = self._VAR_PATTERN.sub(replacer, value)

        # 如果整个字符串就是一个变量引用，保持原始类型
        full_match = re.fullmatch(r'\$\{(\w+)\}', value)
        if full_match:
            var_name = full_match.group(1)
            return self.variables[var_name]  # 返回原始类型

        return result  # 包含其他文本时返回字符串

# resolve() 处理字典参数
params = {
    "input": "$load",
    "options": {
        "crs": "${crs}",
        "simplify": True,
        "tolerance": "${tolerance}"
    }
}

# 递归解析后：
resolved_params = {
    "input": <GeoDataFrame>,          # $load → StepResult.output
    "options": {
        "crs": "EPSG:4326",           # ${crs} → "EPSG:4326"
        "simplify": True,             # 布尔值直接保留
        "tolerance": 0.001            # ${tolerance} → 0.001
    }
}

# 原始参数
params = {
    "input": "$load",
    "columns": ["${col1}", "${col2}", "population"]
}

# 解析后
resolved = {
    "input": <GeoDataFrame>,
    "columns": ["name", "area", "population"]
}

# executor.py 中的变量合并逻辑
def execute_pipeline(self, pipeline: PipelineDefinition,
                     var_overrides: dict = None):
    # 合并变量：CLI --var 覆盖 YAML variables
    variables = {
        **pipeline.variables,       # YAML 中定义的变量
        **(var_overrides or {}),     # CLI --var 覆盖
    }
    context = PipelineContext(variables=variables)

# cli.py 中 run 命令的定义（基于 Click）
@cli.command()
@click.argument("pipeline_file", type=click.Path(exists=True))
@click.option("--var", multiple=True, help="Override variable: key=value")
@click.option("--backend", default=None, help="Preferred backend")
def run(pipeline_file, var, backend):
    """Run a pipeline from YAML file"""
    # 解析 --var 参数
    var_overrides = {}
    for v in var:
        key, _, value = v.partition("=")
        var_overrides[key.strip()] = _parse_value(value.strip())

    # 解析流水线
    pipeline = Parser.parse_yaml(pipeline_file)

    # 执行
    executor = Executor(preferred_backend=backend)
    report = executor.execute_pipeline(pipeline, var_overrides)

    # 输出报告
    print(json.dumps(report, indent=2, default=str))

def _parse_value(value: str):
    """将 CLI 字符串值解析为合适的 Python 类型"""
    # 布尔值
    if value.lower() in ("true", "yes"):
        return True
    if value.lower() in ("false", "no"):
        return False

    # 整数
    try:
        return int(value)
    except ValueError:
        pass

    # 浮点数
    try:
        return float(value)
    except ValueError:
        pass

    # 字符串
    return value

class VariableResolutionError(GeoPipeAgentError):
    """变量或步骤引用解析失败"""
    pass

def _check_step_references(self, steps):
    defined = set()
    for step in steps:
        # 检查参数中引用的步骤是否已定义
        refs = self._extract_step_refs(step.params)
        for ref in refs:
            if ref not in defined:
                raise ValidationError(
                    f"Step '{step.id}' references '{ref}' "
                    f"which is not defined before it"
                )
        defined.add(step.id)