from pymongo import MongoClient

# 데이터베이스 연결
client = MongoClient('mongodb://localhost:27017/')
db = client['mydatabase']

# 컬렉션 접근
users = db.users
posts = db.posts

# 환경 변수를 통한 연결 문자열 관리
import os
from dotenv import load_dotenv

load_dotenv()  # .env 파일에서 환경 변수 로드
connection_string = os.getenv('MONGODB_URI')
secure_client = MongoClient(connection_string)

# 문서 생성 (Create)
def create_user(user_data):
    try:
        result = users.insert_one(user_data)
        return str(result.inserted_id)
    except Exception as e:
        print(f"Error: {e}")
        return None

# 문서 조회 (Read)
def get_user(user_id):
    from bson.objectid import ObjectId
    return users.find_one({'_id': ObjectId(user_id)})

# 여러 문서 조회
def get_users(criteria=None, limit=10, skip=0):
    if criteria is None:
        criteria = {}
    cursor = users.find(criteria).limit(limit).skip(skip)
    return list(cursor)
    
# 문서 수정 (Update)
def update_user(user_id, update_data):
    from bson.objectid import ObjectId
    result = users.update_one(
        {'_id': ObjectId(user_id)},
        {'$set': update_data}
    )
    return result.modified_count > 0

# 문서 삭제 (Delete)
def delete_user(user_id):
    from bson.objectid import ObjectId
    result = users.delete_one({'_id': ObjectId(user_id)})
    return result.deleted_count > 0

# 사용 예시
new_user = {
    'name': '홍길동',
    'email': '[email protected]',
    'age': 30,
    'interests': ['독서', '등산', '프로그래밍']
}

user_id = create_user(new_user)
print(f"생성된 사용자 ID: {user_id}")

# 사용자 조회
user = get_user(user_id)
print(f"조회된 사용자: {user}")

# 사용자 정보 수정
update_user(user_id, {'age': 31, 'interests': ['독서', '등산', '프로그래밍', '여행']})

# 조건부 쿼리
young_users = get_users({'age': {'$lt': 35}})

# 복잡한 쿼리
def find_active_users_with_posts():
    return users.aggregate([
        {
            '$match': {
                'status': 'active'
            }
        },
        {
            '$lookup': {
                'from': 'posts',
                'localField': '_id',
                'foreignField': 'user_id',
                'as': 'user_posts'
            }
        },
        {
            '$project': {
                'name': 1,
                'email': 1,
                'post_count': {'$size': '$user_posts'}
            }
        }
    ])

# 인덱스 생성
def create_indexes():
    users.create_index([('email', 1)], unique=True)
    posts.create_index([('title', 'text'), ('content', 'text')])

# 그룹화 쿼리
def group_users_by_age():
    return list(users.aggregate([
        {
            '$group': {
                '_id': {
                    'age_group': {
                        '$switch': {
                            'branches': [
                                {'case': {'$lt': ['$age', 20]}, 'then': '10대'},
                                {'case': {'$lt': ['$age', 30]}, 'then': '20대'},
                                {'case': {'$lt': ['$age', 40]}, 'then': '30대'}
                            ],
                            'default': '40대 이상'
                        }
                    }
                },
                'count': {'$sum': 1},
                'avg_age': {'$avg': '$age'}
            }
        },
        {
            '$sort': {'count': -1}
        }
    ]))

# 텍스트 검색
def search_posts(query):
    return list(posts.find(
        {'$text': {'$search': query}},
        {'score': {'$meta': 'textScore'}}
    ).sort([('score', {'$meta': 'textScore'})]))

# 지리공간 쿼리
def find_nearby_places(longitude, latitude, max_distance_km):
    return list(db.places.find({
        'location': {
            '$near': {
                '$geometry': {
                    'type': 'Point',
                    'coordinates': [longitude, latitude]
                },
                '$maxDistance': max_distance_km * 1000
            }
        }
    }))

from datetime import datetime
from bson.objectid import ObjectId

class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email
        self.created_at = datetime.utcnow()
    
    def to_dict(self):
        return {
            'name': self.name,
            'email': self.email,
            'created_at': self.created_at
        }
    
    @classmethod
    def from_dict(cls, data):
        user = cls(data['name'], data['email'])
        user.created_at = data.get('created_at', datetime.utcnow())
        return user

