import json
from datetime import datetime
from typing import Optional, List, Dict

class NFTService:
    def __init__(self, db_manager):
        """
        NFT 서비스 초기화
        
        Args:
            db_manager: DatabaseManager 인스턴스
        """
        self.db = db_manager
    
    def create_collection(self, name: str, contract_address: str, 
                         description: str = None, creator_address: str = None,
                         total_supply: int = None) -> Optional[int]:
        """
        새로운 NFT 컬렉션 생성
        
        Args:
            name: 컬렉션 이름
            contract_address: 스마트 컨트랙트 주소
            description: 컬렉션 설명
            creator_address: 제작자 지갑 주소
            total_supply: 총 발행량
            
        Returns:
            생성된 컬렉션 ID 또는 None
        """
        query = '''
            INSERT INTO collections 
            (name, contract_address, description, creator_address, total_supply)
            VALUES (?, ?, ?, ?, ?)
        '''
        params = (name, contract_address, description, creator_address, total_supply)
        
        collection_id = self.db.execute_update(query, params)
        
        if collection_id:
            print(f"✅ 컬렉션 '{name}' 생성 완료! (ID: {collection_id})")
        else:
            print(f"❌ 컬렉션 생성 실패")
            
        return collection_id
    
    def add_nft_item(self, collection_id: int, token_id: str, 
                     name: str = None, description: str = None,
                     metadata_uri: str = None, image_uri: str = None,
                     current_owner: str = None, rarity_score: float = None,
                     attributes: Dict = None) -> Optional[int]:
        """
        NFT 아이템 추가
        
        Args:
            collection_id: 컬렉션 ID
            token_id: 토큰 ID
            name: NFT 이름
            description: NFT 설명
            metadata_uri: 메타데이터 URI
            image_uri: 이미지 URI
            current_owner: 현재 소유자 지갑 주소
            rarity_score: 희귀도 점수
            attributes: 속성 정보 (딕셔너리)
            
        Returns:
            생성된 NFT 아이템 ID 또는 None
        """
        # 속성을 JSON 문자열로 변환
        attributes_json = json.dumps(attributes) if attributes else None
        
        query = '''
            INSERT INTO nft_items 
            (collection_id, token_id, name, description, metadata_uri, 
             image_uri, current_owner, rarity_score, attributes)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
        '''
        params = (collection_id, token_id, name, description, metadata_uri,
                 image_uri, current_owner, rarity_score, attributes_json)
        
        nft_id = self.db.execute_update(query, params)
        
        if nft_id:
            print(f"✅ NFT '{name}' (Token ID: {token_id}) 추가 완료!")
        else:
            print(f"❌ NFT 추가 실패")
            
        return nft_id
    
    def get_collection_by_address(self, contract_address: str) -> Optional[Dict]:
        """
        컨트랙트 주소로 컬렉션 조회
        
        Args:
            contract_address: 스마트 컨트랙트 주소
            
        Returns:
            컬렉션 정보 딕셔너리 또는 None
        """
        query = '''
            SELECT * FROM collections 
            WHERE contract_address = ?
        '''
        results = self.db.execute_query(query, (contract_address,))
        
        if results:
            return dict(results[0])
        return None
    
    def get_nft_by_token(self, collection_id: int, token_id: str) -> Optional[Dict]:
        """
        토큰 ID로 NFT 조회
        
        Args:
            collection_id: 컬렉션 ID
            token_id: 토큰 ID
            
        Returns:
            NFT 정보 딕셔너리 또는 None
        """
        query = '''
            SELECT n.*, c.name as collection_name, c.contract_address
            FROM nft_items n
            JOIN collections c ON n.collection_id = c.id
            WHERE n.collection_id = ? AND n.token_id = ?
        '''
        results = self.db.execute_query(query, (collection_id, token_id))
        
        if results:
            nft_data = dict(results[0])
            # JSON 문자열을 딕셔너리로 변환
            if nft_data.get('attributes'):
                nft_data['attributes'] = json.loads(nft_data['attributes'])
            return nft_data
        return None
    
    def update_nft_owner(self, nft_id: int, new_owner: str) -> bool:
        """
        NFT 소유자 업데이트
        
        Args:
            nft_id: NFT 아이템 ID
            new_owner: 새로운 소유자 지갑 주소
            
        Returns:
            성공 여부
        """
        query = '''
            UPDATE nft_items 
            SET current_owner = ?, updated_at = CURRENT_TIMESTAMP
            WHERE id = ?
        '''
        result = self.db.execute_update(query, (new_owner, nft_id))
        
        if result is not None:
            print(f"✅ NFT 소유자 업데이트 완료!")
            return True
        else:
            print(f"❌ NFT 소유자 업데이트 실패")
            return False
    
    def get_collection_stats(self, collection_id: int) -> Dict:
        """
        컬렉션 통계 조회
        
        Args:
            collection_id: 컬렉션 ID
            
        Returns:
            통계 정보 딕셔너리
        """
        # 총 NFT 수
        query_total = '''
            SELECT COUNT(*) as total_nfts FROM nft_items 
            WHERE collection_id = ?
        '''
        total_result = self.db.execute_query(query_total, (collection_id,))
        total_nfts = total_result[0]['total_nfts'] if total_result else 0
        
        # 고유 소유자 수
        query_owners = '''
            SELECT COUNT(DISTINCT current_owner) as unique_owners 
            FROM nft_items 
            WHERE collection_id = ? AND current_owner IS NOT NULL
        '''
        owners_result = self.db.execute_query(query_owners, (collection_id,))
        unique_owners = owners_result[0]['unique_owners'] if owners_result else 0
        
        # 평균 희귀도 점수
        query_rarity = '''
            SELECT AVG(rarity_score) as avg_rarity 
            FROM nft_items 
            WHERE collection_id = ? AND rarity_score IS NOT NULL
        '''
        rarity_result = self.db.execute_query(query_rarity, (collection_id,))
        avg_rarity = rarity_result[0]['avg_rarity'] if rarity_result else 0
        
        return {
            'total_nfts': total_nfts,
            'unique_owners': unique_owners,
            'avg_rarity_score': round(avg_rarity, 2) if avg_rarity else 0
        }
    
    def search_nfts(self, collection_id: int = None, owner: str = None,
                   min_rarity: float = None, max_rarity: float = None,
                   limit: int = 100) -> List[Dict]:
        """
        NFT 검색
        
        Args:
            collection_id: 컬렉션 ID (선택)
            owner: 소유자 주소 (선택)
            min_rarity: 최소 희귀도 (선택)
            max_rarity: 최대 희귀도 (선택)
            limit: 결과 제한
            
        Returns:
            NFT 리스트
        """
        query = 'SELECT * FROM nft_items WHERE 1=1'
        params = []
        
        if collection_id:
            query += ' AND collection_id = ?'
            params.append(collection_id)
        
        if owner:
            query += ' AND current_owner = ?'
            params.append(owner)
        
        if min_rarity is not None:
            query += ' AND rarity_score >= ?'
            params.append(min_rarity)
        
        if max_rarity is not None:
            query += ' AND rarity_score <= ?'
            params.append(max_rarity)
        
        query += f' LIMIT {limit}'
        
        results = self.db.execute_query(query, tuple(params))
        
        nfts = []
        if results:
            for row in results:
                nft_data = dict(row)
                if nft_data.get('attributes'):
                    nft_data['attributes'] = json.loads(nft_data['attributes'])
                nfts.append(nft_data)
        
        return nfts

