# geopipeagent/steps/qc/_helpers.py

def build_qc_result(gdf, issues, stats=None):
    """构建 QC 步骤的标准返回结果

    Args:
        gdf: 原始输入数据（透传）
        issues: QcIssue 列表
        stats: 额外统计信息

    Returns:
        StepResult: 包含透传数据和质检问题
    """
    issues_gdf = _issues_to_geodataframe(issues, crs=gdf.crs)

    base_stats = {
        "feature_count": len(gdf),
        "issue_count": len(issues),
        "error_count": sum(1 for i in issues if i.severity == "error"),
        "warning_count": sum(1 for i in issues if i.severity == "warning"),
    }
    if stats:
        base_stats.update(stats)

    return StepResult(
        output=gdf,          # 数据原样透传
        stats=base_stats,
        issues=issues,       # 问题列表
    )

from dataclasses import dataclass, field
from typing import Any

@dataclass
class QcIssue:
    rule_id: str                        # 规则标识
    severity: str                       # 严重级别
    feature_index: int | None = None    # 要素索引
    message: str = ""                   # 问题描述
    geometry: Any = None                # 问题几何
    details: dict = field(default_factory=dict)  # 扩展信息

issue = QcIssue(
    rule_id="geometry_validity",
    severity="error",
    feature_index=7,
    message="Self-intersection detected",
    geometry=Point(116.39, 39.91),
    details={"type": "self_intersection"},
)

issue.to_dict()
# {
#     "rule_id": "geometry_validity",
#     "severity": "error",
#     "feature_index": 7,
#     "message": "Self-intersection detected",
#     "geometry": "POINT (116.39 39.91)",
#     "details": {"type": "self_intersection"}
# }

@step(id="qc.geometry_validity", ...)
def geometry_validity(ctx):
    gdf = ctx.input("input")
    auto_fix = ctx.param("auto_fix") or False
    severity = ctx.param("severity") or "error"

    issues = []
    result_gdf = gdf.copy()

    for idx, row in gdf.iterrows():
        geom = row.geometry

        # 检查空几何
        if geom is None or geom.is_empty:
            issues.append(QcIssue(
                rule_id="geometry_validity",
                severity=severity,
                feature_index=idx,
                message="Empty or null geometry",
                details={"type": "empty_geometry"},
            ))
            continue

        # 检查几何有效性（含自相交）
        if not geom.is_valid:
            reason = shapely.validation.explain_validity(geom)
            issues.append(QcIssue(
                rule_id="geometry_validity",
                severity=severity,
                feature_index=idx,
                message=f"Invalid geometry: {reason}",
                geometry=geom,
                details={"type": "invalid", "reason": reason},
            ))

            # 自动修复
            if auto_fix:
                from shapely.validation import make_valid
                result_gdf.at[idx, "geometry"] = make_valid(geom)

    output = result_gdf if auto_fix else gdf
    return build_qc_result(output, issues)

@step(id="qc.crs_check", ...)
def crs_check(ctx):
    gdf = ctx.input("input")
    expected_crs = ctx.param("expected_crs")

    issues = []

    # 检查 CRS 是否存在
    if gdf.crs is None:
        issues.append(QcIssue(
            rule_id="crs_check",
            severity="error",
            message="CRS is not defined",
        ))
    elif expected_crs:
        # 检查 CRS 是否匹配
        from pyproj import CRS
        expected = CRS.from_user_input(expected_crs)
        if gdf.crs != expected:
            issues.append(QcIssue(
                rule_id="crs_check",
                severity="error",
                message=f"CRS mismatch: expected {expected_crs}, "
                        f"got {gdf.crs.to_epsg() or gdf.crs}",
                details={
                    "expected": expected_crs,
                    "actual": str(gdf.crs),
                },
            ))

    return build_qc_result(gdf, issues)

