// 사용자 노드 예시
(alice:User {name: "Alice", age: 28, city: "서울"})

// 영화 노드 예시  
(inception:Movie {title: "인셉션", year: 2010, rating: 8.8})

// 레이블: User, Movie
// 프로퍼티: name, age, city, title, year, rating

// Alice가 인셉션을 시청하고 평점 9점을 줬다
(alice)-[:WATCHED {score: 9, date: "2024-01-15"}]->(inception)

// Alice와 Bob은 친구 관계
(alice)-[:FRIEND_OF {since: "2020-03-01"}]->(bob)

// 인셉션은 SF 장르에 속한다
(inception)-[:BELONGS_TO]->(sf:Genre {name: "SF"})

// 기본 패턴: MATCH - WHERE - RETURN
MATCH (u:User {name: "Alice"})-[:WATCHED]->(m:Movie)
WHERE m.rating > 8.0
RETURN m.title, m.year
ORDER BY m.rating DESC

// 결과: Alice가 본 영화 중 평점 8.0 이상인 것들

// 인덱스 생성
CREATE INDEX user_name_idx FOR (u:User) ON (u.name);
CREATE INDEX movie_title_idx FOR (m:Movie) ON (m.title);

// 유니크 제약조건 (자동으로 인덱스도 생성됨)
CREATE CONSTRAINT user_id_unique FOR (u:User) REQUIRE u.id IS UNIQUE;
CREATE CONSTRAINT movie_id_unique FOR (m:Movie) REQUIRE m.id IS UNIQUE;

# Neo4j 최신 버전 Docker 실행
docker run \
  --name neo4j-recommend \
  -p 7474:7474 \
  -p 7687:7687 \
  -e NEO4J_AUTH=neo4j/password123 \
  -e NEO4J_PLUGINS='["apoc", "graph-data-science"]' \
  -v $HOME/neo4j/data:/data \
  -v $HOME/neo4j/logs:/logs \
  -d \
  neo4j:5.15.0

# 실행 확인
docker ps
# 브라우저에서 http://localhost:7474 접속!

# pip으로 설치
pip install neo4j

# 또는 추천 시스템 전체 스택 한번에
pip install neo4j pandas numpy scikit-learn fastapi uvicorn

from neo4j import GraphDatabase

class Neo4jConnection:
    def __init__(self, uri, user, password):
        self.driver = GraphDatabase.driver(
            uri, 
            auth=(user, password),
            max_connection_pool_size=50,  # 커넥션 풀 설정
            connection_timeout=30
        )
    
    def close(self):
        self.driver.close()
    
    def query(self, query, parameters=None):
        with self.driver.session(database="neo4j") as session:
            result = session.run(query, parameters or {})
            return [record.data() for record in result]
    
    def write_query(self, query, parameters=None):
        with self.driver.session(database="neo4j") as session:
            result = session.execute_write(
                lambda tx: tx.run(query, parameters or {}).data()
            )
            return result

# 연결 인스턴스 생성
conn = Neo4jConnection(
    uri="bolt://localhost:7687",
    user="neo4j",
    password="password123"
)

# 연결 테스트
result = conn.query("RETURN 'Neo4j 연결 성공! 🎉' AS message")
print(result)
# [{'message': 'Neo4j 연결 성공! 🎉'}]

// APOC 설치 확인
CALL apoc.help("apoc")

// APOC 유용한 함수 예시
// 1. 배치 데이터 삽입
CALL apoc.periodic.iterate(
  "UNWIND range(1, 1000) AS id RETURN id",
  "CREATE (u:User {id: id, name: 'User_' + id})",
  {batchSize: 100}
)

// 2. JSON 파싱
CALL apoc.load.json("https://api.example.com/movies")
YIELD value
MERGE (m:Movie {id: value.id})
SET m.title = value.title

// ===== 노드 생성 =====

// 사용자 노드
CREATE (u:User {
  id: "user_001",
  name: "Alice",
  age: 28,
  city: "서울",
  joined: date("2023-01-15")
})

// 영화 노드
CREATE (m:Movie {
  id: "movie_001",
  title: "인셉션",
  year: 2010,
  rating: 8.8,
  runtime: 148,
  language: "영어"
})

// 장르 노드
CREATE (g:Genre {id: "genre_001", name: "SF"})
CREATE (g2:Genre {id: "genre_002", name: "스릴러"})

// 감독 노드
CREATE (d:Director {
  id: "dir_001", 
  name: "크리스토퍼 놀란",
  nationality: "영국"
})

