from abc import ABC, abstractmethod
from typing import Any

class GeoBackend(ABC):
    """GIS 后端抽象基类"""

    @abstractmethod
    def name(self) -> str:
        """返回后端名称标识"""
        ...

    @abstractmethod
    def is_available(self) -> bool:
        """检查后端是否可用（依赖是否已安装）"""
        ...

    @abstractmethod
    def buffer(self, gdf, distance, **kwargs) -> Any:
        """缓冲区分析"""
        ...

    @abstractmethod
    def clip(self, input_gdf, clip_gdf, **kwargs) -> Any:
        """裁剪"""
        ...

    @abstractmethod
    def reproject(self, gdf, target_crs, **kwargs) -> Any:
        """坐标转换"""
        ...

    @abstractmethod
    def dissolve(self, gdf, by=None, **kwargs) -> Any:
        """融合"""
        ...

    @abstractmethod
    def simplify(self, gdf, tolerance, **kwargs) -> Any:
        """简化"""
        ...

    @abstractmethod
    def overlay(self, gdf1, gdf2, how="intersection", **kwargs) -> Any:
        """叠加分析"""
        ...

class NativePythonBackend(GeoBackend):
    """基于 GeoPandas + Shapely 的默认后端"""

    def name(self) -> str:
        return "native_python"

    def is_available(self) -> bool:
        try:
            import geopandas
            import shapely
            return True
        except ImportError:
            return False

    def buffer(self, gdf, distance, **kwargs):
        result = gdf.copy()
        result["geometry"] = gdf.geometry.buffer(distance, **kwargs)
        return result

    def clip(self, input_gdf, clip_gdf, **kwargs):
        import geopandas as gpd
        return gpd.clip(input_gdf, clip_gdf)

    def reproject(self, gdf, target_crs, **kwargs):
        return gdf.to_crs(target_crs)

    def dissolve(self, gdf, by=None, **kwargs):
        return gdf.dissolve(by=by, **kwargs)

    def simplify(self, gdf, tolerance, **kwargs):
        result = gdf.copy()
        result["geometry"] = gdf.geometry.simplify(
            tolerance, **kwargs
        )
        return result

    def overlay(self, gdf1, gdf2, how="intersection", **kwargs):
        import geopandas as gpd
        return gpd.overlay(gdf1, gdf2, how=how, **kwargs)

class GdalCliBackend(GeoBackend):

    def name(self) -> str:
        return "gdal_cli"

    def is_available(self) -> bool:
        import shutil
        return shutil.which("ogr2ogr") is not None

    def clip(self, input_gdf, clip_gdf, **kwargs):
        with tmp_io(input_gdf) as (input_path, output_path):
            clip_path = write_tmp_gdf(clip_gdf)
            cmd = [
                "ogr2ogr",
                "-f", "GPKG",
                "-clipsrc", clip_path,
                output_path,
                input_path,
            ]
            subprocess.run(cmd, check=True, capture_output=True)
            return read_gdf(output_path)

    def buffer(self, gdf, distance, **kwargs):
        with tmp_io(gdf) as (input_path, output_path):
            sql = (
                f"SELECT ST_Buffer(geom, {distance}) AS geom, * "
                f"FROM \"{_layer_name(input_path)}\""
            )
            cmd = [
                "ogr2ogr",
                "-f", "GPKG",
                "-sql", sql,
                "-dialect", "SQLite",
                output_path,
                input_path,
            ]
            subprocess.run(cmd, check=True, capture_output=True)
            return read_gdf(output_path)

    def reproject(self, gdf, target_crs, **kwargs):
        with tmp_io(gdf) as (input_path, output_path):
            cmd = [
                "ogr2ogr",
                "-f", "GPKG",
                "-t_srs", str(target_crs),
                output_path,
                input_path,
            ]
            subprocess.run(cmd, check=True, capture_output=True)
            return read_gdf(output_path)

