AcidMap/app/api/cd_flux.py

import os
import json
import tempfile
import shutil
import logging
import sys
from pathlib import Path
from typing import Optional, Dict, Any

from fastapi import APIRouter, File, UploadFile, Form, HTTPException, BackgroundTasks
from fastapi.responses import FileResponse, JSONResponse

from app.services.cd_flux_service import FluxCdVisualizationService

# 固定文件名
DEFAULT_INPUT_MAP_FILENAME = "fluxcd_input_map.jpg"
DEFAULT_INPUT_HIST_FILENAME = "fluxcd_input_histogram.jpg"
DEFAULT_INPUT_CSV_FILENAME = "fluxcd_input.csv"

DEFAULT_OUTPUT_MAP_FILENAME = "fluxcd_output_map.jpg"
DEFAULT_OUTPUT_HIST_FILENAME = "fluxcd_output_histogram.jpg"
DEFAULT_OUTPUT_CSV_FILENAME = "fluxcd_output.csv"

DEFAULT_NET_MAP_FILENAME = "fluxcd_net_map.jpg"
DEFAULT_NET_HIST_FILENAME = "fluxcd_net_histogram.jpg"
DEFAULT_NET_CSV_FILENAME = "fluxcd_net.csv"

LATEST_RESULT_FILENAME = "latest_result.json"
# 配置日志 - 避免重复日志输出
logger = logging.getLogger(__name__)
# 避免重复添加处理器导致重复日志
if not logger.handlers:
    logger.setLevel(logging.INFO)
    handler = logging.StreamHandler()
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)
    logger.addHandler(handler)
    # 关闭日志传播，避免与父级日志处理器重复输出
    logger.propagate = False

router = APIRouter()


def get_base_dir():
    """获取基础目录路径（与土地数据处理函数一致）"""
    if getattr(sys, 'frozen', False):
        # 打包后的可执行文件
        return os.path.dirname(sys.executable)
    else:
        # 脚本运行模式
        return os.path.dirname(os.path.abspath(__file__))


def get_static_dir():
    """获取静态资源目录"""
    base_dir = get_base_dir()
    return os.path.join(base_dir, "..", "static", "cd_flux")


STATIC_DIR = get_static_dir()  # 静态目录，即static/cd_flux


def get_default_file_path(filename: str) -> str:
    """获取默认文件路径"""
    static_dir = get_static_dir()
    path = os.path.join(static_dir, filename)
    return path


@router.post("/calculate")
async def update_and_generate_fluxcd_visualization(
        background_tasks: BackgroundTasks,
        csv_file: Optional[UploadFile] = File(None),
        boundary_shp: Optional[str] = Form(None)
) -> Dict[str, Any]:
    try:
        logger.info("开始处理Cd通量数据可视化")

        # 初始化服务
        service = FluxCdVisualizationService()
        static_dir = get_static_dir()
        os.makedirs(static_dir, exist_ok=True)

        # 如果有上传文件，先更新数据
        if csv_file:
            logger.info("检测到上传文件，开始更新数据")
            temp_dir = tempfile.mkdtemp()
            temp_csv_path = os.path.join(temp_dir, csv_file.filename)

            with open(temp_csv_path, "wb") as f:
                content = await csv_file.read()
                f.write(content)

            update_result = service.update_from_csv(temp_csv_path)
            if not update_result.get("success"):
                logger.error(f"更新数据失败: {update_result.get('message')}")
                raise HTTPException(status_code=500, detail=update_result.get('message'))

            # 清理临时文件
            background_tasks.add_task(shutil.rmtree, temp_dir, ignore_errors=True)

        # 生成所有结果（直接从数据库获取数据）
        input_result = service.generate_cd_input_flux_map(
            output_dir=static_dir,
            boundary_shp=boundary_shp
        )
        output_result = service.generate_cd_output_flux_map(
            output_dir=static_dir,
            boundary_shp=boundary_shp
        )
        net_result = service.generate_cd_net_flux_map(
            output_dir=static_dir,
            boundary_shp=boundary_shp
        )
        end_cd_result = service.generate_end_cd_map(
            output_dir=static_dir,
            boundary_shp=boundary_shp
        )

        # 保存最新结果信息
        latest_result_path = os.path.join(static_dir, LATEST_RESULT_FILENAME)
        with open(latest_result_path, "w", encoding="utf-8") as f:
            json.dump({
                "input": input_result,
                "output": output_result,
                "net": net_result,
                "end_cd": end_cd_result
            }, f, ensure_ascii=False, indent=2)

        return {
            "input": input_result,
            "output": output_result,
            "net": net_result,
            "end_cd": end_cd_result
        }

    except HTTPException as he:
        raise he
    except Exception as e:
        logger.error(f"处理过程中出错: {str(e)}", exc_info=True)
        raise HTTPException(status_code=500, detail=f"服务器内部错误: {str(e)}")