// 태그 노드
CREATE (t:Tag {name: "마인드블로잉"})
CREATE (t2:Tag {name: "복잡한플롯"})

// ===== 관계 생성 =====

// 사용자가 영화를 시청
MATCH (u:User {id: "user_001"}), (m:Movie {id: "movie_001"})
CREATE (u)-[:WATCHED {
  score: 9.0,
  date: date("2024-01-20"),
  completed: true
}]->(m)

// 영화가 장르에 속함
MATCH (m:Movie {id: "movie_001"}), (g:Genre {name: "SF"})
CREATE (m)-[:BELONGS_TO]->(g)

// 영화의 감독
MATCH (m:Movie {id: "movie_001"}), (d:Director {id: "dir_001"})
CREATE (m)-[:DIRECTED_BY]->(d)

// 사용자 간 친구 관계
MATCH (u1:User {id: "user_001"}), (u2:User {id: "user_002"})
CREATE (u1)-[:FRIEND_OF {since: date("2022-06-01")}]->(u2)
CREATE (u2)-[:FRIEND_OF {since: date("2022-06-01")}]->(u1)

// 영화에 태그 추가
MATCH (m:Movie {id: "movie_001"}), (t:Tag {name: "마인드블로잉"})
CREATE (m)-[:TAGGED_WITH]->(t)

// ===== 사용자 기반 협업 필터링 =====
// "나와 비슷한 사용자들이 본 영화 추천"

// 1단계: 유사한 사용자 찾기 (공통 시청 영화 기반)
MATCH (target:User {id: "user_001"})-[:WATCHED]->(m:Movie)
      <-[:WATCHED]-(similar:User)
WHERE target <> similar
WITH similar, COUNT(m) AS commonMovies
ORDER BY commonMovies DESC
LIMIT 10
RETURN similar.name, commonMovies

// 2단계: 유사 사용자들이 본 영화 중 내가 안 본 것 추천
MATCH (target:User {id: "user_001"})-[:WATCHED]->(watched:Movie)
WITH target, COLLECT(watched.id) AS watchedIds

MATCH (target)-[:WATCHED]->(m:Movie)
      <-[:WATCHED]-(similar:User)-[:WATCHED]->(rec:Movie)
WHERE NOT rec.id IN watchedIds
  AND target <> similar

WITH rec, 
     COUNT(DISTINCT similar) AS recommendedBy,
     AVG(rec.rating) AS avgRating
ORDER BY recommendedBy DESC, avgRating DESC
LIMIT 10

RETURN rec.title, rec.year, rec.rating, recommendedBy

// ===== 재클라드 유사도(Jaccard Similarity) 기반 협업 필터링 =====
// 더 정교한 유사도 계산

MATCH (u1:User {id: "user_001"})-[:WATCHED]->(m:Movie)
WITH u1, COLLECT(m.id) AS u1Movies

MATCH (u2:User)-[:WATCHED]->(m2:Movie)
WHERE u2 <> u1
WITH u1, u1Movies, u2, COLLECT(m2.id) AS u2Movies

// 재클라드 유사도 = 교집합 / 합집합
WITH u1, u2,
     [x IN u1Movies WHERE x IN u2Movies] AS intersection,
     u1Movies + [x IN u2Movies WHERE NOT x IN u1Movies] AS union_set

WITH u1, u2,
     toFloat(SIZE(intersection)) / SIZE(union_set) AS jaccardSimilarity
WHERE jaccardSimilarity > 0.1
ORDER BY jaccardSimilarity DESC
LIMIT 5

RETURN u2.name, jaccardSimilarity

// ===== 콘텐츠 기반 필터링 =====
// "내가 좋아한 영화와 비슷한 속성의 영화 추천"

// 방법 1: 같은 장르 + 같은 감독 영화 추천
MATCH (u:User {id: "user_001"})-[w:WATCHED]->(liked:Movie)
WHERE w.score >= 8.0  // 높은 평점을 준 영화만
WITH u, liked

// 같은 장르의 다른 영화 찾기
MATCH (liked)-[:BELONGS_TO]->(g:Genre)<-[:BELONGS_TO]-(rec:Movie)
WHERE rec <> liked

// 내가 이미 본 영화 제외
AND NOT (u)-[:WATCHED]->(rec)

WITH rec, 
     COUNT(DISTINCT g) AS sharedGenres,
     rec.rating AS movieRating
ORDER BY sharedGenres DESC, movieRating DESC
LIMIT 10

RETURN rec.title, rec.year, rec.rating, sharedGenres