@step(id="qc.attribute_completeness", ...)
def attribute_completeness(ctx):
    gdf = ctx.input("input")
    required_fields = ctx.param("required_fields")
    severity = ctx.param("severity") or "error"

    issues = []

    for field_name in required_fields:
        # 检查字段是否存在
        if field_name not in gdf.columns:
            issues.append(QcIssue(
                rule_id="attribute_completeness",
                severity=severity,
                message=f"Required field '{field_name}' not found in data",
                details={"field": field_name, "type": "missing_field"},
            ))
            continue

        # 检查空值
        for idx, value in gdf[field_name].items():
            if value is None or (isinstance(value, float) and
                                  pd.isna(value)) or value == "":
                issues.append(QcIssue(
                    rule_id="attribute_completeness",
                    severity=severity,
                    feature_index=idx,
                    message=f"Field '{field_name}' is null or empty",
                    geometry=gdf.geometry.iloc[idx]
                        if idx < len(gdf) else None,
                    details={
                        "field": field_name,
                        "value": str(value),
                    },
                ))

    return build_qc_result(gdf, issues)

@step(id="qc.attribute_domain", ...)
def attribute_domain(ctx):
    import re

    gdf = ctx.input("input")
    field_name = ctx.param("field")
    allowed_values = ctx.param("allowed_values")
    pattern = ctx.param("pattern")

    issues = []

    for idx, value in gdf[field_name].items():
        if value is None or (isinstance(value, float) and pd.isna(value)):
            continue  # 空值由 attribute_completeness 检查

        if allowed_values and value not in allowed_values:
            issues.append(QcIssue(
                rule_id="attribute_domain",
                severity="error",
                feature_index=idx,
                message=f"Value '{value}' not in allowed values "
                        f"for field '{field_name}'",
                details={
                    "field": field_name,
                    "value": value,
                    "allowed": allowed_values,
                },
            ))

        if pattern and not re.match(pattern, str(value)):
            issues.append(QcIssue(
                rule_id="attribute_domain",
                severity="error",
                feature_index=idx,
                message=f"Value '{value}' does not match pattern "
                        f"'{pattern}' for field '{field_name}'",
                details={
                    "field": field_name,
                    "value": value,
                    "pattern": pattern,
                },
            ))

    return build_qc_result(gdf, issues)

@step(id="qc.value_range", ...)
def value_range(ctx):
    gdf = ctx.input("input")
    field_name = ctx.param("field")
    min_val = ctx.param("min")
    max_val = ctx.param("max")
    severity = ctx.param("severity") or "error"

    issues = []

    for idx, value in gdf[field_name].items():
        if value is None or (isinstance(value, float) and pd.isna(value)):
            continue

        numeric_val = float(value)
        if min_val is not None and numeric_val < min_val:
            issues.append(QcIssue(
                rule_id="value_range",
                severity=severity,
                feature_index=idx,
                message=f"Value {numeric_val} < min {min_val} "
                        f"for field '{field_name}'",
                details={"field": field_name, "value": numeric_val,
                         "min": min_val},
            ))
        if max_val is not None and numeric_val > max_val:
            issues.append(QcIssue(
                rule_id="value_range",
                severity=severity,
                feature_index=idx,
                message=f"Value {numeric_val} > max {max_val} "
                        f"for field '{field_name}'",
                details={"field": field_name, "value": numeric_val,
                         "max": max_val},
            ))

    return build_qc_result(gdf, issues)

@step(id="qc.duplicate_check", ...)
def duplicate_check(ctx):
    gdf = ctx.input("input")
    check_geometry = ctx.param("check_geometry")
    if check_geometry is None:
        check_geometry = True
    check_fields = ctx.param("check_fields")
    tolerance = ctx.param("tolerance") or 0.0

    issues = []
    seen = {}  # 用于跟踪已见过的要素

    for idx, row in gdf.iterrows():
        key_parts = []

        if check_geometry and row.geometry is not None:
            if tolerance > 0:
                geom_key = row.geometry.simplify(tolerance).wkt
            else:
                geom_key = row.geometry.wkt
            key_parts.append(geom_key)

        if check_fields:
            field_key = tuple(row[f] for f in check_fields)
            key_parts.append(str(field_key))

        key = "|".join(key_parts)

        if key in seen:
            issues.append(QcIssue(
                rule_id="duplicate_check",
                severity="warning",
                feature_index=idx,
                message=f"Duplicate of feature {seen[key]}",
                geometry=row.geometry,
                details={
                    "duplicate_of": seen[key],
                    "key": key[:100],
                },
            ))
        else:
            seen[key] = idx

    return build_qc_result(gdf, issues)

