from flask import Blueprint, request, jsonify, Response
from flask_cors import cross_origin
import requests
import os
from dotenv import load_dotenv
import logging
from urllib.parse import unquote
from src.models.db import db
from src.models.gif_feedback import GifFeedback, GifUsage
from datetime import datetime
import uuid
from urllib.parse import quote

# .env 로드
load_dotenv(os.path.join(os.path.dirname(__file__), '..', '.env'))

gif_bp = Blueprint('gif', __name__)

# Tenor API 설정
TENOR_API_KEY = os.getenv("TENOR_API_KEY")
TENOR_BASE_URL = "https://tenor.googleapis.com/v2"

logger = logging.getLogger(__name__)

# 이 라우트를 제거하거나 주석 처리
@gif_bp.route('/api/gif/proxy/<path:image_url>')
@cross_origin()
def proxy_image(image_url):
    """이미지 프록시 - CORS 문제 해결을 위해 서버를 통해 이미지 제공"""
    try:
        # URL 디코딩
        decoded_url = image_url
        logger.info(f"프록시 요청: {decoded_url}")
        
        # 이미지 요청
        response = requests.get(decoded_url, stream=True, timeout=10)
        response.raise_for_status()
        
        # 응답 헤더 설정
        headers = {
            'Content-Type': response.headers.get('Content-Type', 'image/gif'),
            'Cache-Control': 'public, max-age=3600',
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Methods': 'GET',
            'Access-Control-Allow-Headers': 'Content-Type'
        }
        
        return Response(
            response.content,
            status=200,
            headers=headers
        )
        
    except Exception as e:
        logger.error(f"이미지 프록시 오류: {str(e)}")
        return jsonify({"error": "이미지를 가져올 수 없습니다."}), 500

@gif_bp.route('/api/gif/search', methods=['GET'])
def search_gifs():
    """Tenor API를 사용하여 GIF 검색"""
    try:
        # API 키 확인
        if not TENOR_API_KEY:
            return jsonify({
                "error": "Tenor API 키가 설정되지 않았습니다.",
                "gifs": []
            }), 500
        
        # 요청 파라미터
        query = request.args.get('q', '')
        limit = int(request.args.get('limit', 20))
        pos = int(request.args.get('pos', 0))
        
        # Tenor API 호출
        params = {
            'key': TENOR_API_KEY,
            'q': query,
            'limit': limit,
            'pos': pos,
            'media_filter': 'gif',
            'contentfilter': 'high',
            'ar_range': 'all'
        }
        
        response = requests.get(f"{TENOR_BASE_URL}/search", params=params)
        response.raise_for_status()
        
        data = response.json()
            
        #     gifs.append(gif_data)
        gifs = [build_gif_data(item) for item in data.get('results', [])]
        
        return jsonify({
            "gifs": gifs,
            "next": data.get('next', 0)
        })
        
    except Exception as e:
        logger.error(f"GIF 검색 실패: {str(e)}")
        return jsonify({
            "error": "GIF 검색에 실패했습니다.",
            "gifs": []
        }), 500

@gif_bp.route('/api/gif/trending', methods=['GET'])
@cross_origin()
def get_trending_gifs():
    """인기 GIF 가져오기"""
    try:
        if not TENOR_API_KEY:
            return jsonify({
                "error": "Tenor API 키가 설정되지 않았습니다.",
                "gifs": []
            }), 500
        
        limit = request.args.get('limit', 20)
        popular_keywords = ['funny', 'reaction', 'celebration', 'happy', 'excited', 'love', 'wow', 'cool']
        
        params = {
            'key': TENOR_API_KEY,
            'q': popular_keywords[0],
            'limit': min(int(limit), 50),
            'media_filter': 'gif',
            'contentfilter': 'high',
            'ar_range': 'all'
        }
        
        response = requests.get(f"{TENOR_BASE_URL}/search", params=params, timeout=10)
        response.raise_for_status()
        
        data = response.json()
        
        gifs = [build_gif_data(item) for item in data.get('results', [])]
        
        return jsonify({
            'gifs': gifs,
            'next': data.get('next', 0)
        }), 200
        
    except Exception as e:
        logger.error(f"인기 GIF 가져오기 실패: {e}")
        return jsonify({
            "error": "인기 GIF를 가져오는 중 오류가 발생했습니다.",
            "gifs": []
        }), 500