from datetime import datetime, timedelta
from typing import Optional, List, Dict, Tuple
import statistics

class SalesService:
    def __init__(self, db_manager):
        """
        판매 서비스 초기화
        
        Args:
            db_manager: DatabaseManager 인스턴스
        """
        self.db = db_manager
    
    def create_or_get_user(self, wallet_address: str, 
                          username: str = None) -> Optional[int]:
        """
        사용자 생성 또는 조회
        
        Args:
            wallet_address: 지갑 주소
            username: 사용자 이름 (선택)
            
        Returns:
            사용자 ID
        """
        # 기존 사용자 확인
        query_check = 'SELECT id FROM users WHERE wallet_address = ?'
        result = self.db.execute_query(query_check, (wallet_address,))
        
        if result:
            return result[0]['id']
        
        # 새 사용자 생성
        query_insert = '''
            INSERT INTO users (wallet_address, username)
            VALUES (?, ?)
        '''
        user_id = self.db.execute_update(query_insert, (wallet_address, username))
        
        if user_id:
            print(f"✅ 새 사용자 생성 완료! (ID: {user_id})")
        
        return user_id
    
    def record_sale(self, nft_item_id: int, seller_address: str,
                   buyer_address: str, price: float, currency: str = 'ETH',
                   platform_fee: float = 0, royalty_fee: float = 0,
                   transaction_hash: str = None, block_number: int = None,
                   sale_type: str = 'direct') -> Optional[int]:
        """
        판매 거래 기록
        
        Args:
            nft_item_id: NFT 아이템 ID
            seller_address: 판매자 지갑 주소
            buyer_address: 구매자 지갑 주소
            price: 판매 가격
            currency: 통화 (기본: ETH)
            platform_fee: 플랫폼 수수료
            royalty_fee: 로열티 수수료
            transaction_hash: 블록체인 트랜잭션 해시
            block_number: 블록 번호
            sale_type: 판매 유형 (direct, auction, offer)
            
        Returns:
            거래 ID 또는 None
        """
        # 판매자와 구매자 ID 가져오기
        seller_id = self.create_or_get_user(seller_address)
        buyer_id = self.create_or_get_user(buyer_address)
        
        if not seller_id or not buyer_id:
            print("❌ 사용자 정보 처리 실패")
            return None
        
        # 판매 거래 기록
        query = '''
            INSERT INTO sales_transactions
            (nft_item_id, seller_id, buyer_id, price, currency,
             platform_fee, royalty_fee, transaction_hash, block_number, sale_type)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        '''
        params = (nft_item_id, seller_id, buyer_id, price, currency,
                 platform_fee, royalty_fee, transaction_hash, block_number, sale_type)
        
        sale_id = self.db.execute_update(query, params)
        
        if sale_id:
            # NFT 소유자 업데이트
            update_query = '''
                UPDATE nft_items 
                SET current_owner = ?, updated_at = CURRENT_TIMESTAMP
                WHERE id = ?
            '''
            self.db.execute_update(update_query, (buyer_address, nft_item_id))
            
            # 가격 히스토리 기록
            history_query = '''
                INSERT INTO price_history (nft_item_id, price, currency, event_type)
                VALUES (?, ?, ?, 'sale')
            '''
            self.db.execute_update(history_query, (nft_item_id, price, currency))
            
            # 사용자 통계 업데이트
            self._update_user_stats(seller_id, buyer_id)
            
            print(f"✅ 판매 거래 기록 완료! (ID: {sale_id})")
            print(f"   가격: {price} {currency}")
            print(f"   플랫폼 수수료: {platform_fee} {currency}")
            print(f"   로열티: {royalty_fee} {currency}")
        else:
            print("❌ 판매 거래 기록 실패")
        
        return sale_id
    
    def _update_user_stats(self, seller_id: int, buyer_id: int):
        """사용자 통계 업데이트 (내부 메서드)"""
        # 판매자 통계
        query_seller = '''
            UPDATE users 
            SET total_sales = total_sales + 1
            WHERE id = ?
        '''
        self.db.execute_update(query_seller, (seller_id,))
        
        # 구매자 통계
        query_buyer = '''
            UPDATE users 
            SET total_purchases = total_purchases + 1
            WHERE id = ?
        '''
        self.db.execute_update(query_buyer, (buyer_id,))
    
    def get_nft_sales_history(self, nft_item_id: int) -> List[Dict]:
        """
        NFT 판매 이력 조회
        
        Args:
            nft_item_id: NFT 아이템 ID
            
        Returns:
            판매 이력 리스트
        """
        query = '''
            SELECT 
                st.*,
                seller.wallet_address as seller_address,
                buyer.wallet_address as buyer_address,
                n.name as nft_name,
                n.token_id
            FROM sales_transactions st
            JOIN users seller ON st.seller_id = seller.id
            JOIN users buyer ON st.buyer_id = buyer.id
            JOIN nft_items n ON st.nft_item_id = n.id
            WHERE st.nft_item_id = ?
            ORDER BY st.sold_at DESC
        '''
        results = self.db.execute_query(query, (nft_item_id,))
        
        return [dict(row) for row in results] if results else []
    
    def get_user_sales(self, wallet_address: str, 
                      as_seller: bool = True) -> List[Dict]:
        """
        사용자의 판매/구매 이력 조회
        
        Args:
            wallet_address: 지갑 주소
            as_seller: True면 판매 이력, False면 구매 이력
            
        Returns:
            거래 이력 리스트
        """
        role = 'seller' if as_seller else 'buyer'
        
        query = f'''
            SELECT 
                st.*,
                n.name as nft_name,
                n.token_id,
                n.image_uri,
                c.name as collection_name,
                other_user.wallet_address as counterparty_address
            FROM sales_transactions st
            JOIN nft_items n ON st.nft_item_id = n.id
            JOIN collections c ON n.collection_id = c.id
            JOIN users u ON st.{role}_id = u.id
            JOIN users other_user ON st.{'buyer' if as_seller else 'seller'}_id = other_user.id
            WHERE u.wallet_address = ?
            ORDER BY st.sold_at DESC
        '''
        results = self.db.execute_query(query, (wallet_address,))
        
        return [dict(row) for row in results] if results else []
    
    def get_collection_sales_stats(self, collection_id: int, 
                                   days: int = 30) -> Dict:
        """
        컬렉션 판매 통계
        
        Args:
            collection_id: 컬렉션 ID
            days: 조회 기간 (일)
            
        Returns:
            통계 정보 딕셔너리
        """
        start_date = datetime.now() - timedelta(days=days)
        
        query = '''
            SELECT 
                COUNT(*) as total_sales,
                SUM(st.price) as total_volume,
                AVG(st.price) as avg_price,
                MIN(st.price) as floor_price,
                MAX(st.price) as highest_sale
            FROM sales_transactions st
            JOIN nft_items n ON st.nft_item_id = n.id
            WHERE n.collection_id = ? 
            AND st.sold_at >= ?
            AND st.status = 'completed'
        '''
        result = self.db.execute_query(query, (collection_id, start_date))
        
        if result and result[0]['total_sales']:
            stats = dict(result[0])
            
            # 가격 변동 계산
            price_trend = self._calculate_price_trend(collection_id, days)
            stats['price_trend'] = price_trend
            
            # 고유 거래자 수
            unique_traders = self._get_unique_traders(collection_id, days)
            stats['unique_traders'] = unique_traders
            
            return stats
        
        return {
            'total_sales': 0,
            'total_volume': 0,
            'avg_price': 0,
            'floor_price': 0,
            'highest_sale': 0,
            'price_trend': 0,
            'unique_traders': 0
        }
    
    def _calculate_price_trend(self, collection_id: int, days: int) -> float:
        """가격 추세 계산 (내부 메서드)"""
        query = '''
            SELECT st.price, st.sold_at
            FROM sales_transactions st
            JOIN nft_items n ON st.nft_item_id = n.id
            WHERE n.collection_id = ?
            AND st.sold_at >= datetime('now', '-' || ? || ' days')
            ORDER BY st.sold_at ASC
        '''
        results = self.db.execute_query(query, (collection_id, days))
        
        if not results or len(results) < 2:
            return 0
        
        # 첫 거래와 마지막 거래 가격 비교
        first_price = results[0]['price']
        last_price = results[-1]['price']
        
        if first_price == 0:
            return 0
        
        trend = ((last_price - first_price) / first_price) * 100
        return round(trend, 2)
    
    def _get_unique_traders(self, collection_id: int, days: int) -> int:
        """고유 거래자 수 계산 (내부 메서드)"""
        query = '''
            SELECT COUNT(DISTINCT u.wallet_address) as unique_count
            FROM (
                SELECT seller_id as user_id FROM sales_transactions st
                JOIN nft_items n ON st.nft_item_id = n.id
                WHERE n.collection_id = ?
                AND st.sold_at >= datetime('now', '-' || ? || ' days')
                UNION
                SELECT buyer_id as user_id FROM sales_transactions st
                JOIN nft_items n ON st.nft_item_id = n.id
                WHERE n.collection_id = ?
                AND st.sold_at >= datetime('now', '-' || ? || ' days')
            ) traders
            JOIN users u ON traders.user_id = u.id
        '''
        result = self.db.execute_query(query, (collection_id, days, collection_id, days))
        
        return result[0]['unique_count'] if result else 0
    
    def get_top_sales(self, limit: int = 10, days: int = 7) -> List[Dict]:
        """
        최고 판매 거래 조회
        
        Args:
            limit: 결과 개수
            days: 조회 기간 (일)
            
        Returns:
            최고 판매 리스트
        """
        start_date = datetime.now() - timedelta(days=days)
        
        query = '''
            SELECT 
                st.*,
                n.name as nft_name,
                n.token_id,
                n.image_uri,
                c.name as collection_name,
                seller.wallet_address as seller_address,
                buyer.wallet_address as buyer_address
            FROM sales_transactions st
            JOIN nft_items n ON st.nft_item_id = n.id
            JOIN collections c ON n.collection_id = c.id
            JOIN users seller ON st.seller_id = seller.id
            JOIN users buyer ON st.buyer_id = buyer.id
            WHERE st.sold_at >= ?
            AND st.status = 'completed'
            ORDER BY st.price DESC
            LIMIT ?
        '''
        results = self.db.execute_query(query, (start_date, limit))
        
        return [dict(row) for row in results] if results else []
    
    def get_price_distribution(self, collection_id: int) -> Dict:
        """
        가격 분포 분석
        
        Args:
            collection_id: 컬렉션 ID
            
        Returns:
            가격 분포 정보
        """
        query = '''
            SELECT price
            FROM sales_transactions st
            JOIN nft_items n ON st.nft_item_id = n.id
            WHERE n.collection_id = ?
            AND st.status = 'completed'
        '''
        results = self.db.execute_query(query, (collection_id,))
        
        if not results:
            return {}
        
        prices = [row['price'] for row in results]
        
        return {
            'min': min(prices),
            'max': max(prices),
            'mean': round(statistics.mean(prices), 4),
            'median': round(statistics.median(prices), 4),
            'stdev': round(statistics.stdev(prices), 4) if len(prices) > 1 else 0,
            'total_samples': len(prices)
        }

