"""
Knowledge Graph HTTP API — FastAPI server on localhost:8333.

All agents can write/query the knowledge graph through this API.
"""

import json
import logging
from typing import Optional

from fastapi import FastAPI, HTTPException, Query
from pydantic import BaseModel, Field, field_validator

from graph import (
add_entity, add_relation, get_entity, search_entities,
explore, merge_entities, decay_stale, infer_relations,
health, VALID_ENTITY_TYPES, VALID_RELATION_TYPES, VALID_SOURCES,
)

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("knowledge_api")

app = FastAPI(
title="Knowledge Graph API",
description="Structured memory with SQLite + FAISS vector index",
version="1.0.0",
)

──────────────────────────────────────────────

Pydantic models

──────────────────────────────────────────────

class EntityCreate(BaseModel):
type: str = Field(..., description="Entity type")
subject: str = Field(..., min_length=1, description="Entity subject/name")
description: str = Field(default="", description="Description text")
aliases: list[str] = Field(default_factory=list, description="Alternative names")
tags: list[str] = Field(default_factory=list, description="Tags")
confidence: float = Field(default=1.0, ge=0, le=1, description="Confidence 0-1")
source: str = Field(default="live", description="Source type")

@field_validator("type")
@classmethod
def validate_type(cls, v):
    if v not in VALID_ENTITY_TYPES:
        raise ValueError(f"Invalid type '{v}'. Must be one of: {', '.join(sorted(VALID_ENTITY_TYPES))}")
    return v

@field_validator("source")
@classmethod
def validate_source(cls, v):
    if v not in VALID_SOURCES:
        raise ValueError(f"Invalid source '{v}'. Must be one of: {', '.join(sorted(VALID_SOURCES))}")
    return v

class RelationCreate(BaseModel):
source_entity_id: str = Field(..., description="Source entity UUID")
target_entity_id: str = Field(..., description="Target entity UUID")
relation_type: str = Field(..., description="Relation type from controlled vocabulary")
confidence: float = Field(default=1.0, ge=0, le=1, description="Confidence 0-1")
source: str = Field(default="live", description="Source type")

@field_validator("relation_type")
@classmethod
def validate_relation_type(cls, v):
    from graph import VAGUE_RELATION_TYPES, ValidationError
    if v in VAGUE_RELATION_TYPES:
        raise ValueError(
            f"Vague relation type '{v}' rejected. Use a specific type from: "
            f"{', '.join(sorted(VALID_RELATION_TYPES))}"
        )
    if v not in VALID_RELATION_TYPES:
        raise ValueError(
            f"Invalid relation type '{v}'. Must be one of: "
            f"{', '.join(sorted(VALID_RELATION_TYPES))}"
        )
    return v

@field_validator("source")
@classmethod
def validate_source(cls, v):
    if v not in VALID_SOURCES:
        raise ValueError(f"Invalid source '{v}'. Must be one of: {', '.join(sorted(VALID_SOURCES))}")
    return v

class MergeRequest(BaseModel):
entity_id_1: str = Field(..., description="Entity to keep")
entity_id_2: str = Field(..., description="Entity to merge into entity_1 and delete")

class DecayRequest(BaseModel):
days: int = Field(default=90, ge=1, description="Age threshold in days")
decay_rate: float = Field(default=0.1, ge=0, le=1, description="Confidence decay amount")

──────────────────────────────────────────────

Endpoints

──────────────────────────────────────────────

@app.get("/health")
def get_health():
return health()

@app.post("/entity")
def create_entity(data: EntityCreate):
"""Add a new entity to the knowledge graph."""
try:
entity_id = add_entity(
type_=data.type,
subject=data.subject,
description=data.description,
aliases=data.aliases,
tags=data.tags,
confidence=data.confidence,
source=data.source,
)
return {"entity_id": entity_id, "status": "created"}
except Exception as e:
raise HTTPException(status_code=400, detail=str(e))

@app.post("/relation")
def create_relation(data: RelationCreate):
"""Add a relation between two entities."""
try:
relation_id = add_relation(
source_id=data.source_entity_id,
target_id=data.target_entity_id,
relation_type=data.relation_type,
confidence=data.confidence,
source=data.source,
)
return {"relation_id": relation_id, "status": "created"}
except Exception as e:
raise HTTPException(status_code=400, detail=str(e))

@app.get("/search")
def search(q: str = Query(..., description="Search query"), top_k: int = Query(5, description="Number of results")):
"""Semantic search over entity descriptions."""
try:
results = search_entities(q, top_k)
return {"query": q, "results": results, "count": len(results)}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))

@app.get("/entity/{entity_id}")
def read_entity(entity_id: str):
"""Get an entity with all its relations."""
try:
entity = get_entity(entity_id)
if not entity:
raise HTTPException(status_code=404, detail="Entity not found")
return entity
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))

@app.get("/explore/{entity_id}")
def explore_entity(entity_id: str, depth: int = Query(1, ge=1, description="Traversal depth")):
"""Graph traversal — returns entity + neighbors."""
try:
result = explore(entity_id, depth=depth)
if not result:
raise HTTPException(status_code=404, detail="Entity not found")
return result
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))

@app.post("/merge")
def merge(data: MergeRequest):
"""Merge two entities. Entity 1 absorbs entity 2."""
try:
result = merge_entities(data.entity_id_1, data.entity_id_2)
return result
except Exception as e:
raise HTTPException(status_code=400, detail=str(e))

@app.post("/decay")
def decay(data: DecayRequest = DecayRequest()):
"""Decay confidence of old dream/extraction relations."""
try:
result = decay_stale(days=data.days, decay_rate=data.decay_rate)
return result
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))

@app.get("/infer")
def infer():
"""Find entity pairs with shared tags but no relation."""
try:
result = infer_relations()
return result
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))

@app.get("/vocabulary")
def get_vocabulary():
"""Get the controlled relation vocabulary and entity types."""
return {
"entity_types": sorted(VALID_ENTITY_TYPES),
"relation_types": sorted(VALID_RELATION_TYPES),
}