@gif_bp.route('/api/gif/random', methods=['GET'])
def get_random_gifs():
    """랜덤 GIF 가져오기"""
    try:
        # API 키 확인
        if not TENOR_API_KEY:
            return jsonify({
                "error": "Tenor API 키가 설정되지 않았습니다.",
                "gifs": []
            }), 500
        
        # 요청 파라미터
        limit = int(request.args.get('limit', 20))
        
        # Tenor API 호출 (빈 검색어로 랜덤 결과)
        params = {
            'key': TENOR_API_KEY,
            'q': 'funny',  # 기본 키워드 사용
            'limit': limit,
            'media_filter': 'gif',
            'contentfilter': 'high',
            'ar_range': 'all'
        }
        
        response = requests.get(f"{TENOR_BASE_URL}/search", params=params)
        response.raise_for_status()
        
        data = response.json()
            
        #     gifs.append(gif_data)
        gifs = [build_gif_data(item) for item in data.get('results', [])]
        return jsonify({
            "gifs": gifs,
            "next": data.get('next', 0)
        })
        
    except Exception as e:
        logger.error(f"랜덤 GIF 가져오기 실패: {str(e)}")
        return jsonify({
            "error": "랜덤 GIF를 가져올 수 없습니다.",
            "gifs": []
        }), 500

@gif_bp.route('/api/gif/categories', methods=['GET'])
@cross_origin()
def get_gif_categories():
    """GIF 카테고리 가져오기"""
    try:
        if not TENOR_API_KEY:
            return jsonify({
                "error": "Tenor API 키가 설정되지 않았습니다.",
                "categories": []
            }), 500
        
        categories = [
            {'name': 'Funny', 'searchterm': 'funny', 'image': '', 'path': 'funny'},
            {'name': 'Reaction', 'searchterm': 'reaction', 'image': '', 'path': 'reaction'},
            {'name': 'Celebration', 'searchterm': 'celebration', 'image': '', 'path': 'celebration'},
            {'name': 'Happy', 'searchterm': 'happy', 'image': '', 'path': 'happy'},
            {'name': 'Love', 'searchterm': 'love', 'image': '', 'path': 'love'},
            {'name': 'Cool', 'searchterm': 'cool', 'image': '', 'path': 'cool'},
            {'name': 'Excited', 'searchterm': 'excited', 'image': '', 'path': 'excited'},
            {'name': 'Wow', 'searchterm': 'wow', 'image': '', 'path': 'wow'}
        ]
        
        return jsonify({'categories': categories}), 200
        
    except Exception as e:
        logger.error(f"GIF 카테고리 가져오기 실패: {e}")
        return jsonify({
            "error": "GIF 카테고리를 가져오는 중 오류가 발생했습니다.",
            "categories": []
        }), 500

@gif_bp.route('/api/gif/featured', methods=['GET'])
@cross_origin()
def get_featured_gifs():
    """추천 GIF 가져오기"""
    try:
        if not TENOR_API_KEY:
            return jsonify({
                "error": "Tenor API 키가 설정되지 않았습니다.",
                "gifs": []
            }), 500
        
        limit = request.args.get('limit', 20)
        
        params = {
            'key': TENOR_API_KEY,
            'q': 'trending',
            'limit': min(int(limit), 50),
            'media_filter': 'gif',
            'contentfilter': 'high',
            'ar_range': 'all'
        }
        
        response = requests.get(f"{TENOR_BASE_URL}/search", params=params, timeout=10)
        response.raise_for_status()
        
        data = response.json()

        gifs = [build_gif_data(item) for item in data.get('results', [])]
        
        return jsonify({
            'gifs': gifs,
            'next': data.get('next', 0)
        }), 200
        
    except Exception as e:
        logger.error(f"추천 GIF 가져오기 실패: {e}")
        return jsonify({
            "error": "추천 GIF를 가져오는 중 오류가 발생했습니다.",
            "gifs": []
        }), 500 

