import google.generativeai as genai

# 텍스트와 이미지를 함께 입력
response = model.generate_content([
    "이 이미지에서 무엇이 보이나요?",
    image_data
])

# 내부적으로는 모두 토큰으로 변환됨
# "이" → token_1
# "이미지에서" → token_2, token_3
# [image_patch_1] → token_4
# [image_patch_2] → token_5
# ...

import google.generativeai as genai
import os
from PIL import Image

# API 키 설정
genai.configure(api_key=os.environ.get('GEMINI_API_KEY'))

# 모델 초기화
model = genai.GenerativeModel('gemini-2.0-pro-vision')

print("Gemini 2.0 준비 완료! 🎉")

def analyze_image(image_path, prompt):
    """
    이미지를 분석하고 설명을 생성하는 함수
    
    Args:
        image_path: 이미지 파일 경로
        prompt: 분석 요청 프롬프트
    
    Returns:
        분석 결과 텍스트
    """
    # 이미지 로드
    image = Image.open(image_path)
    
    # Gemini에게 질문
    response = model.generate_content([
        prompt,
        image
    ])
    
    return response.text

# 사용 예시
result = analyze_image(
    "cat_photo.jpg",
    "이 이미지를 자세히 설명해주세요. 동물의 종류, 색상, 행동, 배경 등을 포함해서요."
)

print(result)
# 출력 예시:
# "이미지에는 주황색과 흰색 털을 가진 고양이가 보입니다. 
# 고양이는 햇빛이 드는 창가에 앉아 있으며, 편안한 자세로 
# 눈을 반쯤 감고 있습니다. 배경에는 커튼과 화분이 보이며..."

import google.generativeai as genai

def analyze_video(video_path, prompt):
    """
    비디오를 분석하고 요약을 생성하는 함수
    
    Args:
        video_path: 비디오 파일 경로
        prompt: 분석 요청 프롬프트
    
    Returns:
        분석 결과 텍스트
    """
    # 비디오 파일 업로드
    video_file = genai.upload_file(path=video_path)
    
    # 업로드 완료 대기
    while video_file.state.name == "PROCESSING":
        time.sleep(2)
        video_file = genai.get_file(video_file.name)
    
    # 비디오 분석
    response = model.generate_content([
        prompt,
        video_file
    ])
    
    return response.text

# 사용 예시
summary = analyze_video(
    "cooking_tutorial.mp4",
    """
    이 요리 튜토리얼 영상을 분석해서 다음 정보를 추출해주세요:
    1. 만드는 음식의 이름
    2. 주요 재료 목록
    3. 조리 단계별 요약
    4. 예상 조리 시간
    5. 난이도 평가
    """
)

print(summary)

def analyze_audio(audio_path, task="transcribe"):
    """
    오디오를 분석하는 함수
    
    Args:
        audio_path: 오디오 파일 경로
        task: 수행할 작업 (transcribe, summarize, sentiment 등)
    
    Returns:
        분석 결과
    """
    audio_file = genai.upload_file(path=audio_path)
    
    prompts = {
        "transcribe": "이 오디오를 정확하게 텍스트로 변환해주세요.",
        "summarize": "이 오디오의 주요 내용을 3-5문장으로 요약해주세요.",
        "sentiment": "화자의 감정 상태를 분석해주세요. (긍정/부정/중립)",
        "speakers": "여러 화자를 구분하고 각자가 말한 내용을 정리해주세요."
    }
    
    response = model.generate_content([
        prompts.get(task, prompts["transcribe"]),
        audio_file
    ])
    
    return response.text

# 회의 녹음 분석 예시
meeting_summary = analyze_audio(
    "team_meeting.mp3",
    task="summarize"
)

print("회의 요약:", meeting_summary)

# 감정 분석 예시
customer_sentiment = analyze_audio(
    "customer_call.mp3",
    task="sentiment"
)

print("고객 감정:", customer_sentiment)

def analyze_multimodal_content(text, image_path=None, video_path=None, audio_path=None):
    """
    여러 형태의 콘텐츠를 동시에 분석하는 함수
    
    Args:
        text: 텍스트 설명 또는 질문
        image_path: 이미지 파일 경로 (선택)
        video_path: 비디오 파일 경로 (선택)
        audio_path: 오디오 파일 경로 (선택)
    
    Returns:
        통합 분석 결과
    """
    content_parts = [text]
    
    # 이미지 추가
    if image_path:
        image = Image.open(image_path)
        content_parts.append(image)
    
    # 비디오 추가
    if video_path:
        video_file = genai.upload_file(path=video_path)
        content_parts.append(video_file)
    
    # 오디오 추가
    if audio_path:
        audio_file = genai.upload_file(path=audio_path)
        content_parts.append(audio_file)
    
    # 통합 분석
    response = model.generate_content(content_parts)
    
    return response.text