// 방법 2: 태그 기반 유사도
MATCH (u:User {id: "user_001"})-[w:WATCHED]->(liked:Movie)-[:TAGGED_WITH]->(t:Tag)
WHERE w.score >= 7.0
WITH u, COLLECT(DISTINCT t.name) AS likedTags

MATCH (rec:Movie)-[:TAGGED_WITH]->(t2:Tag)
WHERE t2.name IN likedTags
AND NOT (u)-[:WATCHED]->(rec)

WITH rec, COUNT(t2) AS tagMatches
ORDER BY tagMatches DESC
LIMIT 10

RETURN rec.title, tagMatches

// ===== 그래프 경로 기반 추천 =====
// "친구의 친구가 좋아한 영화" (소셜 추천)

MATCH (u:User {id: "user_001"})-[:FRIEND_OF*1..2]->(friend:User)
WHERE u <> friend
WITH u, friend, 
     length((u)-[:FRIEND_OF*..2]->(friend)) AS distance

MATCH (friend)-[w:WATCHED]->(rec:Movie)
WHERE w.score >= 8.0
AND NOT (u)-[:WATCHED]->(rec)

WITH rec, 
     SUM(1.0 / distance) AS socialScore,  // 가까운 친구일수록 가중치 높음
     AVG(w.score) AS avgFriendScore
ORDER BY socialScore DESC, avgFriendScore DESC
LIMIT 10

RETURN rec.title, rec.year, 
       ROUND(socialScore * 100) / 100 AS socialScore,
       ROUND(avgFriendScore * 10) / 10 AS avgFriendScore

// ===== PageRank 기반 영화 중요도 계산 =====
// Graph Data Science 라이브러리 활용
CALL gds.graph.project(
  'movieGraph',
  ['User', 'Movie'],
  {WATCHED: {orientation: 'UNDIRECTED'}}
)

CALL gds.pageRank.stream('movieGraph')
YIELD nodeId, score
WITH gds.util.asNode(nodeId) AS node, score
WHERE node:Movie
RETURN node.title, score
ORDER BY score DESC
LIMIT 10

// 1. 그래프 프로젝션 생성 (메모리에 그래프 로드)
CALL gds.graph.project(
  'userMovieGraph',           // 그래프 이름
  ['User', 'Movie'],          // 노드 레이블
  {
    WATCHED: {
      orientation: 'UNDIRECTED',
      properties: ['score']   // 관계 가중치
    }
  }
)
YIELD graphName, nodeCount, relationshipCount
RETURN graphName, nodeCount, relationshipCount

// 2. Node Similarity 실행 (유사한 사용자 쌍 찾기)
CALL gds.nodeSimilarity.stream('userMovieGraph', {
  topK: 10,                   // 각 노드당 상위 10개 유사 노드
  similarityCutoff: 0.1,      // 최소 유사도 임계값
  nodeLabels: ['User'],       // User 노드만 비교
  relationshipTypes: ['WATCHED']
})
YIELD node1, node2, similarity
WITH gds.util.asNode(node1) AS u1, 
     gds.util.asNode(node2) AS u2, 
     similarity
RETURN u1.name, u2.name, 
       ROUND(similarity * 100) / 100 AS similarity
ORDER BY similarity DESC
LIMIT 20

// 3. 유사도 관계를 그래프에 저장 (나중에 재사용)
CALL gds.nodeSimilarity.write('userMovieGraph', {
  topK: 10,
  similarityCutoff: 0.1,
  nodeLabels: ['User'],
  writeRelationshipType: 'SIMILAR_TO',
  writeProperty: 'score'
})
YIELD nodesCompared, relationshipsWritten
RETURN nodesCompared, relationshipsWritten

// Louvain 커뮤니티 탐지
CALL gds.louvain.stream('userMovieGraph', {
  nodeLabels: ['User'],
  relationshipTypes: ['SIMILAR_TO'],
  relationshipWeightProperty: 'score'
})
YIELD nodeId, communityId
WITH gds.util.asNode(nodeId) AS user, communityId
RETURN communityId, 
       COLLECT(user.name) AS members, 
       COUNT(*) AS groupSize
ORDER BY groupSize DESC
LIMIT 10

// 커뮤니티 ID를 노드에 저장
CALL gds.louvain.write('userMovieGraph', {
  nodeLabels: ['User'],
  writeProperty: 'communityId'
})
YIELD communityCount, modularity
RETURN communityCount, modularity