@gif_bp.route('/api/gif/feedback', methods=['POST'])
@cross_origin()
def submit_gif_feedback():
    """GIF 피드백 제출"""
    try:
        data = request.get_json()
        
        # 필수 필드 검증
        required_fields = ['gif_id', 'gif_url', 'feedback_type']
        for field in required_fields:
            if field not in data:
                return jsonify({"error": f"필수 필드가 누락되었습니다: {field}"}), 400
        
        # 피드백 타입 검증
        valid_feedback_types = ['like', 'dislike', 'funny', 'useful', 'inappropriate']
        if data['feedback_type'] not in valid_feedback_types:
            return jsonify({"error": "유효하지 않은 피드백 타입입니다."}), 400
        
        # 평점 검증 (있는 경우)
        if 'rating' in data and data['rating'] is not None:
            if not isinstance(data['rating'], int) or data['rating'] < 1 or data['rating'] > 5:
                return jsonify({"error": "평점은 1-5 사이의 정수여야 합니다."}), 400
        
        # 세션 ID 생성 (없는 경우)
        session_id = data.get('session_id')
        if not session_id:
            session_id = str(uuid.uuid4())
        
        # 피드백 생성
        feedback = GifFeedback(
            gif_id=data['gif_id'],
            gif_title=data.get('gif_title', ''),
            gif_url=data['gif_url'],
            user_id=data.get('user_id'),
            session_id=session_id,
            feedback_type=data['feedback_type'],
            rating=data.get('rating'),
            comment=data.get('comment', '')
        )
        
        db.session.add(feedback)
        db.session.commit()
        
        return jsonify({
            "message": "피드백이 성공적으로 제출되었습니다.",
            "feedback_id": feedback.id,
            "session_id": session_id
        }), 201
        
    except Exception as e:
        db.session.rollback()
        logger.error(f"GIF 피드백 제출 실패: {str(e)}")
        return jsonify({"error": "피드백 제출에 실패했습니다."}), 500

@gif_bp.route('/api/gif/feedback/<gif_id>', methods=['GET'])
@cross_origin()
def get_gif_feedback(gif_id):
    """특정 GIF의 피드백 조회"""
    try:
        # 피드백 통계 조회
        feedback_stats = db.session.query(
            GifFeedback.feedback_type,
            db.func.count(GifFeedback.id).label('count')
        ).filter(
            GifFeedback.gif_id == gif_id
        ).group_by(GifFeedback.feedback_type).all()
        
        # 평점 통계 조회
        rating_stats = db.session.query(
            db.func.avg(GifFeedback.rating).label('average_rating'),
            db.func.count(GifFeedback.rating).label('rating_count')
        ).filter(
            GifFeedback.gif_id == gif_id,
            GifFeedback.rating.isnot(None)
        ).first()
        
        # 최근 피드백 조회 (최대 10개)
        recent_feedbacks = GifFeedback.query.filter(
            GifFeedback.gif_id == gif_id
        ).order_by(GifFeedback.created_at.desc()).limit(10).all()
        
        # 통계 데이터 구성
        stats = {
            'total_feedbacks': sum(stat.count for stat in feedback_stats),
            'feedback_breakdown': {stat.feedback_type: stat.count for stat in feedback_stats},
            'average_rating': float(rating_stats.average_rating) if rating_stats.average_rating else None,
            'rating_count': rating_stats.rating_count if rating_stats.rating_count else 0,
            'recent_feedbacks': [feedback.to_dict() for feedback in recent_feedbacks]
        }
        
        return jsonify(stats), 200
        
    except Exception as e:
        logger.error(f"GIF 피드백 조회 실패: {str(e)}")
        return jsonify({"error": "피드백 조회에 실패했습니다."}), 500

@gif_bp.route('/api/gif/usage', methods=['POST'])
@cross_origin()
def track_gif_usage():
    """GIF 사용 추적"""
    try:
        data = request.get_json()
        
        # 필수 필드 검증
        required_fields = ['gif_id', 'gif_url', 'usage_type']
        for field in required_fields:
            if field not in data:
                return jsonify({"error": f"필수 필드가 누락되었습니다: {field}"}), 400
        
        # 사용 타입 검증
        valid_usage_types = ['sent', 'viewed', 'shared']
        if data['usage_type'] not in valid_usage_types:
            return jsonify({"error": "유효하지 않은 사용 타입입니다."}), 400
        
        # 세션 ID 생성 (없는 경우)
        session_id = data.get('session_id')
        if not session_id:
            session_id = str(uuid.uuid4())
        
        # 사용 기록 생성
        usage = GifUsage(
            gif_id=data['gif_id'],
            gif_title=data.get('gif_title', ''),
            gif_url=data['gif_url'],
            user_id=data.get('user_id'),
            session_id=session_id,
            usage_type=data['usage_type'],
            context=data.get('context', 'chat')
        )
        
        db.session.add(usage)
        db.session.commit()
        
        return jsonify({
            "message": "사용 기록이 성공적으로 저장되었습니다.",
            "usage_id": usage.id,
            "session_id": session_id
        }), 201
        
    except Exception as e:
        db.session.rollback()
        logger.error(f"GIF 사용 추적 실패: {str(e)}")
        return jsonify({"error": "사용 추적에 실패했습니다."}), 500