import logging
from database.db_manager import DatabaseManager
from services.nft_service import NFTService
from services.sales_service import SalesService

# 로깅 설정
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

def initialize_system():
    """시스템 초기화"""
    print("🚀 NFT 판매 데이터 관리 시스템 시작!\n")
    
    # 데이터베이스 매니저 생성
    db = DatabaseManager('nft_sales.db')
    
    # 연결 및 테이블 생성
    if db.connect():
        db.create_tables()
        return db
    return None

def demo_collection_creation(nft_service):
    """컬렉션 생성 데모"""
    print("\n" + "="*50)
    print("📦 컬렉션 생성 데모")
    print("="*50 + "\n")
    
    # CryptoPunks 스타일 컬렉션 생성
    collection_id = nft_service.create_collection(
        name="CyberPunks",
        contract_address="0x1234567890abcdef1234567890abcdef12345678",
        description="10,000개의 독특한 사이버펑크 캐릭터 NFT",
        creator_address="0xCreator123456789",
        total_supply=10000
    )
    
    return collection_id

def demo_nft_creation(nft_service, collection_id):
    """NFT 생성 데모"""
    print("\n" + "="*50)
    print("🎨 NFT 아이템 생성 데모")
    print("="*50 + "\n")
    
    # 여러 NFT 생성
    nfts = [
        {
            "token_id": "1",
            "name": "CyberPunk #1",
            "description": "희귀한 레이저 눈을 가진 사이버펑크",
            "metadata_uri": "ipfs://QmXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/1",
            "image_uri": "ipfs://QmYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY/1.png",
            "current_owner": "0xOwner111111111",
            "rarity_score": 95.5,
            "attributes": {
                "background": "Purple",
                "eyes": "Laser",
                "hair": "Mohawk",
                "accessories": "Cybernetic Implant"
            }
        },
        {
            "token_id": "2",
            "name": "CyberPunk #2",
            "description": "클래식 선글라스를 착용한 사이버펑크",
            "metadata_uri": "ipfs://QmXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/2",
            "image_uri": "ipfs://QmYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY/2.png",
            "current_owner": "0xOwner222222222",
            "rarity_score": 78.3,
            "attributes": {
                "background": "Blue",
                "eyes": "Sunglasses",
                "hair": "Bald",
                "accessories": "Earring"
            }
        },
        {
            "token_id": "3",
            "name": "CyberPunk #3",
            "description": "네온 마스크를 착용한 신비로운 사이버펑크",
            "metadata_uri": "ipfs://QmXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/3",
            "image_uri": "ipfs://QmYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY/3.png",
            "current_owner": "0xOwner333333333",
            "rarity_score": 88.7,
            "attributes": {
                "background": "Black",
                "eyes": "Neon Mask",
                "hair": "Long",
                "accessories": "Chain"
            }
        }
    ]
    
    nft_ids = []
    for nft_data in nfts:
        nft_id = nft_service.add_nft_item(
            collection_id=collection_id,
            **nft_data
        )
        nft_ids.append(nft_id)
    
    return nft_ids