// 같은 커뮤니티 사용자들의 인기 영화 추천
MATCH (u:User {id: "user_001"})
WITH u.communityId AS myCommunity, u

MATCH (peer:User {communityId: myCommunity})-[w:WATCHED]->(m:Movie)
WHERE peer <> u
AND NOT (u)-[:WATCHED]->(m)
WITH m, COUNT(peer) AS peerCount, AVG(w.score) AS avgScore
ORDER BY peerCount DESC, avgScore DESC
LIMIT 10
RETURN m.title, peerCount, ROUND(avgScore * 10) / 10 AS avgScore

// 영화 PageRank 계산 (많이 시청되고 좋은 평점을 받은 영화)
CALL gds.pageRank.write('userMovieGraph', {
  nodeLabels: ['Movie'],
  maxIterations: 20,
  dampingFactor: 0.85,
  writeProperty: 'pageRankScore'
})
YIELD nodePropertiesWritten, ranIterations

// PageRank 높은 영화 = 트렌디한 영화로 추천
MATCH (m:Movie)
WHERE m.pageRankScore IS NOT NULL
RETURN m.title, m.year, 
       ROUND(m.pageRankScore * 1000) / 1000 AS pageRank
ORDER BY m.pageRankScore DESC
LIMIT 10

recommendation-api/
├── main.py              # FastAPI 앱 진입점
├── database.py          # Neo4j 연결 관리
├── models.py            # Pydantic 모델
├── recommender.py       # 추천 알고리즘 클래스
├── routers/
│   ├── recommend.py     # 추천 API 라우터
│   └── users.py         # 사용자 API 라우터
└── requirements.txt

# database.py
from neo4j import GraphDatabase
from contextlib import contextmanager
import os

class Neo4jDatabase:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.driver = GraphDatabase.driver(
                os.getenv("NEO4J_URI", "bolt://localhost:7687"),
                auth=(
                    os.getenv("NEO4J_USER", "neo4j"),
                    os.getenv("NEO4J_PASSWORD", "password123")
                ),
                max_connection_pool_size=50
            )
        return cls._instance
    
    @contextmanager
    def get_session(self):
        session = self.driver.session(database="neo4j")
        try:
            yield session
        finally:
            session.close()
    
    def execute_read(self, query: str, params: dict = None):
        with self.get_session() as session:
            result = session.run(query, params or {})
            return [record.data() for record in result]
    
    def execute_write(self, query: str, params: dict = None):
        with self.get_session() as session:
            result = session.execute_write(
                lambda tx: list(tx.run(query, params or {}))
            )
            return result
    
    def close(self):
        self.driver.close()

# 싱글톤 인스턴스
db = Neo4jDatabase()

# recommender.py
from database import db
from typing import List, Dict, Optional