@contextmanager
def tmp_io(gdf):
    """创建临时输入/输出文件对

    用法:
        with tmp_io(gdf) as (input_path, output_path):
            # input_path: 写入了 gdf 的临时文件
            # output_path: 空的临时输出文件路径
            subprocess.run([...])
            result = read_gdf(output_path)
    """
    input_path = write_tmp_gdf(gdf)
    output_path = make_tmp_path(".gpkg")
    try:
        yield input_path, output_path
    finally:
        # 清理临时文件
        for p in [input_path, output_path]:
            if os.path.exists(p):
                os.remove(p)

class GdalPythonBackend(GeoBackend):

    def name(self) -> str:
        return "gdal_python"

    def is_available(self) -> bool:
        try:
            from osgeo import ogr, osr, gdal
            return True
        except ImportError:
            return False

    def buffer(self, gdf, distance, **kwargs):
        from osgeo import ogr

        result_geoms = []
        for geom in gdf.geometry:
            ogr_geom = ogr.CreateGeometryFromWkt(geom.wkt)
            buffered = ogr_geom.Buffer(distance)
            result_geoms.append(
                shapely.wkt.loads(buffered.ExportToWkt())
            )

        result = gdf.copy()
        result["geometry"] = result_geoms
        return result

    def reproject(self, gdf, target_crs, **kwargs):
        from osgeo import osr

        source_srs = osr.SpatialReference()
        source_srs.ImportFromEPSG(gdf.crs.to_epsg())

        target_srs = osr.SpatialReference()
        target_srs.SetFromUserInput(str(target_crs))

        transform = osr.CoordinateTransformation(
            source_srs, target_srs
        )

        result_geoms = []
        for geom in gdf.geometry:
            ogr_geom = ogr.CreateGeometryFromWkt(geom.wkt)
            ogr_geom.Transform(transform)
            result_geoms.append(
                shapely.wkt.loads(ogr_geom.ExportToWkt())
            )

        result = gdf.copy()
        result["geometry"] = result_geoms
        result.crs = target_crs
        return result

class QgisProcessBackend(GeoBackend):

    def name(self) -> str:
        return "qgis_process"

    def is_available(self) -> bool:
        import shutil
        return shutil.which("qgis_process") is not None

    def buffer(self, gdf, distance, **kwargs):
        with tmp_io(gdf) as (input_path, output_path):
            cmd = [
                "qgis_process", "run",
                "native:buffer",
                "--",
                f"INPUT={input_path}",
                f"DISTANCE={distance}",
                "SEGMENTS=5",
                "END_CAP_STYLE=0",
                "JOIN_STYLE=0",
                f"OUTPUT={output_path}",
            ]
            subprocess.run(cmd, check=True, capture_output=True)
            return read_gdf(output_path)

    def clip(self, input_gdf, clip_gdf, **kwargs):
        with tmp_io(input_gdf) as (input_path, output_path):
            clip_path = write_tmp_gdf(clip_gdf)
            cmd = [
                "qgis_process", "run",
                "native:clip",
                "--",
                f"INPUT={input_path}",
                f"OVERLAY={clip_path}",
                f"OUTPUT={output_path}",
            ]
            subprocess.run(cmd, check=True, capture_output=True)
            return read_gdf(output_path)

    def dissolve(self, gdf, by=None, **kwargs):
        with tmp_io(gdf) as (input_path, output_path):
            cmd = [
                "qgis_process", "run",
                "native:dissolve",
                "--",
                f"INPUT={input_path}",
                f"FIELD={by or ''}",
                f"OUTPUT={output_path}",
            ]
            subprocess.run(cmd, check=True, capture_output=True)
            return read_gdf(output_path)