def demo_sales_recording(sales_service, nft_ids):
    """판매 기록 데모"""
    print("\n" + "="*50)
    print("💰 판매 거래 기록 데모")
    print("="*50 + "\n")
    
    # 첫 번째 NFT 판매
    sale1 = sales_service.record_sale(
        nft_item_id=nft_ids[0],
        seller_address="0xOwner111111111",
        buyer_address="0xBuyer111111111",
        price=5.5,
        currency="ETH",
        platform_fee=0.275,  # 5% 플랫폼 수수료
        royalty_fee=0.55,    # 10% 로열티
        transaction_hash="0xTxHash1111111111111111111111111111111111111111111111111111111111",
        block_number=15000000,
        sale_type="direct"
    )
    
    # 두 번째 NFT 판매
    sale2 = sales_service.record_sale(
        nft_item_id=nft_ids[1],
        seller_address="0xOwner222222222",
        buyer_address="0xBuyer222222222",
        price=3.2,
        currency="ETH",
        platform_fee=0.16,
        royalty_fee=0.32,
        transaction_hash="0xTxHash2222222222222222222222222222222222222222222222222222222222",
        block_number=15000100,
        sale_type="auction"
    )
    
    # 세 번째 NFT 판매
    sale3 = sales_service.record_sale(
        nft_item_id=nft_ids[2],
        seller_address="0xOwner333333333",
        buyer_address="0xBuyer333333333",
        price=7.8,
        currency="ETH",
        platform_fee=0.39,
        royalty_fee=0.78,
        transaction_hash="0xTxHash3333333333333333333333333333333333333333333333333333333333",
        block_number=15000200,
        sale_type="direct"
    )
    
    return [sale1, sale2, sale3]

def demo_statistics(nft_service, sales_service, collection_id, nft_ids):
    """통계 조회 데모"""
    print("\n" + "="*50)
    print("📊 통계 분석 데모")
    print("="*50 + "\n")
    
    # 컬렉션 통계
    print("📦 컬렉션 통계:")
    collection_stats = nft_service.get_collection_stats(collection_id)
    print(f"   총 NFT 수: {collection_stats['total_nfts']}")
    print(f"   고유 소유자: {collection_stats['unique_owners']}")
    print(f"   평균 희귀도: {collection_stats['avg_rarity_score']}")
    
    # 판매 통계
    print("\n💰 판매 통계 (최근 30일):")
    sales_stats = sales_service.get_collection_sales_stats(collection_id, days=30)
    print(f"   총 거래 수: {sales_stats['total_sales']}")
    print(f"   총 거래량: {sales_stats['total_volume']:.2f} ETH")
    print(f"   평균 가격: {sales_stats['avg_price']:.2f} ETH")
    print(f"   바닥 가격: {sales_stats['floor_price']:.2f} ETH")
    print(f"   최고 판매가: {sales_stats['highest_sale']:.2f} ETH")
    print(f"   가격 추세: {sales_stats['price_trend']:+.2f}%")
    print(f"   고유 거래자: {sales_stats['unique_traders']}")
    
    # NFT 판매 이력
    print(f"\n📜 NFT #{nft_ids[0]} 판매 이력:")
    history = sales_service.get_nft_sales_history(nft_ids[0])
    for sale in history:
        print(f"   {sale['sold_at']}: {sale['price']} {sale['currency']}")
        print(f"   판매자: {sale['seller_address'][:10]}...")
        print(f"   구매자: {sale['buyer_address'][:10]}...")
        print()
    
    # 최고 판매 거래
    print("🏆 최고 판매 거래 (최근 7일):")
    top_sales = sales_service.get_top_sales(limit=5, days=7)
    for i, sale in enumerate(top_sales, 1):
        print(f"   {i}. {sale['nft_name']}: {sale['price']} {sale['currency']}")
    
    # 가격 분포
    print("\n📈 가격 분포 분석:")
    price_dist = sales_service.get_price_distribution(collection_id)
    if price_dist:
        print(f"   최소: {price_dist['min']:.2f} ETH")
        print(f"   최대: {price_dist['max']:.2f} ETH")
        print(f"   평균: {price_dist['mean']:.2f} ETH")
        print(f"   중앙값: {price_dist['median']:.2f} ETH")
        print(f"   표준편차: {price_dist['stdev']:.2f} ETH")
        print(f"   샘플 수: {price_dist['total_samples']}")

