# -*- coding:utf-8 -*-
from traceback import format_exc
from ahserver.serverenv import ServerEnv
from appPublic.registerfunction import RegisterFunction
from appPublic.log import exception
import json


async def status_handler(request, params_kw, *args, **kwargs):
    import sys, os
    sys.path.insert(0, os.getcwd())
    from workers.graph_engine import health_check
    health = health_check()
    return json.dumps({
        "service": "graph-service",
        "backend": health["backend"],
        "graphs_loaded": health["graphs_loaded"],
        "data_dir": health["data_dir"],
        "endpoints": [
            "/api/status", "/api/graph/add_node", "/api/graph/add_edge",
            "/api/graph/neighbors", "/api/graph/path", "/api/graph/query",
            "/api/graph/stats", "/api/graph/save", "/api/graph/load"
        ]
    }, indent=2, ensure_ascii=False)


async def debug_handler(request, params_kw, *args, **kwargs):
    """Debug endpoint to see params_kw contents"""
    return json.dumps({
        "params_kw": params_kw,
        "params_kw_keys": list(params_kw.keys()),
        "request_method": request.method,
        "request_content_type": request.content_type
    }, indent=2, ensure_ascii=False)


async def add_node_handler(request, params_kw, *args, **kwargs):
    import sys, os
    sys.path.insert(0, os.getcwd())
    from workers.graph_engine import add_node
    try:
        graph = params_kw.get("graph", "default")
        node_id = params_kw.get("node_id")
        attrs = params_kw.get("attrs", {})
        
        if not node_id:
            return json.dumps({"error": "node_id required", "debug": {"params_kw": params_kw}})
        
        result = add_node(graph, node_id, **attrs)
        return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
    except Exception as e:
        exception(f"{e}, {format_exc()}")
        return json.dumps({"error": str(e)})


async def add_edge_handler(request, params_kw, *args, **kwargs):
    import sys, os
    sys.path.insert(0, os.getcwd())
    from workers.graph_engine import add_edge
    try:
        graph = params_kw.get("graph", "default")
        source = params_kw.get("source")
        target = params_kw.get("target")
        attrs = params_kw.get("attrs", {})
        
        if not source or not target:
            return json.dumps({"error": "source and target required"})
        
        result = add_edge(graph, source, target, **attrs)
        return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
    except Exception as e:
        exception(f"{e}, {format_exc()}")
        return json.dumps({"error": str(e)})


async def neighbors_handler(request, params_kw, *args, **kwargs):
    import sys, os
    sys.path.insert(0, os.getcwd())
    from workers.graph_engine import get_neighbors
    try:
        graph = params_kw.get("graph", "default")
        node_id = params_kw.get("node_id")
        direction = params_kw.get("direction", "both")
        depth = int(params_kw.get("depth", 1))
        
        if not node_id:
            return json.dumps({"error": "node_id required"})
        
        result = get_neighbors(graph, node_id, direction, depth)
        return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
    except Exception as e:
        exception(f"{e}, {format_exc()}")
        return json.dumps({"error": str(e)})


async def path_handler(request, params_kw, *args, **kwargs):
    import sys, os
    sys.path.insert(0, os.getcwd())
    from workers.graph_engine import find_path
    try:
        graph = params_kw.get("graph", "default")
        source = params_kw.get("source")
        target = params_kw.get("target")
        max_depth = int(params_kw.get("max_depth", 10))
        
        if not source or not target:
            return json.dumps({"error": "source and target required"})
        
        result = find_path(graph, source, target, max_depth)
        return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
    except Exception as e:
        exception(f"{e}, {format_exc()}")
        return json.dumps({"error": str(e)})


async def query_handler(request, params_kw, *args, **kwargs):
    import sys, os
    sys.path.insert(0, os.getcwd())
    from workers.graph_engine import query_nodes
    try:
        graph = params_kw.get("graph", "default")
        filters = params_kw.get("filters")
        limit = int(params_kw.get("limit", 100))
        
        result = query_nodes(graph, filters, limit)
        return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
    except Exception as e:
        exception(f"{e}, {format_exc()}")
        return json.dumps({"error": str(e)})


async def stats_handler(request, params_kw, *args, **kwargs):
    import sys, os
    sys.path.insert(0, os.getcwd())
    from workers.graph_engine import get_stats
    try:
        graph = params_kw.get("graph", "default")
        result = get_stats(graph)
        return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
    except Exception as e:
        exception(f"{e}, {format_exc()}")
        return json.dumps({"error": str(e)})


async def save_handler(request, params_kw, *args, **kwargs):
    import sys, os
    sys.path.insert(0, os.getcwd())
    from workers.graph_engine import save_graph
    try:
        graph = params_kw.get("graph", "default")
        result = save_graph(graph)
        return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
    except Exception as e:
        exception(f"{e}, {format_exc()}")
        return json.dumps({"error": str(e)})


async def load_handler(request, params_kw, *args, **kwargs):
    import sys, os
    sys.path.insert(0, os.getcwd())
    from workers.graph_engine import load_graph
    try:
        graph = params_kw.get("graph", "default")
        result = load_graph(graph)
        return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
    except Exception as e:
        exception(f"{e}, {format_exc()}")
        return json.dumps({"error": str(e)})


def load_graph_service():
    """Register API handlers"""
    env = ServerEnv()
    rf = RegisterFunction()
    rf.register("status", status_handler)
    rf.register("debug", debug_handler)
    rf.register("add_node", add_node_handler)
    rf.register("add_edge", add_edge_handler)
    rf.register("neighbors", neighbors_handler)
    rf.register("path", path_handler)
    rf.register("query", query_handler)
    rf.register("stats", stats_handler)
    rf.register("save", save_handler)
    rf.register("load", load_handler)