class PyQgisBackend(GeoBackend):

    def name(self) -> str:
        return "pyqgis"

    def is_available(self) -> bool:
        try:
            from qgis.core import QgsApplication
            return True
        except ImportError:
            return False

    def buffer(self, gdf, distance, **kwargs):
        from qgis.core import QgsVectorLayer
        import processing

        with tmp_io(gdf) as (input_path, output_path):
            result = processing.run("native:buffer", {
                "INPUT": input_path,
                "DISTANCE": distance,
                "SEGMENTS": 5,
                "END_CAP_STYLE": 0,
                "JOIN_STYLE": 0,
                "OUTPUT": output_path,
            })
            return read_gdf(result["OUTPUT"])

    def overlay(self, gdf1, gdf2, how="intersection", **kwargs):
        import processing

        alg_map = {
            "intersection": "native:intersection",
            "union": "native:union",
            "difference": "native:difference",
            "symmetric_difference": "native:symmetricaldifference",
        }

        alg = alg_map.get(how)
        if not alg:
            raise ValueError(f"Unsupported overlay method: {how}")

        with tmp_io(gdf1) as (input_path, output_path):
            overlay_path = write_tmp_gdf(gdf2)
            result = processing.run(alg, {
                "INPUT": input_path,
                "OVERLAY": overlay_path,
                "OUTPUT": output_path,
            })
            return read_gdf(result["OUTPUT"])

_BACKEND_CLASSES = [
    NativePythonBackend,
    GdalCliBackend,
    GdalPythonBackend,
    QgisProcessBackend,
    PyQgisBackend,
]

class BackendManager:
    """后端管理器——自动检测可用后端并提供选择机制"""

    def __init__(self):
        # 实例化所有后端类
        all_backends = [cls() for cls in _BACKEND_CLASSES]
        # 过滤出可用的后端
        self.backends = [b for b in all_backends if b.is_available()]

    def get(self, preferred=None) -> GeoBackend:
        """获取后端实例

        Args:
            preferred: 优先选择的后端名称

        Returns:
            GeoBackend: 后端实例

        Raises:
            BackendNotAvailableError: 无可用后端
        """
        if preferred:
            for b in self.backends:
                if b.name() == preferred:
                    return b
            raise BackendNotAvailableError(
                f"Backend '{preferred}' is not available. "
                f"Available: {[b.name() for b in self.backends]}"
            )

        if not self.backends:
            raise BackendNotAvailableError(
                "No GIS backend is available. "
                "Please install geopandas at minimum."
            )

        return self.backends[0]  # 返回第一个可用后端

def write_tmp_gdf(gdf, fmt="GPKG"):
    """将 GeoDataFrame 写入临时文件

    Args:
        gdf: 输入 GeoDataFrame
        fmt: 输出格式（默认 GPKG）

    Returns:
        str: 临时文件路径
    """
    path = make_tmp_path(".gpkg")
    gdf.to_file(path, driver=fmt)
    return path

import tempfile
import uuid

def make_tmp_path(suffix=".gpkg"):
    """生成唯一的临时文件路径

    Returns:
        str: 临时文件路径（文件尚不存在）
    """
    tmp_dir = tempfile.gettempdir()
    filename = f"geopipe_{uuid.uuid4().hex[:8]}{suffix}"
    return os.path.join(tmp_dir, filename)

import geopandas as gpd

def read_gdf(path):
    """从文件读取 GeoDataFrame

    Args:
        path: 文件路径

    Returns:
        GeoDataFrame: 读取的空间数据
    """
    return gpd.read_file(path)

from contextlib import contextmanager

@contextmanager
def tmp_io(gdf):
    """创建临时输入/输出文件对的上下文管理器

    自动写入输入数据到临时文件，并在退出时清理所有临时文件。

    Usage:
        with tmp_io(gdf) as (input_path, output_path):
            subprocess.run(["ogr2ogr", output_path, input_path])
            result = read_gdf(output_path)
    """
    input_path = write_tmp_gdf(gdf)
    output_path = make_tmp_path(".gpkg")
    try:
        yield input_path, output_path
    finally:
        for p in [input_path, output_path]:
            if os.path.exists(p):
                os.remove(p)