# 添加常量定义
DEFAULT_END_CD_MAP_FILENAME = "fluxcd_end_cd_map.jpg"
DEFAULT_END_CD_HIST_FILENAME = "fluxcd_end_cd_histogram.jpg"
DEFAULT_END_CD_CSV_FILENAME = "fluxcd_end_cd.csv"

# 添加API路由
@router.get("/end-cd/map",
            summary="获取当年Cd浓度空间分布图",
            description="返回当年Cd浓度的空间分布图")
async def get_end_cd_map() -> FileResponse:
    try:
        map_path = get_default_file_path(DEFAULT_END_CD_MAP_FILENAME)
        if os.path.exists(map_path):
            return FileResponse(map_path, media_type="image/jpeg")
        else:
            raise HTTPException(status_code=404, detail="当年Cd浓度地图不存在，请先生成")
    except Exception as e:
        logger.error(f"获取当年Cd浓度地图失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"获取当年Cd浓度地图失败: {str(e)}")

@router.get("/end-cd/histogram",
            summary="获取当年Cd浓度直方图",
            description="返回当年Cd浓度的直方图")
async def get_end_cd_histogram() -> FileResponse:
    try:
        hist_path = get_default_file_path(DEFAULT_END_CD_HIST_FILENAME)
        if os.path.exists(hist_path):
            return FileResponse(hist_path, media_type="image/jpeg")
        else:
            raise HTTPException(status_code=404, detail="当年Cd浓度直方图不存在，请先生成")
    except Exception as e:
        logger.error(f"获取当年Cd浓度直方图失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"获取当年Cd浓度直方图失败: {str(e)}")

@router.get("/end-cd/statistics",
            summary="获取当年Cd浓度统计信息",
            description="返回当年Cd浓度的统计信息")
async def get_end_cd_statistics() -> JSONResponse:
    try:
        latest_result_path = os.path.join(STATIC_DIR, LATEST_RESULT_FILENAME)
        if not os.path.exists(latest_result_path):
            raise HTTPException(status_code=404, detail="无可用统计信息，请先生成")

        with open(latest_result_path, "r", encoding="utf-8") as f:
            result = json.load(f)

        if not result.get("end_cd") or not result["end_cd"].get("success"):
            raise HTTPException(status_code=404, detail="当年Cd浓度结果无效")

        stats = result["end_cd"].get("data", {}).get("statistics")
        if stats:
            return JSONResponse(content=stats)
        else:
            raise HTTPException(status_code=404, detail="当年Cd浓度统计信息不存在")
    except Exception as e:
        logger.error(f"获取当年Cd浓度统计信息失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"获取当年Cd浓度统计信息失败: {str(e)}")

@router.get("/end-cd/export-csv",
            summary="导出当年Cd浓度CSV文件",
            description="导出当年Cd浓度的CSV文件")
async def export_end_cd_csv() -> FileResponse:
    try:
        csv_path = get_default_file_path(DEFAULT_END_CD_CSV_FILENAME)
        if os.path.exists(csv_path):
            return FileResponse(
                csv_path,
                filename="fluxcd_end_cd.csv",
                media_type="text/csv"
            )
        else:
            raise HTTPException(status_code=404, detail="当年Cd浓度CSV文件不存在，请先生成")
    except Exception as e:
        logger.error(f"导出当年Cd浓度CSV失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"导出当年Cd浓度CSV失败: {str(e)}")

@router.get("/input/map",
            summary="获取Cd输入通量空间分布图",
            description="返回默认的Cd输入通量空间分布图")
async def get_fluxcd_map() -> FileResponse:
    try:
        # 直接返回静态目录中的默认地图
        map_path = get_default_file_path(DEFAULT_INPUT_MAP_FILENAME)
        if os.path.exists(map_path):
            return FileResponse(map_path, media_type="image/jpeg")
        else:
            raise HTTPException(status_code=404, detail="默认地图不存在，请先生成")
    except Exception as e:
        logger.error(f"获取地图失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"获取地图失败: {str(e)}")


@router.get("/output/map",
            summary="获取Cd输出通量空间分布图",
            description="返回默认的Cd输出通量空间分布图")
async def get_fluxcd_output_map() -> FileResponse:
    try:
        # 直接返回静态目录中的默认地图
        map_path = get_default_file_path(DEFAULT_OUTPUT_MAP_FILENAME)
        if os.path.exists(map_path):
            return FileResponse(map_path, media_type="image/jpeg")
        else:
            raise HTTPException(status_code=404, detail="默认输出通量地图不存在，请先生成")
    except Exception as e:
        logger.error(f"获取输出通量地图失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"获取输出通量地图失败: {str(e)}")


@router.get("/net/map",
            summary="获取Cd净通量空间分布图",
            description="返回默认的Cd净通量空间分布图")
async def get_fluxcd_net_map() -> FileResponse:
    try:
        # 直接返回静态目录中的默认地图
        map_path = get_default_file_path(DEFAULT_NET_MAP_FILENAME)
        if os.path.exists(map_path):
            return FileResponse(map_path, media_type="image/jpeg")
        else:
            raise HTTPException(status_code=404, detail="默认净通量地图不存在，请先生成")
    except Exception as e:
        logger.error(f"获取净通量地图失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"获取净通量地图失败: {str(e)}")


@router.get("/input/histogram",
            summary="获取Cd输入通量直方图",
            description="返回默认的Cd输入通量直方图")
async def get_fluxcd_histogram() -> FileResponse:
    try:
        # 直接返回静态目录中的默认直方图
        hist_path = get_default_file_path(DEFAULT_INPUT_HIST_FILENAME)
        if os.path.exists(hist_path):
            return FileResponse(hist_path, media_type="image/jpeg")
        else:
            raise HTTPException(status_code=404, detail="默认直方图不存在，请先生成")
    except Exception as e:
        logger.error(f"获取直方图失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"获取直方图失败: {str(e)}")


@router.get("/output/histogram",
            summary="获取Cd输出通量直方图",
            description="返回默认的Cd输出通量直方图")
async def get_fluxcd_output_histogram() -> FileResponse:
    try:
        # 直接返回静态目录中的默认直方图
        hist_path = get_default_file_path(DEFAULT_OUTPUT_HIST_FILENAME)
        if os.path.exists(hist_path):
            return FileResponse(hist_path, media_type="image/jpeg")
        else:
            raise HTTPException(status_code=404, detail="默认输出通量直方图不存在，请先生成")
    except Exception as e:
        logger.error(f"获取输出通量直方图失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"获取输出通量直方图失败: {str(e)}")


@router.get("/net/histogram",
            summary="获取Cd净通量直方图",
            description="返回默认的Cd净通量直方图")
async def get_fluxcd_net_histogram() -> FileResponse:
    try:
        # 直接返回静态目录中的默认直方图
        hist_path = get_default_file_path(DEFAULT_NET_HIST_FILENAME)
        if os.path.exists(hist_path):
            return FileResponse(hist_path, media_type="image/jpeg")
        else:
            raise HTTPException(status_code=404, detail="默认净通量直方图不存在，请先生成")
    except Exception as e:
        logger.error(f"获取净通量直方图失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"获取净通量直方图失败: {str(e)}")


@router.get("/input/statistics",
            summary="获取Cd输入通量统计信息",
            description="返回最新生成的Cd输入通量统计信息")
async def get_fluxcd_statistics() -> JSONResponse:
    try:
        latest_result_path = os.path.join(STATIC_DIR, LATEST_RESULT_FILENAME)
        if not os.path.exists(latest_result_path):
            raise HTTPException(status_code=404, detail="无可用统计信息，请先生成")

        with open(latest_result_path, "r", encoding="utf-8") as f:
            result = json.load(f)

        if not result.get("input") or not result["input"].get("success"):
            raise HTTPException(status_code=404, detail="输入通量结果无效")

        stats = result["input"].get("data", {}).get("statistics")
        if stats:
            return JSONResponse(content=stats)
        else:
            raise HTTPException(status_code=404, detail="统计信息不存在")
    except Exception as e:
        logger.error(f"获取统计信息失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"获取统计信息失败: {str(e)}")


@router.get("/output/statistics",
            summary="获取Cd输出通量统计信息",
            description="返回最新生成的Cd输出通量统计信息")
async def get_fluxcd_output_statistics() -> JSONResponse:
    try:
        latest_result_path = os.path.join(STATIC_DIR, LATEST_RESULT_FILENAME)
        if not os.path.exists(latest_result_path):
            raise HTTPException(status_code=404, detail="无可用统计信息，请先生成")

        with open(latest_result_path, "r", encoding="utf-8") as f:
            result = json.load(f)

        if not result.get("output") or not result["output"].get("success"):
            raise HTTPException(status_code=404, detail="输出通量结果无效")

        stats = result["output"].get("data", {}).get("statistics")
        if stats:
            return JSONResponse(content=stats)
        else:
            raise HTTPException(status_code=404, detail="输出通量统计信息不存在")
    except Exception as e:
        logger.error(f"获取输出通量统计信息失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"获取输出通量统计信息失败: {str(e)}")


@router.get("/net/statistics",
            summary="获取Cd净通量统计信息",
            description="返回最新生成的Cd净通量统计信息")
async def get_fluxcd_net_statistics() -> JSONResponse:
    try:
        latest_result_path = os.path.join(STATIC_DIR, LATEST_RESULT_FILENAME)
        if not os.path.exists(latest_result_path):
            raise HTTPException(status_code=404, detail="无可用统计信息，请先生成")

        with open(latest_result_path, "r", encoding="utf-8") as f:
            result = json.load(f)

        if not result.get("net") or not result["net"].get("success"):
            raise HTTPException(status_code=404, detail="净通量结果无效")

        stats = result["net"].get("data", {}).get("statistics")
        if stats:
            return JSONResponse(content=stats)
        else:
            raise HTTPException(status_code=404, detail="净通量统计信息不存在")
    except Exception as e:
        logger.error(f"获取净通量统计信息失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"获取净通量统计信息失败: {str(e)}")


@router.get("/input/export-csv",
            summary="导出fluxcd_input.csv文件",
            description="导出默认的fluxcd_input.csv文件")
async def export_fluxcd_csv() -> FileResponse:
    try:
        # 直接返回静态目录中的CSV文件
        csv_path = get_default_file_path(DEFAULT_INPUT_CSV_FILENAME)
        if os.path.exists(csv_path):
            return FileResponse(
                csv_path,
                filename="fluxcd_input.csv",
                media_type="text/csv"
            )
        else:
            raise HTTPException(status_code=404, detail="CSV文件不存在，请先生成")
    except Exception as e:
        logger.error(f"导出CSV失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"导出CSV失败: {str(e)}")


@router.get("/output/export-csv",
            summary="导出fluxcd_output.csv文件",
            description="导出默认的fluxcd_output.csv文件")
async def export_fluxcd_output_csv() -> FileResponse:
    try:
        # 直接返回静态目录中的CSV文件
        csv_path = get_default_file_path(DEFAULT_OUTPUT_CSV_FILENAME)
        if os.path.exists(csv_path):
            return FileResponse(
                csv_path,
                filename="fluxcd_output.csv",
                media_type="text/csv"
            )
        else:
            raise HTTPException(status_code=404, detail="输出通量CSV文件不存在，请先生成")
    except Exception as e:
        logger.error(f"导出输出通量CSV失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"导出输出通量CSV失败: {str(e)}")


@router.get("/net/export-csv",
            summary="导出fluxcd_net.csv文件",
            description="导出默认的fluxcd_net.csv文件")
async def export_fluxcd_net_csv() -> FileResponse:
    try:
        # 直接返回静态目录中的CSV文件
        csv_path = get_default_file_path(DEFAULT_NET_CSV_FILENAME)
        if os.path.exists(csv_path):
            return FileResponse(
                csv_path,
                filename="fluxcd_net.csv",
                media_type="text/csv"
            )
        else:
            raise HTTPException(status_code=404, detail="净通量CSV文件不存在，请先生成")
    except Exception as e:
        logger.error(f"导出净通量CSV失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"导出净通量CSV失败: {str(e)}")