class MovieRecommender:
    
    def collaborative_filter(
        self, 
        user_id: str, 
        limit: int = 10,
        min_similarity: float = 0.1
    ) -> List[Dict]:
        """협업 필터링 기반 추천"""
        query = """
        MATCH (target:User {id: $userId})-[:WATCHED]->(watched:Movie)
        WITH target, COLLECT(watched.id) AS watchedIds
        
        MATCH (target)-[:WATCHED]->(m:Movie)
              <-[:WATCHED]-(similar:User)-[:WATCHED]->(rec:Movie)
        WHERE NOT rec.id IN watchedIds
          AND target <> similar
        
        WITH rec,
             COUNT(DISTINCT similar) AS recommendedBy,
             AVG(rec.rating) AS avgRating,
             COLLECT(DISTINCT similar.name)[..3] AS topRecommenders
        
        ORDER BY recommendedBy DESC, avgRating DESC
        LIMIT $limit
        
        RETURN rec.id AS id,
               rec.title AS title,
               rec.year AS year,
               rec.rating AS rating,
               recommendedBy,
               topRecommenders,
               'collaborative' AS algorithm
        """
        return db.execute_read(query, {
            "userId": user_id, 
            "limit": limit
        })
    
    def content_based_filter(
        self, 
        user_id: str, 
        limit: int = 10,
        min_score: float = 7.0
    ) -> List[Dict]:
        """콘텐츠 기반 필터링 추천"""
        query = """
        MATCH (u:User {id: $userId})-[w:WATCHED]->(liked:Movie)
        WHERE w.score >= $minScore
        
        WITH u, liked
        MATCH (liked)-[:BELONGS_TO]->(g:Genre)<-[:BELONGS_TO]-(rec:Movie)
        WHERE rec <> liked
          AND NOT (u)-[:WATCHED]->(rec)
        
        WITH rec,
             COUNT(DISTINCT g) AS sharedGenres,
             COLLECT(DISTINCT g.name)[..3] AS matchedGenres
        
        ORDER BY sharedGenres DESC, rec.rating DESC
        LIMIT $limit
        
        RETURN rec.id AS id,
               rec.title AS title,
               rec.year AS year,
               rec.rating AS rating,
               sharedGenres,
               matchedGenres,
               'content_based' AS algorithm
        """
        return db.execute_read(query, {
            "userId": user_id,
            "minScore": min_score,
            "limit": limit
        })
    
    def social_recommend(
        self, 
        user_id: str, 
        limit: int = 10,
        max_depth: int = 2
    ) -> List[Dict]:
        """소셜 그래프 기반 추천 (친구의 친구)"""
        query = """
        MATCH (u:User {id: $userId})-[:FRIEND_OF*1..$maxDepth]->(friend:User)
        WHERE u <> friend
        
        WITH u, friend,
             length((u)-[:FRIEND_OF*..2]->(friend)) AS distance
        
        MATCH (friend)-[w:WATCHED]->(rec:Movie)
        WHERE w.score >= 7.5
          AND NOT (u)-[:WATCHED]->(rec)
        
        WITH rec,
             SUM(1.0 / distance) AS socialScore,
             AVG(w.score) AS avgFriendScore,
             COUNT(DISTINCT friend) AS friendCount
        
        ORDER BY socialScore DESC, avgFriendScore DESC
        LIMIT $limit
        
        RETURN rec.id AS id,
               rec.title AS title,
               rec.year AS year,
               rec.rating AS rating,
               ROUND(socialScore * 100) / 100 AS socialScore,
               friendCount,
               'social' AS algorithm
        """
        return db.execute_read(query, {
            "userId": user_id,
            "maxDepth": max_depth,
            "limit": limit
        })
    
    def hybrid_recommend(
        self, 
        user_id: str, 
        limit: int = 10
    ) -> List[Dict]:
        """하이브리드 추천 (협업 + 콘텐츠 + 소셜 조합)"""
        # 각 알고리즘에서 후보 수집
        collab = self.collaborative_filter(user_id, limit=20)
        content = self.content_based_filter(user_id, limit=20)
        social = self.social_recommend(user_id, limit=20)
        
        # 점수 통합 (가중 평균)
        scores = {}
        weights = {'collaborative': 0.4, 'content_based': 0.35, 'social': 0.25}
        
        for item in collab:
            mid = item['id']
            scores[mid] = scores.get(mid, {'item': item, 'score': 0})
            scores[mid]['score'] += weights['collaborative'] * (item.get('recommendedBy', 1))
        
        for item in content:
            mid = item['id']
            if mid not in scores:
                scores[mid] = {'item': item, 'score': 0}
            scores[mid]['score'] += weights['content_based'] * (item.get('sharedGenres', 1))
        
        for item in social:
            mid = item['id']
            if mid not in scores:
                scores[mid] = {'item': item, 'score': 0}
            scores[mid]['score'] += weights['social'] * (item.get('socialScore', 0.1))
        
        # 정렬 후 반환
        sorted_items = sorted(
            scores.values(), 
            key=lambda x: x['score'], 
            reverse=True
        )[:limit]
        
        return [
            {**item['item'], 'hybridScore': round(item['score'], 3), 'algorithm': 'hybrid'}
            for item in sorted_items
        ]

recommender = MovieRecommender()

# main.py
from fastapi import FastAPI, HTTPException, Query
from fastapi.middleware.cors import CORSMiddleware
from recommender import recommender
from typing import Optional

app = FastAPI(
    title="Neo4j 영화 추천 API",
    description="그래프 데이터베이스 기반 스마트 추천 시스템",
    version="1.0.0"
)

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_methods=["*"],
    allow_headers=["*"]
)