# 참조 관계 모델링
class Post:
    def __init__(self, title, content, author_id):
        self.title = title
        self.content = content
        self.author_id = author_id  # User의 _id를 참조
        self.created_at = datetime.utcnow()
        self.updated_at = self.created_at
        self.tags = []
    
    def to_dict(self):
        return {
            'title': self.title,
            'content': self.content,
            'author_id': self.author_id,
            'created_at': self.created_at,
            'updated_at': self.updated_at,
            'tags': self.tags
        }
    
    def add_tag(self, tag):
        if tag not in self.tags:
            self.tags.append(tag)
    
    @classmethod
    def from_dict(cls, data):
        post = cls(
            data['title'],
            data['content'],
            data['author_id']
        )
        post.created_at = data.get('created_at', datetime.utcnow())
        post.updated_at = data.get('updated_at', datetime.utcnow())
        post.tags = data.get('tags', [])
        return post

# 내장 문서 모델링
class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price
        self.created_at = datetime.utcnow()
        self.reviews = []  # 내장 문서
    
    def to_dict(self):
        return {
            'name': self.name,
            'price': self.price,
            'created_at': self.created_at,
            'reviews': self.reviews
        }
    
    def add_review(self, user_id, rating, comment):
        review = {
            'user_id': user_id,
            'rating': rating,
            'comment': comment,
            'created_at': datetime.utcnow()
        }
        self.reviews.append(review)

def bulk_insert(documents):
    try:
        result = users.insert_many(documents)
        return len(result.inserted_ids)
    except Exception as e:
        print(f"Bulk insert failed: {e}")
        return 0

def bulk_update(filter_criteria, update_data):
    try:
        result = users.update_many(
            filter_criteria,
            {'$set': update_data}
        )
        return result.modified_count
    except Exception as e:
        print(f"Bulk update failed: {e}")
        return 0

# 벌크 작업 전용 API 사용
def perform_bulk_operations():
    from pymongo import UpdateOne, InsertOne, DeleteOne
    
    bulk_operations = [
        InsertOne({'name': '김철수', 'age': 25}),
        InsertOne({'name': '이영희', 'age': 28}),
        UpdateOne({'name': '홍길동'}, {'$set': {'age': 40}}),
        DeleteOne({'name': '박지성'})
    ]
    
    try:
        result = users.bulk_write(bulk_operations, ordered=False)
        print(f"삽입: {result.inserted_count}, 수정: {result.modified_count}, 삭제: {result.deleted_count}")
        return True
    except Exception as e:
        print(f"Bulk operation failed: {e}")
        return False

# 대용량 데이터 처리
def process_large_dataset(file_path, batch_size=1000):
    import csv
    
    total_inserted = 0
    batch = []
    
    with open(file_path, 'r', encoding='utf-8') as csvfile:
        reader = csv.DictReader(csvfile)
        
        for i, row in enumerate(reader):
            # 필드 변환 및 정제
            if 'age' in row:
                row['age'] = int(row['age'])
            
            batch.append(row)
            
            # 배치 크기에 도달하면 삽입
            if len(batch) >= batch_size:
                inserted = bulk_insert(batch)
                total_inserted += inserted
                print(f"Inserted {inserted} documents. Total: {total_inserted}")
                batch = []
        
        # 남은 배치 처리
        if batch:
            inserted = bulk_insert(batch)
            total_inserted += inserted
            print(f"Inserted {inserted} documents. Total: {total_inserted}")
    
    return total_inserted