def demo_search(nft_service, collection_id):
    """검색 기능 데모"""
    print("\n" + "="*50)
    print("🔍 NFT 검색 데모")
    print("="*50 + "\n")
    
    # 희귀도 기준 검색
    print("높은 희귀도 NFT 검색 (85점 이상):")
    rare_nfts = nft_service.search_nfts(
        collection_id=collection_id,
        min_rarity=85.0
    )
    
    for nft in rare_nfts:
        print(f"   {nft['name']}: 희귀도 {nft['rarity_score']}")
        print(f"   소유자: {nft['current_owner'][:10]}...")
        print()

def main():
    """메인 함수"""
    # 시스템 초기화
    db = initialize_system()
    if not db:
        print("❌ 시스템 초기화 실패")
        return
    
    # 서비스 인스턴스 생성
    nft_service = NFTService(db)
    sales_service = SalesService(db)
    
    try:
        # 데모 실행
        collection_id = demo_collection_creation(nft_service)
        nft_ids = demo_nft_creation(nft_service, collection_id)
        sale_ids = demo_sales_recording(sales_service, nft_ids)
        demo_statistics(nft_service, sales_service, collection_id, nft_ids)
        demo_search(nft_service, collection_id)
        
        print("\n" + "="*50)
        print("✅ 모든 데모 완료!")
        print("="*50)
        
    except Exception as e:
        print(f"\n❌ 오류 발생: {e}")
        logging.error(f"오류 발생: {e}", exc_info=True)
    
    finally:
        # 데이터베이스 연결 종료
        db.disconnect()
        print("\n👋 시스템 종료")

if __name__ == "__main__":
    main()

import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime, timedelta
from typing import List, Dict
import json