@app.get("/recommend/{user_id}")
async def get_recommendations(
    user_id: str,
    algorithm: str = Query(
        default="hybrid",
        enum=["collaborative", "content_based", "social", "hybrid"]
    ),
    limit: int = Query(default=10, ge=1, le=50)
):
    """사용자 맞춤 영화 추천"""
    try:
        if algorithm == "collaborative":
            results = recommender.collaborative_filter(user_id, limit)
        elif algorithm == "content_based":
            results = recommender.content_based_filter(user_id, limit)
        elif algorithm == "social":
            results = recommender.social_recommend(user_id, limit)
        else:  # hybrid
            results = recommender.hybrid_recommend(user_id, limit)
        
        if not results:
            raise HTTPException(
                status_code=404, 
                detail=f"사용자 {user_id}에 대한 추천 결과가 없습니다."
            )
        
        return {
            "userId": user_id,
            "algorithm": algorithm,
            "count": len(results),
            "recommendations": results
        }
    
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.post("/watch/{user_id}/{movie_id}")
async def record_watch(
    user_id: str, 
    movie_id: str, 
    score: float = Query(default=7.0, ge=1.0, le=10.0)
):
    """시청 기록 저장"""
    from database import db
    from datetime import date
    
    query = """
    MATCH (u:User {id: $userId}), (m:Movie {id: $movieId})
    MERGE (u)-[w:WATCHED]->(m)
    SET w.score = $score,
        w.date = date($today),
        w.updatedAt = datetime()
    RETURN u.name AS user, m.title AS movie, w.score AS score
    """
    
    result = db.execute_read(query, {
        "userId": user_id,
        "movieId": movie_id,
        "score": score,
        "today": str(date.today())
    })
    
    return {"message": "시청 기록 저장 완료", "data": result[0] if result else {}}

# 실행: uvicorn main:app --reload --port 8000

// 필수 인덱스 설정
CREATE INDEX user_id_idx FOR (u:User) ON (u.id);
CREATE INDEX movie_id_idx FOR (m:Movie) ON (m.id);
CREATE INDEX movie_rating_idx FOR (m:Movie) ON (m.rating);
CREATE INDEX movie_year_idx FOR (m:Movie) ON (m.year);

// 복합 인덱스 (여러 조건 동시 사용 시)
CREATE INDEX movie_year_rating FOR (m:Movie) ON (m.year, m.rating);

// 전문 검색 인덱스 (제목 검색용)
CREATE FULLTEXT INDEX movie_title_search FOR (m:Movie) ON EACH [m.title];

// 전문 검색 사용 예시
CALL db.index.fulltext.queryNodes("movie_title_search", "인셉션")
YIELD node, score
RETURN node.title, score
ORDER BY score DESC

# Python Redis 캐싱 적용
import redis
import json
from functools import wraps

redis_client = redis.Redis(host='localhost', port=6379, db=0)

def cache_recommendations(ttl: int = 300):  # 5분 캐시
    def decorator(func):
        @wraps(func)
        def wrapper(self, user_id: str, *args, **kwargs):
            cache_key = f"rec:{func.__name__}:{user_id}"
            
            # 캐시 확인
            cached = redis_client.get(cache_key)
            if cached:
                return json.loads(cached)
            
            # 캐시 없으면 실제 쿼리 실행
            result = func(self, user_id, *args, **kwargs)
            
            # 결과 캐싱
            redis_client.setex(
                cache_key, 
                ttl, 
                json.dumps(result, ensure_ascii=False)
            )
            return result
        return wrapper
    return decorator

class CachedRecommender(MovieRecommender):
    
    @cache_recommendations(ttl=300)
    def collaborative_filter(self, user_id, limit=10, min_similarity=0.1):
        return super().collaborative_filter(user_id, limit, min_similarity)
    
    @cache_recommendations(ttl=600)  # 콘텐츠 기반은 더 오래 캐시
    def content_based_filter(self, user_id, limit=10, min_score=7.0):
        return super().content_based_filter(user_id, limit, min_score)
    
    def invalidate_cache(self, user_id: str):
        """사용자 시청 기록 업데이트 시 캐시 무효화"""
        patterns = [
            f"rec:collaborative_filter:{user_id}",
            f"rec:content_based_filter:{user_id}",
            f"rec:social_recommend:{user_id}",
            f"rec:hybrid_recommend:{user_id}"
        ]
        for key in patterns:
            redis_client.delete(key)

// 쿼리 실행 계획 확인 (EXPLAIN)
EXPLAIN
MATCH (u:User {id: "user_001"})-[:WATCHED]->(m:Movie)
RETURN m.title

// 실제 실행 통계 확인 (PROFILE)
PROFILE
MATCH (u:User {id: "user_001"})-[:WATCHED]->(m:Movie)
WHERE m.rating > 8.0
RETURN m.title, m.rating
ORDER BY m.rating DESC

// 느린 쿼리 로그 확인
CALL dbms.listQueries()
YIELD queryId, query, elapsedTimeMillis
WHERE elapsedTimeMillis > 1000  // 1초 이상 걸린 쿼리
RETURN queryId, query, elapsedTimeMillis
ORDER BY elapsedTimeMillis DESC