def transfer_points(from_user_id, to_user_id, points):
    from bson.objectid import ObjectId
    from pymongo.errors import PyMongoError
    
    # 세션 시작
    with client.start_session() as session:
        try:
            # 트랜잭션 시작
            with session.start_transaction():
                # 포인트 차감
                from_result = users.update_one(
                    {'_id': ObjectId(from_user_id)},
                    {'$inc': {'points': -points}},
                    session=session
                )
                
                if from_result.modified_count == 0:
                    raise ValueError(f"User {from_user_id} not found or not enough points")
                
                # 포인트 추가
                to_result = users.update_one(
                    {'_id': ObjectId(to_user_id)},
                    {'$inc': {'points': points}},
                    session=session
                )
                
                if to_result.modified_count == 0:
                    raise ValueError(f"User {to_user_id} not found")
                
                # 트랜잭션 로그 기록
                db.transactions.insert_one({
                    'from_user': ObjectId(from_user_id),
                    'to_user': ObjectId(to_user_id),
                    'points': points,
                    'timestamp': datetime.utcnow()
                }, session=session)
                
                return True
                
        except (PyMongoError, ValueError) as e:
            print(f"Transaction failed: {e}")
            return False

# 재시도 로직
def retry_operation(operation_func, max_retries=3, *args, **kwargs):
    from pymongo.errors import ConnectionFailure, OperationFailure
    
    retries = 0
    while retries < max_retries:
        try:
            return operation_func(*args, **kwargs)
        except (ConnectionFailure, OperationFailure) as e:
            retries += 1
            wait_time = 0.5 * (2 ** retries)  # 지수 백오프
            print(f"Operation failed: {e}. Retrying in {wait_time}s ({retries}/{max_retries})")
            import time
            time.sleep(wait_time)
    
    # 모든 재시도 실패
    raise Exception(f"Operation failed after {max_retries} retries")

# 쿼리 프로파일링
def analyze_slow_queries():
    # 프로파일링 레벨 설정 (0=꺼짐, 1=느린 쿼리만, 2=모든 쿼리)
    db.command({"profile": 1, "slowms": 100})
    
    # 느린 쿼리 확인
    slow_queries = list(db.system.profile.find().sort("millis", -1).limit(10))
    for query in slow_queries:
        print(f"Slow query: {query['op']} - {query['millis']}ms")
        print(f"Query: {query['query']}")
        print(f"Namespace: {query['ns']}")
        print("-" * 50)
    
    return slow_queries

# 데이터 모델 최적화 (예: 인덱스 추천)
def suggest_indexes():
    # 현재 인덱스 확인
    current_indexes = list(users.list_indexes())
    print(f"Current indexes: {len(current_indexes)}")
    
    # 인덱스 추천 로직
    pipeline = [
        {"$indexStats": {}},
        {"$sort": {"accesses.ops": -1}}
    ]
    
    index_stats = list(users.aggregate(pipeline))
    
    # 추천 인덱스 생성
    recommendations = []
    for stat in index_stats:
        if stat["accesses"]["ops"] > 1000:
            # 인덱스 계획 설정 예시
            recommendations.append({
                "collection": stat["name"],
                "field": stat["key"].keys(),
                "ops": stat["accesses"]["ops"]
            })
    
    return recommendations

# 쿼리 최적화 - 커버링 인덱스 활용
def optimized_users_query(min_age, max_age):
    # 1. 인덱스 생성
    users.create_index([("age", 1), ("name", 1)])
    
    # 2. 인덱스만 사용하는 쿼리 (필드 프로젝션에 주의)
    result = users.find(
        {"age": {"$gte": min_age, "$lte": max_age}},
        {"_id": 0, "name": 1, "age": 1}  # 인덱스에 포함된 필드만 사용
    ).hint([("age", 1), ("name", 1)])  # 명시적 인덱스 사용
    
    return list(result)

# 캐싱 레이어 구현
import functools

def cached_query(ttl_seconds=300):
    """쿼리 결과를 메모리에 캐싱하는 데코레이터"""
    cache = {}
    
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            # 캐시 키 생성
            key = str(args) + str(kwargs)
            
            # 캐시 확인
            now = datetime.utcnow()
            if key in cache and (now - cache[key]["timestamp"]).total_seconds() < ttl_seconds:
                print("Cache hit!")
                return cache[key]["result"]
            
            # 캐시 미스 - 함수 실행 및 결과 캐싱
            result = func(*args, **kwargs)
            cache[key] = {"result": result, "timestamp": now}
            print("Cache miss - updated cache")
            
            return result
        return wrapper
    return decorator

@cached_query(ttl_seconds=60)
def get_popular_posts(limit=10):
    return list(posts.find().sort("views", -1).limit(limit))