app.py

import os

from flask import Flask, request, jsonify

from data_utils import LUCASSoilData
from gadm_utils import GADMHandler
from geo_utils import resolve_place

app = Flask(__name__, static_folder="plots", static_url_path="/plots")

gadm_handler = GADMHandler("data_api/gadm_tree_europe.pkl")
soil_data = LUCASSoilData(table_path="data_api/data_table.csv",
                          dict_path="data_api/data_dict.pkl",
                          column_names_path="data_api/meta_column_names.json",
                          gadm_handler=gadm_handler)


# --- geo_utils API ---
@app.route("/resolve_place", methods=["POST"])
def api_resolve_place():
    data = request.json
    print("resolve_place input:", data)
    result = resolve_place(
        data.get("place_name"),
        data.get("fallback"),
        data.get("session_name")
    )
    print("resolve_place output:", result)
    return jsonify(result)


@app.route("/gadm/find_gid", methods=["POST"])
def api_gadm_find_gid():
    data = request.json
    print("find_gid input:", data)
    lat = data["lat"]
    lon = data["lon"]
    bbox_area = data.get("bbox_area")
    return_all = data.get("return_all", False)

    result = gadm_handler.find_gid(lat, lon, bbox_area, return_all)
    print("find_gid output:", result)

    if result is None or (isinstance(result, list) and not result):
        return jsonify({
            "status": "Failed. No matching GADM region found.",
            "gid": None
        })

    if return_all:
        return jsonify({
            "status": f"Success. Found {len(result)} matching regions.",
            "gids": result
        })
    else:
        return jsonify({
            "status": "Success. Found best matching region.",
            "gid": result
        })


@app.route("/gadm/get_full_name", methods=["POST"])
def api_gadm_get_full_name():
    data = request.json
    print("get_full_name input:", data)
    gid = data.get("gid")
    result = gadm_handler.get_full_name(gid)
    output = {
        "status": "Success. Full hierarchical name found." if result else f"Failed. GID '{gid}' not found.",
        "full_name": result
    }
    print("get_full_name output:", output)
    return jsonify(output)


@app.route("/gadm/get_geometry_info", methods=["POST"])
def api_gadm_geometry_info():
    data = request.json
    print("get_geometry_info input:", data)
    gid = data.get("gid")
    result = gadm_handler.get_geometry_info(gid)
    if result is None:
        output = {
            "status": f"Failed. GID '{gid}' not found or has no geometry.",
            "latitude": None,
            "longitude": None,
            "bbox_bounds": None,
            "polygon_area": None,
            "bbox_area": None
        }
    else:
        output = {
            "status": "Success. Geometry information retrieved.",
            **result
        }
    print("get_geometry_info output:", output)
    return jsonify(output)


@app.route("/gadm/get_tree_info", methods=["POST"])
def api_gadm_tree_info():
    data = request.json
    print("get_tree_info input:", data)
    gid = data.get("gid")
    result = gadm_handler.get_tree_info(gid)
    if result is None:
        output = {
            "status": f"Failed. GID '{gid}' not found.",
            "level": None,
            "parent": None,
            "children": None,
            "siblings": None
        }
    else:
        output = {
            "status": "Success. Tree information retrieved.",
            **result
        }
    print("get_tree_info output:", output)
    return jsonify(output)


@app.route("/gadm/get_quick_summary", methods=["POST"])
def api_gadm_quick_summary():
    data = request.json
    print("get_quick_summary input:", data)
    gid = data.get("gid")
    summary = gadm_handler.quick_summary(gid)
    status = "Success" if not summary.startswith("Invalid GID") else "Failed"
    output = {"summary": summary, "status": status}
    print("get_quick_summary output:", output)
    return jsonify(output)


# --- ISDASoilData APIs ---
@app.route("/soil/get_point", methods=["POST"])
def api_soil_get_point():
    data = request.json
    print("get_point input:", data)

    data = request.get_json(silent=True) or {}
    place = data.get("place")
    properties = data.get("properties")
    if place is None or not isinstance(properties, list) or len(properties) == 0:
        return jsonify({
            "query_input": {"place": place, "properties": properties, "session_name": data.get("session_name")},
            "query_status": "Failed. Missing required fields: 'place' and non-empty 'properties'.",
            "query_output": {}
        }), 400

    # Use server-side defaults if client omitted them
    distance_top_k = int(data.get("distance_top_k", 20))
    distance_limit = float(data.get("distance_limit", 200000))
    session_name = data.get("session_name")

    result = soil_data.get_point(
        place=place,
        properties=properties,
        distance_top_k=distance_top_k,
        distance_limit=distance_limit,
        session_name=session_name,
    )
    print("get_point output:", result)
    return jsonify(result)


@app.route("/soil/get_map", methods=["POST"])
def api_soil_get_map():
    data = request.get_json(silent=True) or {}
    print("get_map input:", data)

    place = data.get("place")
    properties = data.get("properties") or []
    session_name = data.get("session_name")
    kwargs = data.get("kwargs") or {}

    # Basic input validation (mirror API contract)
    if not session_name:
        return jsonify({
            "query_input": {"place": place, "properties": properties, "session_name": session_name},
            "query_status": "Failed. Missing required field: session_name.",
            "query_output": {}
        }), 400
    if place is None:
        return jsonify({
            "query_input": {"place": place, "properties": properties, "session_name": session_name},
            "query_status": "Failed. Missing required field: place.",
            "query_output": {}
        }), 400
    if not isinstance(properties, list) or len(properties) == 0:
        return jsonify({
            "query_input": {"place": place, "properties": properties, "session_name": session_name},
            "query_status": "Failed. properties must be a non-empty list.",
            "query_output": {}
        }), 400

    # Call core API
    result = soil_data.get_map(place=place, properties=properties, session_name=session_name, **kwargs)
    print("get_map raw output:", result.get("query_output", {}))

    # Convert local file paths to public URLs under /plots/<session_name>/
    try:
        qo = result.get("query_output", {})
        for label, path in list(qo.items()):
            if isinstance(path, str) and path.endswith(".png") and os.path.exists(path):
                filename = os.path.basename(path)
                # app.static_url_path is "/plots"
                public_url = f"{request.url_root.rstrip('/')}{app.static_url_path}/{session_name}/{filename}"
                result["query_output"][label] = public_url
    except Exception as e:
        # Do not fail the whole response; annotate status
        result["query_status"] = f"{result.get('query_status', 'Success')}\nNote: Failed to rewrite some URLs: {e}"

    print("get_map with URLs:", result.get("query_output", {}))
    return jsonify(result)


@app.route("/health", methods=["GET"])
def health_check():
    print("health_check called")
    return jsonify({"status": "OK"})


if __name__ == "__main__":
    import argparse

    parser = argparse.ArgumentParser(description="Run Soil API server")
    parser.add_argument(
        "--host", default="0.0.0.0",
        help="Host to bind (default: 0.0.0.0)"
    )
    parser.add_argument(
        "--port", type=int, default=5050,
        help="Port to listen on (default: 5050)"
    )
    args = parser.parse_args()

    app.run(host=args.host, port=args.port)