class NFTAnalytics:
    def __init__(self, db_manager):
        """
        NFT 분석 도구 초기화
        
        Args:
            db_manager: DatabaseManager 인스턴스
        """
        self.db = db_manager
    
    def get_sales_dataframe(self, collection_id: int = None, 
                           days: int = 30) -> pd.DataFrame:
        """
        판매 데이터를 Pandas DataFrame으로 변환
        
        Args:
            collection_id: 컬렉션 ID (선택)
            days: 조회 기간
            
        Returns:
            DataFrame
        """
        start_date = datetime.now() - timedelta(days=days)
        
        query = '''
            SELECT 
                st.id,
                st.price,
                st.currency,
                st.platform_fee,
                st.royalty_fee,
                st.sale_type,
                st.sold_at,
                n.name as nft_name,
                n.token_id,
                n.rarity_score,
                c.name as collection_name
            FROM sales_transactions st
            JOIN nft_items n ON st.nft_item_id = n.id
            JOIN collections c ON n.collection_id = c.id
            WHERE st.sold_at >= ?
        '''
        
        params = [start_date]
        
        if collection_id:
            query += ' AND n.collection_id = ?'
            params.append(collection_id)
        
        query += ' ORDER BY st.sold_at ASC'
        
        results = self.db.execute_query(query, tuple(params))
        
        if not results:
            return pd.DataFrame()
        
        # DataFrame 생성
        df = pd.DataFrame([dict(row) for row in results])
        df['sold_at'] = pd.to_datetime(df['sold_at'])
        
        return df
    
    def calculate_daily_volume(self, df: pd.DataFrame) -> pd.DataFrame:
        """
        일별 거래량 계산
        
        Args:
            df: 판매 데이터 DataFrame
            
        Returns:
            일별 통계 DataFrame
        """
        if df.empty:
            return pd.DataFrame()
        
        df['date'] = df['sold_at'].dt.date
        
        daily_stats = df.groupby('date').agg({
            'price': ['sum', 'mean', 'count'],
            'platform_fee': 'sum',
            'royalty_fee': 'sum'
        }).reset_index()
        
        daily_stats.columns = ['date', 'total_volume', 'avg_price', 
                              'sales_count', 'total_platform_fee', 'total_royalty']
        
        return daily_stats
    
    def analyze_rarity_price_correlation(self, collection_id: int) -> Dict:
        """
        희귀도와 가격의 상관관계 분석
        
        Args:
            collection_id: 컬렉션 ID
            
        Returns:
            분석 결과 딕셔너리
        """
        query = '''
            SELECT 
                n.rarity_score,
                AVG(st.price) as avg_price,
                COUNT(*) as sales_count
            FROM sales_transactions st
            JOIN nft_items n ON st.nft_item_id = n.id
            WHERE n.collection_id = ?
            AND n.rarity_score IS NOT NULL
            GROUP BY n.rarity_score
            ORDER BY n.rarity_score
        '''
        
        results = self.db.execute_query(query, (collection_id,))
        
        if not results:
            return {}
        
        df = pd.DataFrame([dict(row) for row in results])
        
        # 상관계수 계산
        correlation = df['rarity_score'].corr(df['avg_price'])
        
        return {
            'correlation': round(correlation, 4),
            'data': df.to_dict('records'),
            'interpretation': self._interpret_correlation(correlation)
        }
    
    def _interpret_correlation(self, corr: float) -> str:
        """상관계수 해석"""
        if corr > 0.7:
            return "강한 양의 상관관계 - 희귀도가 높을수록 가격이 높음"
        elif corr > 0.3:
            return "중간 양의 상관관계 - 희귀도가 가격에 영향을 줌"
        elif corr > -0.3:
            return "약한 상관관계 - 희귀도와 가격의 관계가 불명확"
        elif corr > -0.7:
            return "중간 음의 상관관계 - 희귀도가 낮을수록 가격이 높음"
        else:
            return "강한 음의 상관관계 - 희귀도와 가격이 반대로 움직임"
    
    def get_holder_distribution(self, collection_id: int) -> Dict:
        """
        소유자 분포 분석
        
        Args:
            collection_id: 컬렉션 ID
            
        Returns:
            분포 정보
        """
        query = '''
            SELECT 
                current_owner,
                COUNT(*) as nft_count
            FROM nft_items
            WHERE collection_id = ?
            AND current_owner IS NOT NULL
            GROUP BY current_owner
            ORDER BY nft_count DESC
        '''
        
        results = self.db.execute_query(query, (collection_id,))
        
        if not results:
            return {}
        
        df = pd.DataFrame([dict(row) for row in results])
        
        total_nfts = df['nft_count'].sum()
        total_holders = len(df)
        
        # 상위 소유자 분석
        top_10_count = df.head(10)['nft_count'].sum()
        top_10_percentage = (top_10_count / total_nfts) * 100
        
        # 고래(whale) 정의: 전체의 5% 이상 보유
        whale_threshold = total_nfts * 0.05
        whales = df[df['nft_count'] >= whale_threshold]
        
        return {
            'total_holders': total_holders,
            'total_nfts': total_nfts,
            'avg_nfts_per_holder': round(total_nfts / total_holders, 2),
            'top_10_holders_percentage': round(top_10_percentage, 2),
            'whale_count': len(whales),
            'whale_holdings': int(whales['nft_count'].sum()),
            'distribution_data': df.head(20).to_dict('records')
        }
    
    def analyze_sale_types(self, collection_id: int) -> Dict:
        """
        판매 유형별 분석
        
        Args:
            collection_id: 컬렉션 ID
            
        Returns:
            판매 유형 통계
        """
        query = '''
            SELECT 
                st.sale_type,
                COUNT(*) as count,
                AVG(st.price) as avg_price,
                SUM(st.price) as total_volume
            FROM sales_transactions st
            JOIN nft_items n ON st.nft_item_id = n.id
            WHERE n.collection_id = ?
            GROUP BY st.sale_type
        '''
        
        results = self.db.execute_query(query, (collection_id,))
        
        if not results:
            return {}
        
        return {
            'by_type': [dict(row) for row in results]
        }
    
    def get_price_momentum(self, collection_id: int, 
                          window_days: int = 7) -> Dict:
        """
        가격 모멘텀 분석
        
        Args:
            collection_id: 컬렉션 ID
            window_days: 이동평균 윈도우 (일)
            
        Returns:
            모멘텀 정보
        """
        df = self.get_sales_dataframe(collection_id, days=30)
        
        if df.empty:
            return {}
        
        daily_stats = self.calculate_daily_volume(df)
        
        # 이동평균 계산
        daily_stats['ma_price'] = daily_stats['avg_price'].rolling(
            window=window_days, min_periods=1
        ).mean()
        
        # 현재 가격과 이동평균 비교
        latest_price = daily_stats.iloc[-1]['avg_price']
        latest_ma = daily_stats.iloc[-1]['ma_price']
        
        momentum = ((latest_price - latest_ma) / latest_ma) * 100
        
        return {
            'current_avg_price': round(latest_price, 4),
            'moving_average': round(latest_ma, 4),
            'momentum_percentage': round(momentum, 2),
            'signal': 'bullish' if momentum > 5 else 'bearish' if momentum < -5 else 'neutral',
            'daily_data': daily_stats.to_dict('records')
        }
    
    def export_report(self, collection_id: int, filename: str = None):
        """
        분석 리포트 생성 및 저장
        
        Args:
            collection_id: 컬렉션 ID
            filename: 저장할 파일명
        """
        if not filename:
            filename = f"nft_report_{collection_id}_{datetime.now().strftime('%Y%m%d')}.json"
        
        report = {
            'generated_at': datetime.now().isoformat(),
            'collection_id': collection_id,
            'rarity_analysis': self.analyze_rarity_price_correlation(collection_id),
            'holder_distribution': self.get_holder_distribution(collection_id),
            'sale_types': self.analyze_sale_types(collection_id),
            'price_momentum': self.get_price_momentum(collection_id)
        }
        
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(report, f, indent=2, ensure_ascii=False)
        
        print(f"✅ 리포트 저장 완료: {filename}")

from web3 import Web3
from web3.middleware import geth_poa_middleware
import json
import time
from typing import Callable

class NFTEventListener:
    def __init__(self, provider_url: str, contract_address: str, 
                 contract_abi: list):
        """
        NFT 이벤트 리스너 초기화
        
        Args:
            provider_url: Web3 프로바이더 URL
            contract_address: NFT 컨트랙트 주소
            contract_abi: 컨트랙트 ABI
        """
        self.w3 = Web3(Web3.HTTPProvider(provider_url))
        
        # PoA 체인 지원 (Polygon 등)
        self.w3.middleware_onion.inject(geth_poa_middleware, layer=0)
        
        self.contract = self.w3.eth.contract(
            address=Web3.toChecksumAddress(contract_address),
            abi=contract_abi
        )
        
        self.is_listening = False
    
    def listen_transfer_events(self, callback: Callable, 
                               from_block: int = 'latest'):
        """
        Transfer 이벤트 리스닝
        
        Args:
            callback: 이벤트 처리 콜백 함수
            from_block: 시작 블록 번호
        """
        print(f"🎧 Transfer 이벤트 리스닝 시작... (블록: {from_block})")
        
        # 이벤트 필터 생성
        event_filter = self.contract.events.Transfer.create_filter(
            fromBlock=from_block
        )
        
        self.is_listening = True
        
        while self.is_listening:
            try:
                # 새 이벤트 확인
                for event in event_filter.get_new_entries():
                    self._process_transfer_event(event, callback)
                
                # 1초 대기
                time.sleep(1)
                
            except Exception as e:
                print(f"❌ 이벤트 리스닝 오류: {e}")
                time.sleep(5)  # 오류 발생 시 5초 대기
    
    def _process_transfer_event(self, event, callback):
        """Transfer 이벤트 처리"""
        try:
            # 이벤트 데이터 추출
            event_data = {
                'from_address': event['args']['from'],
                'to_address': event['args']['to'],
                'token_id': str(event['args']['tokenId']),
                'transaction_hash': event['transactionHash'].hex(),
                'block_number': event['blockNumber'],
                'timestamp': self._get_block_timestamp(event['blockNumber'])
            }
            
            print(f"📦 Transfer 이벤트 감지:")
            print(f"   Token ID: {event_data['token_id']}")
            print(f"   From: {event_data['from_address'][:10]}...")
            print(f"   To: {event_data['to_address'][:10]}...")
            
            # 콜백 함수 실행
            callback(event_data)
            
        except Exception as e:
            print(f"❌ 이벤트 처리 실패: {e}")
    
    def _get_block_timestamp(self, block_number: int) -> int:
        """블록 타임스탬프 조회"""
        try:
            block = self.w3.eth.get_block(block_number)
            return block['timestamp']
        except Exception as e:
            print(f"❌ 블록 타임스탬프 조회 실패: {e}")
            return int(time.time())
    
    def stop_listening(self):
        """리스닝 중지"""
        self.is_listening = False
        print("🛑 이벤트 리스닝 중지")

