from pydantic import BaseModel, field_validator

class StepDefinition(BaseModel):
    """单个步骤的配置。"""
    id: str                         # 步骤唯一 ID
    use: str                        # 步骤类型（如 "vector.buffer"）
    params: dict = {}              # 步骤参数（含引用字符串）
    when: str | None = None        # 条件表达式
    on_error: str = "fail"         # 错误策略：fail / skip / retry
    backend: str | None = None     # 指定后端（None 使用默认）

    @field_validator("on_error")
    @classmethod
    def validate_on_error(cls, v):
        allowed = {"fail", "skip", "retry"}
        if v not in allowed:
            raise ValueError(f"on_error 必须是 {allowed} 之一，当前值：{v!r}")
        return v

class PipelineDefinition(BaseModel):
    """完整的流水线配置模型。"""
    name: str                              # 流水线名称（必填）
    description: str | None = None        # 可选描述
    crs: str | None = None                # 默认 CRS
    variables: dict = {}                  # 全局变量
    steps: list[StepDefinition] = []      # 步骤列表
    outputs: dict[str, str] = {}          # 输出映射 {名称: 步骤引用}

from dataclasses import dataclass, field
from typing import Any

@dataclass
class StepResult:
    """步骤执行结果。"""
    output: Any = None              # 主要输出（GeoDataFrame、raster dict 等）
    stats: dict = field(default_factory=dict)  # 统计信息
    issues: list["QcIssue"] = field(default_factory=list)  # 质检问题列表
    
    # 快捷属性（与 output 同步）
    @property
    def crs(self) -> str | None:
        """获取输出数据的 CRS。"""
        if hasattr(self.output, "crs") and self.output is not None:
            return str(self.output.crs)
        return self.stats.get("crs")
    
    @property
    def feature_count(self) -> int:
        """获取输出数据的要素数量。"""
        if hasattr(self.output, "__len__"):
            return len(self.output)
        return self.stats.get("feature_count", 0)
    
    @property
    def geometry_type(self) -> str | None:
        """获取几何类型。"""
        return self.stats.get("geometry_type")
    
    # 质检结果快捷属性
    @property
    def issue_count(self) -> int:
        return len(self.issues)
    
    @property
    def passed(self) -> bool:
        return self.issue_count == 0
    
    def summary(self) -> dict:
        """生成 JSON 可序列化的摘要，用于报告。"""
        return {
            "type": type(self.output).__name__ if self.output is not None else "None",
            "feature_count": self.feature_count,
            "crs": self.crs,
            **self.stats,
        }

from dataclasses import dataclass
from typing import Any

@dataclass
class QcIssue:
    """质检发现的单个问题。"""
    type: str           # 问题类型（如 "self_intersection"、"missing_crs"）
    message: str        # 问题描述（人类可读）
    fid: Any = None     # 相关要素的 ID（矢量质检）
    location: Any = None  # 问题的地理位置（如有）
    severity: str = "error"   # 严重程度：error / warning / info
    
    def to_dict(self) -> dict:
        """转为字典，用于 JSON 报告。"""
        return {
            "type": self.type,
            "message": self.message,
            "fid": self.fid,
            "severity": self.severity,
        }

@step(id="qc.geometry_validity", ...)
def geometry_validity_step(ctx: StepContext) -> StepResult:
    gdf = ctx.input()
    issues = []
    
    for idx, row in gdf.iterrows():
        if row.geometry is None:
            issues.append(QcIssue(
                type="empty_geometry",
                message=f"要素 {idx} 的几何为空",
                fid=idx,
                severity="error"
            ))
        elif not row.geometry.is_valid:
            issues.append(QcIssue(
                type="self_intersection",
                message=f"要素 {idx} 存在自相交",
                fid=idx,
                severity="error"
            ))
    
    return StepResult(
        output=gdf,
        stats={"checked_count": len(gdf), "issue_count": len(issues)},
        issues=issues
    )

class GeopipeAgentError(Exception):
    """GeoPipeAgent 所有自定义异常的基类。"""
    
    def to_dict(self) -> dict:
        """转为 JSON 可序列化的错误字典，用于输出到 stderr。"""
        return {
            "error": type(self).__name__,
            "message": str(self),
        }

class PipelineParseError(GeopipeAgentError):
    pass

# 抛出示例
raise PipelineParseError(
    f"无法解析流水线文件 '{file_path}'：{yaml_error}"
)

class PipelineValidationError(GeopipeAgentError):
    pass

# 抛出示例
raise PipelineValidationError(
    f"步骤 ID '{step_id}' 重复。流水线中每个步骤的 ID 必须唯一。"
)

class StepExecutionError(GeopipeAgentError):
    def __init__(
        self,
        step_id: str,
        message: str,
        cause: Exception | None = None,
        suggestion: str | None = None,   # AI 友好的修复建议
    ):
        self.step_id = step_id
        self.message = message
        self.cause = cause
        self.suggestion = suggestion
        super().__init__(f"步骤 '{step_id}' 执行失败：{message}")
    
    def to_dict(self) -> dict:
        result = {
            "error": "StepExecutionError",
            "step_id": self.step_id,
            "message": self.message,
        }
        if self.suggestion:
            result["suggestion"] = self.suggestion
        if self.cause:
            result["cause"] = str(self.cause)
        return result

class VariableResolutionError(GeopipeAgentError):
    pass

# 抛出示例（变量未定义）
raise VariableResolutionError(
    f"变量 '$' 未定义。可用变量：{list(self.variables.keys())}"
)

# 抛出示例（步骤引用不存在）
raise VariableResolutionError(
    f"步骤引用 '$load-roads' 失败：步骤 'load-roads' 无输出。"
    f"可用步骤输出：{list(self._step_outputs.keys())}"
)

class BackendError(GeopipeAgentError):
    def __init__(self, backend_name: str, message: str):
        self.backend_name = backend_name
        super().__init__(f"后端 '{backend_name}' 错误：{message}")

try:
    report = execute_pipeline(pipeline)
    click.echo(json.dumps(report, indent=2))  # 成功：报告输出到 stdout
except GeopipeAgentError as e:
    # 已知框架错误：JSON 格式输出到 stderr
    click.echo(json.dumps(e.to_dict(), indent=2), err=True)
    sys.exit(1)
except Exception as e:
    # 未知错误：包装后输出
    click.echo(json.dumps({"error": "UnexpectedError", "message": str(e)}), err=True)
    sys.exit(1)