# 실전 예시: 제품 리뷰 분석
review_analysis = analyze_multimodal_content(
    text="""
    이 제품 리뷰를 종합적으로 분석해주세요:
    1. 이미지에서 제품의 상태 평가
    2. 비디오에서 사용 방법 및 성능 확인
    3. 오디오 리뷰에서 고객의 만족도 파악
    4. 전체적인 평가 및 개선점 제안
    """,
    image_path="product_photo.jpg",
    video_path="product_demo.mp4",
    audio_path="customer_review.mp3"
)

print(review_analysis)

def medical_image_analysis(image_path, patient_history):
    """
    의료 영상을 분석하고 소견을 제공하는 함수
    """
    image = Image.open(image_path)
    
    prompt = f"""
    다음 의료 영상을 분석해주세요:
    
    환자 정보:
    {patient_history}
    
    분석 항목:
    1. 이상 소견 유무
    2. 이상 소견의 위치 및 크기
    3. 심각도 평가 (경증/중등도/중증)
    4. 추가 검사 필요 여부
    5. 유사 케이스 참고 사항
    
    ⚠️ 주의: 이는 보조 도구이며, 최종 진단은 전문의가 해야 합니다.
    """
    
    response = model.generate_content([prompt, image])
    return response.text

# 사용 예시
result = medical_image_analysis(
    "chest_xray.jpg",
    "60세 남성, 흡연력 30년, 기침 증상 2주 지속"
)

print(result)

def smart_product_registration(product_images, product_video=None):
    """
    상품 이미지와 영상으로 자동으로 상품 정보를 생성
    """
    content = [
        """
        이 상품의 정보를 다음 형식으로 생성해주세요:
        
        1. 상품명 (SEO 최적화된)
        2. 카테고리 (대/중/소 분류)
        3. 상세 설명 (500자 이상)
        4. 주요 특징 (5개)
        5. 추천 타겟 고객
        6. 예상 가격대
        7. 관련 키워드 (10개)
        8. 상품 태그
        """
    ]
    
    # 여러 각도의 상품 이미지 추가
    for img_path in product_images:
        content.append(Image.open(img_path))
    
    # 상품 소개 영상이 있으면 추가
    if product_video:
        video_file = genai.upload_file(path=product_video)
        content.append(video_file)
    
    response = model.generate_content(content)
    return response.text

# 실제 사용
product_info = smart_product_registration(
    product_images=["product_front.jpg", "product_side.jpg", "product_detail.jpg"],
    product_video="product_demo.mp4"
)

print(product_info)

def create_learning_assistant(lecture_video, textbook_images, student_question):
    """
    강의 영상과 교재를 분석해서 학생 질문에 답변
    """
    content = [
        f"""
        학생 질문: {student_question}
        
        다음 자료를 참고해서 답변해주세요:
        - 강의 영상의 관련 부분 인용
        - 교재의 해당 페이지 참조
        - 추가 설명 및 예시 제공
        - 연습 문제 추천
        
        답변은 학생이 이해하기 쉽게 단계별로 설명해주세요.
        """
    ]
    
    # 강의 영상 추가
    video_file = genai.upload_file(path=lecture_video)
    content.append(video_file)
    
    # 교재 이미지들 추가
    for img_path in textbook_images:
        content.append(Image.open(img_path))
    
    response = model.generate_content(content)
    return response.text

# 사용 예시
answer = create_learning_assistant(
    lecture_video="math_lecture_chapter3.mp4",
    textbook_images=["textbook_p45.jpg", "textbook_p46.jpg"],
    student_question="이차방정식의 근의 공식은 어떻게 유도되나요?"
)

print(answer)

def video_editing_assistant(raw_footage_paths, editing_style):
    """
    원본 영상들을 분석해서 편집 가이드 제공
    """
    content = [
        f"""
        다음 원본 영상들을 분석해서 {editing_style} 스타일의 
        편집 가이드를 만들어주세요:
        
        1. 하이라이트 장면 타임스탬프
        2. 컷 편집 포인트 추천
        3. 장면 전환 효과 제안
        4. BGM 분위기 추천
        5. 자막 삽입 위치
        6. 색보정 방향성
        7. 최종 러닝타임 제안
        """
    ]
    
    # 여러 원본 영상 추가
    for video_path in raw_footage_paths:
        video_file = genai.upload_file(path=video_path)
        content.append(video_file)
    
    response = model.generate_content(content)
    return response.text

# 브이로그 편집 예시
editing_guide = video_editing_assistant(
    raw_footage_paths=[
        "morning_routine.mp4",
        "cafe_visit.mp4",
        "shopping.mp4",
        "dinner.mp4"
    ],
    editing_style="감성적이고 따뜻한 일상 브이로그"
)