class SyncManager:
    def __init__(self, db_manager, nft_service, sales_service):
        """
        동기화 매니저 초기화
        
        Args:
            db_manager: DatabaseManager 인스턴스
            nft_service: NFTService 인스턴스
            sales_service: SalesService 인스턴스
        """
        self.db = db_manager
        self.nft_service = nft_service
        self.sales_service = sales_service
    
    def handle_transfer_event(self, event_data: dict):
        """
        Transfer 이벤트 처리 및 DB 업데이트
        
        Args:
            event_data: 이벤트 데이터
        """
        try:
            # NFT 조회
            nft = self.nft_service.get_nft_by_token(
                collection_id=1,  # 실제로는 컨트랙트 주소로 조회
                token_id=event_data['token_id']
            )
            
            if not nft:
                print(f"⚠️ NFT를 찾을 수 없음: Token ID {event_data['token_id']}")
                return
            
            # 민팅(0x0에서 전송)이 아닌 경우 판매로 간주
            zero_address = '0x0000000000000000000000000000000000000000'
            
            if event_data['from_address'].lower() != zero_address.lower():
                # 트랜잭션 상세 정보 조회
                tx_details = self._get_transaction_details(
                    event_data['transaction_hash']
                )
                
                if tx_details:
                    # 판매 기록
                    self.sales_service.record_sale(
                        nft_item_id=nft['id'],
                        seller_address=event_data['from_address'],
                        buyer_address=event_data['to_address'],
                        price=tx_details['value'],
                        transaction_hash=event_data['transaction_hash'],
                        block_number=event_data['block_number']
                    )
                    
                    print(f"✅ 판매 기록 완료!")
            else:
                # 민팅인 경우 소유자만 업데이트
                self.nft_service.update_nft_owner(
                    nft_id=nft['id'],
                    new_owner=event_data['to_address']
                )
                print(f"✅ 민팅 기록 완료!")
                
        except Exception as e:
            print(f"❌ Transfer 이벤트 처리 실패: {e}")
    
    def _get_transaction_details(self, tx_hash: str) -> dict:
        """트랜잭션 상세 정보 조회"""
        # 실제 구현에서는 Web3를 사용해 트랜잭션 정보 조회
        # 여기서는 예시로 간단히 처리
        return {
            'value': 1.5,  # ETH
            'gas_used': 150000
        }

from flask import Flask, jsonify, request
from flask_cors import CORS
from database.db_manager import DatabaseManager
from services.nft_service import NFTService
from services.sales_service import SalesService
from utils.analytics import NFTAnalytics
import logging

app = Flask(__name__)
CORS(app)  # CORS 활성화

# 로깅 설정
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# 서비스 초기화
db = DatabaseManager('nft_sales.db')
db.connect()
db.create_tables()

nft_service = NFTService(db)
sales_service = SalesService(db)
analytics = NFTAnalytics(db)

# ============= 컬렉션 API =============