# seed_data.py — 테스트 데이터 생성
import random
from datetime import date, timedelta
from database import db

# 영화 데이터
MOVIES = [
    {"id": "m001", "title": "인셉션", "year": 2010, "rating": 8.8},
    {"id": "m002", "title": "인터스텔라", "year": 2014, "rating": 8.6},
    {"id": "m003", "title": "매트릭스", "year": 1999, "rating": 8.7},
    {"id": "m004", "title": "기생충", "year": 2019, "rating": 8.5},
    {"id": "m005", "title": "올드보이", "year": 2003, "rating": 8.4},
    {"id": "m006", "title": "어벤져스", "year": 2012, "rating": 8.0},
    {"id": "m007", "title": "다크나이트", "year": 2008, "rating": 9.0},
    {"id": "m008", "title": "쇼생크탈출", "year": 1994, "rating": 9.3},
    {"id": "m009", "title": "라라랜드", "year": 2016, "rating": 8.0},
    {"id": "m010", "title": "겨울왕국", "year": 2013, "rating": 7.4},
]

GENRES = ["SF", "스릴러", "액션", "드라마", "로맨스", "애니메이션", "범죄"]
MOVIE_GENRES = {
    "m001": ["SF", "스릴러"], "m002": ["SF", "드라마"],
    "m003": ["SF", "액션"], "m004": ["드라마", "스릴러"],
    "m005": ["스릴러", "범죄"], "m006": ["액션", "SF"],
    "m007": ["액션", "범죄"], "m008": ["드라마"],
    "m009": ["로맨스", "드라마"], "m010": ["애니메이션"]
}

def seed_database():
    print("🌱 데이터 시딩 시작...")
    
    # 장르 생성
    for genre in GENRES:
        db.execute_read(
            "MERGE (g:Genre {name: $name})",
            {"name": genre}
        )
    print(f"✅ 장르 {len(GENRES)}개 생성")
    
    # 영화 생성 + 장르 연결
    for movie in MOVIES:
        db.execute_read(
            """
            MERGE (m:Movie {id: $id})
            SET m.title = $title, m.year = $year, m.rating = $rating
            """,
            movie
        )
        for genre_name in MOVIE_GENRES.get(movie["id"], []):
            db.execute_read(
                """
                MATCH (m:Movie {id: $movieId}), (g:Genre {name: $genre})
                MERGE (m)-[:BELONGS_TO]->(g)
                """,
                {"movieId": movie["id"], "genre": genre_name}
            )
    print(f"✅ 영화 {len(MOVIES)}개 생성")
    
    # 사용자 100명 생성
    cities = ["서울", "부산", "대구", "인천", "광주"]
    for i in range(1, 101):
        db.execute_read(
            """
            MERGE (u:User {id: $id})
            SET u.name = $name, u.age = $age, u.city = $city
            """,
            {
                "id": f"u{i:03d}",
                "name": f"사용자{i:03d}",
                "age": random.randint(18, 55),
                "city": random.choice(cities)
            }
        )
    print("✅ 사용자 100명 생성")
    
    # 시청 기록 생성 (사용자당 평균 5~15편)
    watch_count = 0
    for i in range(1, 101):
        user_id = f"u{i:03d}"
        watched_movies = random.sample(MOVIES, random.randint(3, 10))
        for movie in watched_movies:
            score = round(random.uniform(5.0, 10.0), 1)
            days_ago = random.randint(1, 365)
            watch_date = date.today() - timedelta(days=days_ago)
            db.execute_read(
                """
                MATCH (u:User {id: $userId}), (m:Movie {id: $movieId})
                MERGE (u)-[w:WATCHED]->(m)
                SET w.score = $score, w.date = date($date)
                """,
                {
                    "userId": user_id,
                    "movieId": movie["id"],
                    "score": score,
                    "date": str(watch_date)
                }
            )
            watch_count += 1
    print(f"✅ 시청 기록 {watch_count}개 생성")
    
    # 친구 관계 생성 (사용자당 평균 3~8명)
    friend_count = 0
    for i in range(1, 101):
        friends = random.sample(
            [j for j in range(1, 101) if j != i],
            random.randint(2, 6)
        )
        for j in friends:
            db.execute_read(
                """
                MATCH (u1:User {id: $id1}), (u2:User {id: $id2})
                MERGE (u1)-[:FRIEND_OF]->(u2)
                """,
                {"id1": f"u{i:03d}", "id2": f"u{j:03d}"}
            )
            friend_count += 1
    print(f"✅ 친구 관계 {friend_count}개 생성")
    print("🎉 데이터 시딩 완료!")

