from dataclasses import dataclass, field

@dataclass
class PipelineDefinition:
    name: str                           # 流水线名称
    steps: list[StepDefinition]         # 步骤列表（有序）
    description: str = ""               # 描述
    crs: str | None = None              # 默认 CRS
    variables: dict = field(default_factory=dict)   # 变量
    outputs: dict = field(default_factory=dict)      # 输出声明

PipelineDefinition(
    name="缓冲区分析",
    description="对道路进行缓冲区分析",
    crs="EPSG:4326",
    variables={"dist": 500},
    steps=[
        StepDefinition(id="read", use="io.read_vector", params={"path": "data/roads.shp"})
    ],
    outputs={"result": "$read.output"}
)

@dataclass
class StepDefinition:
    id: str                         # 唯一标识符
    use: str                        # 步骤类型（registry ID）
    params: dict = field(default_factory=dict)   # 参数
    when: str | None = None         # 条件执行表达式
    on_error: str = "fail"          # 错误策略：fail/skip/retry
    backend: str | None = None      # 指定后端

    def __post_init__(self):
        if self.params is None:
            self.params = {}

from typing import Any

@dataclass
class StepResult:
    output: Any = None              # 主要输出数据
    stats: dict = field(default_factory=dict)    # 统计信息
    metadata: dict = field(default_factory=dict) # 元数据

StepResult(
    output=result_gdf,
    stats={
        "feature_count": 100,
        "total_area": 12345.67,
    }
)

def __getattr__(self, name: str) -> Any:
    if name.startswith("_"):
        raise AttributeError(name)
    if name in self.stats:
        return self.stats[name]
    if name in self.metadata:
        return self.metadata[name]
    raise AttributeError(
        f"StepResult has no attribute '{name}'. "
        f"Available: output, stats={list(self.stats.keys())}, "
        f"metadata={list(self.metadata.keys())}"
    )

def summary(self) -> dict:
    summary = {}
    if self.output is not None:
        try:
            # GeoDataFrame 摘要
            summary["feature_count"] = len(self.output)
            if hasattr(self.output, "crs") and self.output.crs:
                summary["crs"] = str(self.output.crs)
            if hasattr(self.output, "geometry"):
                summary["geometry_types"] = list(
                    self.output.geometry.geom_type.unique()
                )
        except (TypeError, AttributeError):
            summary["type"] = type(self.output).__name__
    summary.update(self.stats)
    return summary

result = StepResult(
    output=gdf,  # 100 个 Point 要素，CRS=EPSG:4326
    stats={"total_area": 12345.67}
)

result.summary()
# {
#     "feature_count": 100,
#     "crs": "EPSG:4326",
#     "geometry_types": ["Point"],
#     "total_area": 12345.67
# }

class _StepInfo:
    def __init__(
        self,
        id: str,            # 步骤 ID（如 "vector.buffer"）
        func: Callable,     # 步骤函数
        name: str = "",     # 显示名称
        description: str = "",  # 描述
        category: str = "", # 类别
        params: dict | None = None,    # 参数 schema
        outputs: dict | None = None,   # 输出 schema
        backends: list[str] | None = None,  # 支持的后端
        examples: list[dict] | None = None, # 使用示例
    ):
        ...

params={
    "input": {
        "type": "geodataframe",    # 参数类型
        "required": True,          # 是否必需
        "description": "输入矢量数据",
    },
    "distance": {
        "type": "number",
        "required": True,
        "description": "缓冲区距离",
    },
    "cap_style": {
        "type": "string",
        "required": False,
        "default": "round",
        "enum": ["round", "flat", "square"],
        "description": "端点样式",
    },
}

def to_dict(self) -> dict:
    return {
        "id": self.id,
        "name": self.name,
        "description": self.description,
        "category": self.category,
        "params": self.params,
        "outputs": self.outputs,
        "backends": self.backends,
        "examples": self.examples,
    }

class PipelineContext:
    def __init__(self, variables: dict | None = None):
        self.variables: dict = dict(variables or {})
        self._step_outputs: dict[str, StepResult] = {}

def resolve_params(self, params: dict) -> dict:
    resolved = {}
    for key, value in params.items():
        if isinstance(value, dict):
            resolved[key] = self.resolve_params(value)    # 递归处理字典
        elif isinstance(value, list):
            resolved[key] = [self.resolve(v) for v in value]  # 处理列表
        else:
            resolved[key] = self.resolve(value)            # 处理标量
    return resolved

class StepContext:
    def __init__(self, params, backend=None, pipeline_context=None):
        self._params = params       # 已解析的参数
        self.backend = backend      # 当前后端实例
        self.pipeline_context = pipeline_context

    def param(self, name, default=None):
        """获取参数值"""
        return self._params.get(name, default)

    def input(self, name="input"):
        """获取输入数据（快捷方式）"""
        return self._params.get(name)

    @property
    def params(self):
        return self._params

@step(id="vector.buffer", ...)
def vector_buffer(ctx: StepContext) -> StepResult:
    gdf = ctx.input("input")           # 获取输入数据
    distance = ctx.param("distance")    # 获取参数
    cap_style = ctx.param("cap_style", "round")  # 获取带默认值的参数

    result = ctx.backend.buffer(gdf, distance, cap_style=cap_style)

    return StepResult(output=result, stats={...})

class GeopipeAgentError(Exception):
    """基类异常"""

class PipelineParseError(GeopipeAgentError):
    """YAML 解析错误"""

class PipelineValidationError(GeopipeAgentError):
    """流水线验证错误"""

class StepExecutionError(GeopipeAgentError):
    """步骤执行错误"""
    def __init__(self, step_id, message, cause=None, suggestion=None):
        self.step_id = step_id         # 失败的步骤 ID
        self.suggestion = suggestion   # AI 修复建议
        self.cause = cause             # 原始异常

    def to_dict(self) -> dict:
        """转为 JSON 格式（AI 友好）"""
        result = {
            "error": "StepExecutionError",
            "step_id": self.step_id,
            "message": str(self),
        }
        if self.suggestion:
            result["suggestion"] = self.suggestion
        if self.cause:
            result["cause"] = str(self.cause)
        return result

class BackendNotAvailableError(GeopipeAgentError):
    """后端不可用"""

class StepNotFoundError(GeopipeAgentError):
    """步骤未注册"""

class VariableResolutionError(GeopipeAgentError):
    """变量或引用解析错误"""