@app.route('/api/collections', methods=['POST'])
def create_collection():
    """컬렉션 생성"""
    try:
        data = request.json
        collection_id = nft_service.create_collection(
            name=data['name'],
            contract_address=data['contract_address'],
            description=data.get('description'),
            creator_address=data.get('creator_address'),
            total_supply=data.get('total_supply')
        )
        
        return jsonify({
            'success': True,
            'collection_id': collection_id
        }), 201
        
    except Exception as e:
        logger.error(f"컬렉션 생성 실패: {e}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 400

@app.route('/api/collections/<contract_address>', methods=['GET'])
def get_collection(contract_address):
    """컬렉션 조회"""
    try:
        collection = nft_service.get_collection_by_address(contract_address)
        
        if collection:
            return jsonify({
                'success': True,
                'data': collection
            })
        else:
            return jsonify({
                'success': False,
                'error': '컬렉션을 찾을 수 없습니다'
            }), 404
            
    except Exception as e:
        logger.error(f"컬렉션 조회 실패: {e}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 400

@app.route('/api/collections/<int:collection_id>/stats', methods=['GET'])
def get_collection_stats(collection_id):
    """컬렉션 통계"""
    try:
        stats = nft_service.get_collection_stats(collection_id)
        
        return jsonify({
            'success': True,
            'data': stats
        })
        
    except Exception as e:
        logger.error(f"통계 조회 실패: {e}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 400

# ============= NFT API =============

@app.route('/api/nfts', methods=['POST'])
def create_nft():
    """NFT 생성"""
    try:
        data = request.json
        nft_id = nft_service.add_nft_item(
            collection_id=data['collection_id'],
            token_id=data['token_id'],
            name=data.get('name'),
            description=data.get('description'),
            metadata_uri=data.get('metadata_uri'),
            image_uri=data.get('image_uri'),
            current_owner=data.get('current_owner'),
            rarity_score=data.get('rarity_score'),
            attributes=data.get('attributes')
        )
        
        return jsonify({
            'success': True,
            'nft_id': nft_id
        }), 201
        
    except Exception as e:
        logger.error(f"NFT 생성 실패: {e}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 400

@app.route('/api/nfts/<int:collection_id>/<token_id>', methods=['GET'])
def get_nft(collection_id, token_id):
    """NFT 조회"""
    try:
        nft = nft_service.get_nft_by_token(collection_id, token_id)
        
        if nft:
            return jsonify({
                'success': True,
                'data': nft
            })
        else:
            return jsonify({
                'success': False,
                'error': 'NFT를 찾을 수 없습니다'
            }), 404
            
    except Exception as e:
        logger.error(f"NFT 조회 실패: {e}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 400

@app.route('/api/nfts/search', methods=['GET'])
def search_nfts():
    """NFT 검색"""
    try:
        collection_id = request.args.get('collection_id', type=int)
        owner = request.args.get('owner')
        min_rarity = request.args.get('min_rarity', type=float)
        max_rarity = request.args.get('max_rarity', type=float)
        limit = request.args.get('limit', default=100, type=int)
        
        nfts = nft_service.search_nfts(
            collection_id=collection_id,
            owner=owner,
            min_rarity=min_rarity,
            max_rarity=max_rarity,
            limit=limit
        )
        
        return jsonify({
            'success': True,
            'data': nfts,
            'count': len(nfts)
        })
        
    except Exception as e:
        logger.error(f"NFT 검색 실패: {e}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 400

# ============= 판매 API =============

@app.route('/api/sales', methods=['POST'])
def record_sale():
    """판매 기록"""
    try:
        data = request.json
        sale_id = sales_service.record_sale(
            nft_item_id=data['nft_item_id'],
            seller_address=data['seller_address'],
            buyer_address=data['buyer_address'],
            price=data['price'],
            currency=data.get('currency', 'ETH'),
            platform_fee=data.get('platform_fee', 0),
            royalty_fee=data.get('royalty_fee', 0),
            transaction_hash=data.get('transaction_hash'),
            block_number=data.get('block_number'),
            sale_type=data.get('sale_type', 'direct')
        )
        
        return jsonify({
            'success': True,
            'sale_id': sale_id
        }), 201
        
    except Exception as e:
        logger.error(f"판매 기록 실패: {e}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 400

@app.route('/api/sales/nft/<int:nft_id>', methods=['GET'])
def get_nft_sales_history(nft_id):
    """NFT 판매 이력"""
    try:
        history = sales_service.get_nft_sales_history(nft_id)
        
        return jsonify({
            'success': True,
            'data': history,
            'count': len(history)
        })
        
    except Exception as e:
        logger.error(f"판매 이력 조회 실패: {e}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 400

@app.route('/api/sales/user/<wallet_address>', methods=['GET'])
def get_user_sales(wallet_address):
    """사용자 거래 이력"""
    try:
        as_seller = request.args.get('as_seller', default='true').lower() == 'true'
        
        sales = sales_service.get_user_sales(wallet_address, as_seller)
        
        return jsonify({
            'success': True,
            'data': sales,
            'count': len(sales)
        })
        
    except Exception as e:
        logger.error(f"사용자 거래 이력 조회 실패: {e}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 400

@app.route('/api/sales/top', methods=['GET'])
def get_top_sales():
    """최고 판매 거래"""
    try:
        limit = request.args.get('limit', default=10, type=int)
        days = request.args.get('days', default=7, type=int)
        
        top_sales = sales_service.get_top_sales(limit, days)
        
        return jsonify({
            'success': True,
            'data': top_sales,
            'count': len(top_sales)
        })
        
    except Exception as e:
        logger.error(f"최고 판매 조회 실패: {e}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 400

# ============= 분석 API =============

@app.route('/api/analytics/collection/<int:collection_id>/sales', methods=['GET'])
def get_sales_analytics(collection_id):
    """판매 분석"""
    try:
        days = request.args.get('days', default=30, type=int)
        
        stats = sales_service.get_collection_sales_stats(collection_id, days)
        
        return jsonify({
            'success': True,
            'data': stats
        })
        
    except Exception as e:
        logger.error(f"판매 분석 실패: {e}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 400

@app.route('/api/analytics/collection/<int:collection_id>/holders', methods=['GET'])
def get_holder_analytics(collection_id):
    """소유자 분석"""
    try:
        distribution = analytics.get_holder_distribution(collection_id)
        
        return jsonify({
            'success': True,
            'data': distribution
        })
        
    except Exception as e:
        logger.error(f"소유자 분석 실패: {e}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 400

@app.route('/api/analytics/collection/<int:collection_id>/rarity', methods=['GET'])
def get_rarity_analytics(collection_id):
    """희귀도 분석"""
    try:
        analysis = analytics.analyze_rarity_price_correlation(collection_id)
        
        return jsonify({
            'success': True,
            'data': analysis
        })
        
    except Exception as e:
        logger.error(f"희귀도 분석 실패: {e}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 400

# ============= 헬스 체크 =============

@app.route('/api/health', methods=['GET'])
def health_check():
    """헬스 체크"""
    return jsonify({
        'status': 'healthy',
        'service': 'NFT Sales Manager API',
        'version': '1.0.0'
    })

# ============= 에러 핸들러 =============

@app.errorhandler(404)
def not_found(error):
    return jsonify({
        'success': False,
        'error': '요청한 리소스를 찾을 수 없습니다'
    }), 404

@app.errorhandler(500)
def internal_error(error):
    logger.error(f"서버 오류: {error}")
    return jsonify({
        'success': False,
        'error': '서버 내부 오류가 발생했습니다'
    }), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8000, debug=True)

import requests

# API 베이스 URL
BASE_URL = 'http://localhost:8000/api'

# 1. 컬렉션 생성
response = requests.post(f'{BASE_URL}/collections', json={
    'name': 'CoolNFTs',
    'contract_address': '0x1234567890abcdef',
    'description': '멋진 NFT 컬렉션',
    'total_supply': 10000
})
print(response.json())

# 2. NFT 검색
response = requests.get(f'{BASE_URL}/nfts/search', params={
    'collection_id': 1,
    'min_rarity': 80,
    'limit': 10
})
print(response.json())

# 3. 판매 통계 조회
response = requests.get(f'{BASE_URL}/analytics/collection/1/sales', params={
    'days': 30
})
print(response.json())

# 4. 최고 판매 조회
response = requests.get(f'{BASE_URL}/sales/top', params={
    'limit': 5,
    'days': 7
})
print(response.json())