if __name__ == "__main__":
    seed_database()

# evaluation.py — 추천 시스템 평가
import numpy as np
from typing import List

def precision_at_k(recommended: List[str], relevant: List[str], k: int) -> float:
    """Precision@K 계산"""
    recommended_k = recommended[:k]
    hits = len(set(recommended_k) & set(relevant))
    return hits / k if k > 0 else 0.0

def recall_at_k(recommended: List[str], relevant: List[str], k: int) -> float:
    """Recall@K 계산"""
    recommended_k = recommended[:k]
    hits = len(set(recommended_k) & set(relevant))
    return hits / len(relevant) if relevant else 0.0

def ndcg_at_k(recommended: List[str], relevant: List[str], k: int) -> float:
    """NDCG@K 계산"""
    recommended_k = recommended[:k]
    
    # DCG 계산
    dcg = sum(
        1.0 / np.log2(i + 2)  # i+2 because i is 0-indexed
        for i, item in enumerate(recommended_k)
        if item in relevant
    )
    
    # IDCG 계산 (이상적인 DCG)
    ideal_hits = min(len(relevant), k)
    idcg = sum(1.0 / np.log2(i + 2) for i in range(ideal_hits))
    
    return dcg / idcg if idcg > 0 else 0.0

def evaluate_recommender(recommender, test_data: dict, k: int = 10) -> dict:
    """전체 평가 실행"""
    precisions, recalls, ndcgs = [], [], []
    
    for user_id, relevant_items in test_data.items():
        # 추천 결과 가져오기
        recs = recommender.hybrid_recommend(user_id, limit=k)
        recommended_ids = [r['id'] for r in recs]
        
        # 지표 계산
        p = precision_at_k(recommended_ids, relevant_items, k)
        r = recall_at_k(recommended_ids, relevant_items, k)
        n = ndcg_at_k(recommended_ids, relevant_items, k)
        
        precisions.append(p)
        recalls.append(r)
        ndcgs.append(n)
    
    avg_p = np.mean(precisions)
    avg_r = np.mean(recalls)
    f1 = 2 * avg_p * avg_r / (avg_p + avg_r) if (avg_p + avg_r) > 0 else 0
    
    return {
        f"Precision@{k}": round(avg_p, 4),
        f"Recall@{k}": round(avg_r, 4),
        f"F1@{k}": round(f1, 4),
        f"NDCG@{k}": round(np.mean(ndcgs), 4)
    }

# 사용 예시
# test_data = {"u001": ["m003", "m007", "m009"], ...}
# metrics = evaluate_recommender(recommender, test_data, k=10)
# print(metrics)
# {'Precision@10': 0.3, 'Recall@10': 0.6, 'F1@10': 0.4, 'NDCG@10': 0.45}

# docker-compose.yml
version: '3.8'

services:
  neo4j:
    image: neo4j:5.15.0
    container_name: neo4j
    ports:
      - "7474:7474"
      - "7687:7687"
    environment:
      NEO4J_AUTH: neo4j/password123
      NEO4J_PLUGINS: '["apoc", "graph-data-science"]'
      NEO4J_dbms_memory_heap_max__size: 2G
      NEO4J_dbms_memory_pagecache_size: 1G
    volumes:
      - neo4j_data:/data
      - neo4j_logs:/logs
    healthcheck:
      test: ["CMD", "cypher-shell", "-u", "neo4j", "-p", "password123", "RETURN 1"]
      interval: 30s
      timeout: 10s
      retries: 5

  redis:
    image: redis:7-alpine
    container_name: redis
    ports:
      - "6379:6379"
    command: redis-server --maxmemory 512mb --maxmemory-policy allkeys-lru

  api:
    build: .
    container_name: recommend-api
    ports:
      - "8000:8000"
    environment:
      NEO4J_URI: bolt://neo4j:7687
      NEO4J_USER: neo4j
      NEO4J_PASSWORD: password123
      REDIS_HOST: redis
    depends_on:
      neo4j:
        condition: service_healthy
      redis:
        condition: service_started
    command: uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4

volumes:
  neo4j_data:
  neo4j_logs:

# 전체 스택 실행
docker-compose up -d

# 로그 확인
docker-compose logs -f api

# 데이터 시딩
docker-compose exec api python seed_data.py

# API 테스트
curl http://localhost:8000/recommend/u001?algorithm=hybrid&limit=5