@step(id="qc.raster_nodata", ...)
def raster_nodata(ctx):
    raster = ctx.input("input")  # raster_info dict
    expected_nodata = ctx.param("expected_nodata")
    max_nodata_ratio = ctx.param("max_nodata_ratio")

    issues = []
    profile = raster["profile"]
    data = raster["data"]
    actual_nodata = profile.get("nodata")

    # 检查 NoData 值一致性
    if expected_nodata is not None and actual_nodata != expected_nodata:
        issues.append(QcIssue(
            rule_id="raster_nodata",
            severity="error",
            message=f"NoData mismatch: expected {expected_nodata}, "
                    f"got {actual_nodata}",
            details={
                "expected": expected_nodata,
                "actual": actual_nodata,
            },
        ))

    # 检查 NoData 像素占比
    if max_nodata_ratio is not None and actual_nodata is not None:
        total_pixels = data.size
        nodata_pixels = (data == actual_nodata).sum()
        ratio = nodata_pixels / total_pixels

        if ratio > max_nodata_ratio:
            issues.append(QcIssue(
                rule_id="raster_nodata",
                severity="warning",
                message=f"NoData ratio {ratio:.2%} exceeds "
                        f"threshold {max_nodata_ratio:.2%}",
                details={
                    "nodata_ratio": float(ratio),
                    "threshold": max_nodata_ratio,
                    "nodata_pixels": int(nodata_pixels),
                    "total_pixels": int(total_pixels),
                },
            ))

    return build_qc_result(raster, issues)

@step(id="qc.raster_resolution", ...)
def raster_resolution(ctx):
    raster = ctx.input("input")
    expected_x = ctx.param("expected_x")
    expected_y = ctx.param("expected_y")
    tolerance = ctx.param("tolerance") or 0.0

    issues = []
    transform = raster["transform"]

    # 从仿射变换矩阵获取实际分辨率
    actual_x = abs(transform.a)   # X 方向像素大小
    actual_y = abs(transform.e)   # Y 方向像素大小

    if abs(actual_x - expected_x) > tolerance:
        issues.append(QcIssue(
            rule_id="raster_resolution",
            severity="error",
            message=f"X resolution mismatch: expected {expected_x}, "
                    f"got {actual_x}",
            details={"axis": "x", "expected": expected_x,
                     "actual": actual_x},
        ))

    if abs(actual_y - expected_y) > tolerance:
        issues.append(QcIssue(
            rule_id="raster_resolution",
            severity="error",
            message=f"Y resolution mismatch: expected {expected_y}, "
                    f"got {actual_y}",
            details={"axis": "y", "expected": expected_y,
                     "actual": actual_y},
        ))

    return build_qc_result(raster, issues)

@step(id="qc.raster_value_range", ...)
def raster_value_range(ctx):
    raster = ctx.input("input")
    min_val = ctx.param("min")
    max_val = ctx.param("max")
    severity = ctx.param("severity") or "error"
    band = ctx.param("band") or 1

    issues = []
    data = raster["data"]
    nodata = raster["profile"].get("nodata")

    # 提取指定波段（band 索引从 1 开始）
    band_data = data[band - 1]

    # 排除 NoData 值
    if nodata is not None:
        valid_data = band_data[band_data != nodata]
    else:
        valid_data = band_data.ravel()

    actual_min = float(valid_data.min())
    actual_max = float(valid_data.max())

    if min_val is not None and actual_min < min_val:
        issues.append(QcIssue(
            rule_id="raster_value_range",
            severity=severity,
            message=f"Band {band}: min value {actual_min} < {min_val}",
            details={"band": band, "actual_min": actual_min,
                     "expected_min": min_val},
        ))

    if max_val is not None and actual_max > max_val:
        issues.append(QcIssue(
            rule_id="raster_value_range",
            severity=severity,
            message=f"Band {band}: max value {actual_max} > {max_val}",
            details={"band": band, "actual_max": actual_max,
                     "expected_max": max_val},
        ))

    return build_qc_result(raster, issues, stats={
        "band": band,
        "actual_min": actual_min,
        "actual_max": actual_max,
    })