@gif_bp.route('/api/gif/analytics', methods=['GET'])
@cross_origin()
def get_gif_analytics():
    """GIF 분석 데이터 조회"""
    try:
        # 전체 통계
        total_gifs = GifUsage.query.count()
        total_feedbacks = GifFeedback.query.count()
        
        # 인기 GIF (사용량 기준)
        popular_gifs = db.session.query(
            GifUsage.gif_id,
            GifUsage.gif_title,
            db.func.count(GifUsage.id).label('usage_count')
        ).group_by(
            GifUsage.gif_id, GifUsage.gif_title
        ).order_by(
            db.func.count(GifUsage.id).desc()
        ).limit(10).all()
        
        # 피드백 타입별 통계
        feedback_by_type = db.session.query(
            GifFeedback.feedback_type,
            db.func.count(GifFeedback.id).label('count')
        ).group_by(GifFeedback.feedback_type).all()
        
        # 일별 사용량 (최근 7일)
        from datetime import datetime, timedelta
        seven_days_ago = datetime.now() - timedelta(days=7)
        
        daily_usage = db.session.query(
            db.func.date(GifUsage.created_at).label('date'),
            db.func.count(GifUsage.id).label('count')
        ).filter(
            GifUsage.created_at >= seven_days_ago
        ).group_by(
            db.func.date(GifUsage.created_at)
        ).all()
        
        analytics = {
            'total_gifs_used': total_gifs,
            'total_feedbacks': total_feedbacks,
            'popular_gifs': [
                {
                    'gif_id': gif.gif_id,
                    'gif_title': gif.gif_title,
                    'usage_count': gif.usage_count
                }
                for gif in popular_gifs
            ],
            'feedback_breakdown': {
                feedback.feedback_type: feedback.count 
                for feedback in feedback_by_type
            },
            'daily_usage': [
                {
                    'date': usage.date.isoformat(),
                    'count': usage.count
                }
                for usage in daily_usage
            ]
        }
        
        return jsonify(analytics), 200
        
    except Exception as e:
        logger.error(f"GIF 분석 데이터 조회 실패: {str(e)}")
        return jsonify({"error": "분석 데이터 조회에 실패했습니다."}), 500 
    
def build_gif_data(item):
    """Tenor 결과에서 GIF 데이터 정리 + 프록시 URL 생성"""
    gif_url = item.get('media_formats', {}).get('gif', {}).get('url', '')
    preview_url = item.get('media_formats', {}).get('tinygif', {}).get('url', '')

    gif_data = {
        'id': item.get('id'),
        'title': item.get('content_description', ''),
        'url': gif_url,  # 원본 URL은 그대로 유지
        'preview_url': preview_url,
        'width': item.get('media_formats', {}).get('gif', {}).get('dims', [0, 0])[0],
        'height': item.get('media_formats', {}).get('gif', {}).get('dims', [0, 0])[1]
    }

    # ✅ proxy_url 생성 시 반드시 경로만 사용
    if gif_url:
        # URL에서 도메인 부분 제거하고 경로만 사용
        if 'media.tenor.com' in gif_url:
            gif_path = gif_url.split('media.tenor.com')[-1]
            gif_data['proxy_url'] = f"/api/gif/proxy{gif_path}"
        else:
            gif_data['proxy_url'] = f"/api/gif/proxy/{gif_url}"

    if preview_url:
        # URL에서 도메인 부분 제거하고 경로만 사용
        if 'media.tenor.com' in preview_url:
            preview_path = preview_url.split('media.tenor.com')[-1]
            gif_data['preview_proxy_url'] = f"/api/gif/proxy{preview_path}"
        else:
            gif_data['preview_proxy_url'] = f"/api/gif/proxy/{preview_url}"

    return gif_data