print(editing_guide)

def stream_response(prompt, image=None):
    """
    응답을 스트리밍으로 받아서 즉시 표시
    """
    content = [prompt]
    if image:
        content.append(image)
    
    response = model.generate_content(
        content,
        stream=True  # 스트리밍 활성화
    )
    
    # 응답이 생성되는 대로 출력
    for chunk in response:
        print(chunk.text, end='', flush=True)
    print()  # 줄바꿈

# 사용자는 전체 응답을 기다리지 않고 
# 생성되는 즉시 읽을 수 있어!

from PIL import Image

def optimize_image(image_path, max_size=(1024, 1024)):
    """
    이미지를 적절한 크기로 리사이즈
    """
    img = Image.open(image_path)
    
    # 비율 유지하면서 리사이즈
    img.thumbnail(max_size, Image.Resampling.LANCZOS)
    
    # 임시 파일로 저장
    optimized_path = "temp_optimized.jpg"
    img.save(optimized_path, "JPEG", quality=85, optimize=True)
    
    return optimized_path

# 원본 10MB 이미지를 500KB로 줄여서 전송!
# 속도는 빨라지고 API 비용은 절약!

import asyncio

async def process_multiple_images(image_paths, prompt):
    """
    여러 이미지를 동시에 처리
    """
    tasks = []
    
    for img_path in image_paths:
        task = asyncio.create_task(
            analyze_image_async(img_path, prompt)
        )
        tasks.append(task)
    
    # 모든 작업을 동시에 실행
    results = await asyncio.gather(*tasks)
    return results

# 10개 이미지를 순차 처리: 100초
# 10개 이미지를 병렬 처리: 15초!

import hashlib
import json
from functools import lru_cache

class GeminiCache:
    """
    API 응답을 캐싱해서 중복 요청 방지
    """
    def __init__(self):
        self.cache = {}
    
    def get_cache_key(self, prompt, image_path=None):
        """
        프롬프트와 이미지로 고유 키 생성
        """
        key_data = prompt
        
        if image_path:
            # 이미지 파일의 해시값 추가
            with open(image_path, 'rb') as f:
                img_hash = hashlib.md5(f.read()).hexdigest()
            key_data += img_hash
        
        return hashlib.md5(key_data.encode()).hexdigest()
    
    def get(self, prompt, image_path=None):
        """
        캐시에서 결과 가져오기
        """
        key = self.get_cache_key(prompt, image_path)
        return self.cache.get(key)
    
    def set(self, prompt, result, image_path=None):
        """
        결과를 캐시에 저장
        """
        key = self.get_cache_key(prompt, image_path)
        self.cache[key] = result

# 사용 예시
cache = GeminiCache()

def analyze_with_cache(prompt, image_path=None):
    # 캐시 확인
    cached_result = cache.get(prompt, image_path)
    if cached_result:
        print("💾 캐시에서 결과 반환! (API 호출 0원)")
        return cached_result
    
    # 캐시 없으면 API 호출
    print("🌐 API 호출 중...")
    result = analyze_image(image_path, prompt)
    
    # 결과 캐싱
    cache.set(prompt, result, image_path)
    return result

# 같은 이미지에 같은 질문을 하면 캐시 사용!
# 비용 절감 + 속도 향상 일석이조!

import time
from google.api_core import exceptions

def robust_api_call(func, max_retries=3, *args, **kwargs):
    """
    재시도 로직이 포함된 안전한 API 호출
    """
    for attempt in range(max_retries):
        try:
            result = func(*args, **kwargs)
            return result
            
        except exceptions.ResourceExhausted:
            # 할당량 초과
            print(f"⚠️ API 할당량 초과. {60}초 대기 중...")
            time.sleep(60)
            
        except exceptions.DeadlineExceeded:
            # 타임아웃
            print(f"⏱️ 타임아웃 발생. 재시도 {attempt + 1}/{max_retries}")
            time.sleep(2 ** attempt)  # 지수 백오프
            
        except exceptions.ServiceUnavailable:
            # 서비스 일시 중단
            print(f"🔧 서비스 점검 중. 재시도 {attempt + 1}/{max_retries}")
            time.sleep(5)
            
        except Exception as e:
            # 기타 에러
            print(f"❌ 예상치 못한 에러: {str(e)}")
            if attempt == max_retries - 1:
                raise
            time.sleep(1)
    
    raise Exception("최대 재시도 횟수 초과")

# 사용 예시
try:
    result = robust_api_call(
        analyze_image,
        max_retries=3,
        image_path="photo.jpg",
        prompt="이미지 설명해줘"
    )
    print(result)
except Exception as e:
    print(f"최종 실패: {e}")
    # 폴백 로직 실행
    result = "이미지 분석에 실패했습니다."