info_blog.py

import os
import random
import re
import requests
import logging
from bs4 import BeautifulSoup
import html
import markdown2
from dotenv import load_dotenv  # 추가된 부분

# 환경 변수 로드
load_dotenv()  # 추가된 부분

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

# 상수 정의
TARGET_CHAR_LENGTH = 4000      # 정보성 블로그 최소 글자수
MIN_SECTION_LENGTH = 600       # 각 소제목 아래 최소 글자수
MAX_TOKENS = 15000             # Gemini API 최대 토큰 수
TEMPERATURE = 0.85             # Gemini API 온도 값
TOP_P = 0.9                    # Gemini API top_p 값

# API 관련 설정
API_BASE_URL = os.getenv("API_BASE_URL", "").rstrip('/')
API_KEY = os.getenv("API_KEY", "")

API_HEADERS = {
    "x-api-key": API_KEY,
    "content-type": "application/json"
}

# API 키 설정
def load_gemini_api_keys():
    # 여러 개의 API 키 로드
    api_keys = [
        os.getenv("GEMINI_API_KEY_1", ""),
        os.getenv("GEMINI_API_KEY_2", ""),
        os.getenv("GEMINI_API_KEY_3", ""),
        os.getenv("GEMINI_API_KEY_4", ""),
        os.getenv("GEMINI_API_KEY_5", "")
    ]
    
    # 빈 키 제거
    api_keys = [key for key in api_keys if key]
    
    # 기본 키가 없으면 GEMINI_API_KEY 환경변수 사용
    if not api_keys:
        default_key = os.getenv("GEMINI_API_KEY")
        if default_key:
            api_keys.append(default_key)
    
    if not api_keys:
        raise ValueError("API 키가 설정되지 않았습니다. .env 파일에 GEMINI_API_KEY 또는 GEMINI_API_KEY_1~5를 추가하세요.")
    
    logging.info(f"총 {len(api_keys)}개의 API 키가 로드되었습니다.")
    return api_keys

# 매번 랜덤하게 API 키 선택하는 함수
def get_random_gemini_client():
    """랜덤 API 키로 Gemini 클라이언트 초기화 및 반환"""
    from google import genai
    from google.genai import types
    
    api_keys = load_gemini_api_keys()
    if not api_keys:
        raise ValueError("사용 가능한 API 키가 없습니다.")
    
    # 랜덤하게 API 키 인덱스 선택
    random_index = random.randint(0, len(api_keys) - 1)
    selected_key = api_keys[random_index]
    
    logging.info(f"랜덤 API 키 선택: 인덱스 {random_index + 1}")
    
    # Gemini 클라이언트 초기화 및 반환
    return genai.Client(api_key=selected_key)

# --- Google Gemini SDK 초기화 수정 ---
# 기존 코드 주석 처리:
# from google import genai
# from google.genai import types
# client = genai.Client(api_key=gemini_api_key)

# 함수 호출 방식으로 변경
def fetch_references(topic):
    """API를 통해 참고 블로그 글 가져오기"""
    try:
        if not topic or not topic.strip():
            return ["검색 키워드를 입력해주세요."] * 3

        encoded_keyword = requests.utils.quote(topic.strip())
        url = f"{API_BASE_URL}/search/{encoded_keyword}"
        
        logging.info(f"API 호출 URL: {url}")
        logging.info(f"API 헤더: {API_HEADERS}")
        
        response = requests.get(url, headers=API_HEADERS)
        logging.info(f"API 응답 상태: {response.status_code}")
        logging.info(f"API 응답 내용: {response.text}")
        
        if response.ok:
            result = response.json()
            return [
                result.get("reference1", "참고글1을 찾을 수 없습니다."),
                result.get("reference2", "참고글2을 찾을 수 없습니다."),
                result.get("reference3", "참고글3을 찾을 수 없습니다.")
            ]
        else:
            return [f"API 오류: {response.text}"] * 3
            
    except Exception as e:
        return [f"참고글 수집 중 오류 발생: {str(e)}"] * 3

def fetch_crawl_results(query):
    """API를 통해 블로그 검색 결과 가져오기 (참고글 3개)"""
    references = fetch_references(query)
    return references[0], references[1], references[2]

def get_style_prompt(style="친근한"):
    prompts = {
        "친근한": """
[친근한 정보성 블로그 스타일 가이드]
1. 톤과 어조
  - 대화하듯 편안하고 친근한 말투 사용
  - 주제에 대한 관심과 호기심을 담은 표현 사용
2. 문장 및 어투
   - 반드시 '해요체'로 작성, 절대 '습니다'체를 사용하지 말 것
   - '~요'로 끝나도록 작성, '~다'로 끝나지 않게 하라
   - 구어체 표현 사용 (예: "~했어요", "~인 것 같아요")
   - 이모티콘은 사용하지 마세요
3. 용어 및 설명 방식
   - 전문 용어는 쉬운 단어로 풀어서 설명
   - 비유나 은유를 활용하여 복잡한 개념 설명
   - 수사의문문 활용하여 독자와 소통하는 느낌 주기 (예: "여러분도 이런 생각 해보셨나요?")
   - 구체적 사례와 예시를 통한 개념 설명
4. 정보 전달 방식
   - 개인적인 관점에 녹여 자연스럽게 정보 전달
   - 복잡한 개념을 단계적으로 설명
   - 독자가 실제로 활용할 수 있는 실용적 정보 제공
5. 독자와의 상호작용
   - 독자의 의견을 물어보는 질문 포함
   - 실생활에 적용할 수 있는 팁이나 조언 제공
주의사항: 너무 가벼운 톤은 지양하고, 주제의 전문성과 신뢰성을 해치지 않는 선에서 친근함 유지
""",
        "일반적인": """
#일반적인 정보성 블로그 스타일 가이드
1. 톤과 어조
   - 중립적이고 객관적인 톤 유지
   - 적절한 존댓말 사용 (예: "~합니다", "~입니다")
   - 정보 전달 중심의 명확한 어투
2. 내용 구조 및 전개
   - 명확한 주제 소개로 시작
   - 논리적인 순서로 정보 전개 (배경 → 주요 개념 → 분석 → 적용 등)
   - 핵심 포인트를 강조하는 소제목 활용
   - 적절한 길이의 단락으로 구성
3. 용어 및 설명 방식
   - 일반적으로 이해하기 쉬운 용어 선택
   - 필요시 전문 용어에 간단한 설명 추가
   - 객관적인 정보 제공에 중점
   - 균형 잡힌 시각에서 다양한 관점 제시
4. 정보 전달 방식
   - 주제의 기본 개념과 원리 명확하게 제공
   - 구체적인 예시와 사례 포함
   - 시각적 요소(그래프, 표 등) 설명 방식
   - 최신 연구나 동향 참고
5. 독자 상호작용
   - 적절히 독자의 생각을 묻는 질문 포함
   - 추가 정보를 찾을 수 있는 키워드 제시
   - 실용적인 적용 방안 제공
6. 마무리
   - 주요 내용 간단히 요약
   - 주제의 중요성이나 의의 강조
   - 향후 전망이나 추가 고려사항 제시
주의사항: 너무 딱딱하거나 지루하지 않도록 다양한 예시와 객관적 정보 사이의 균형 유지
""",
        "전문적인": """
#전문적인 정보성 블로그 스타일 가이드
1. 톤과 구조
   - 공식적이고 전문적인 톤 사용
   - 객관적이고 분석적인 접근 유지
   - 명확한 서론(개요), 본론(상세 분석), 결론(종합 평가) 구조
   - 체계적인 정보 전개
   - 세부 섹션을 위한 명확한 소제목 사용
2. 내용 구성 및 전개
   - 주제의 역사적 배경, 이론적 기반, 현재 동향 등 심층적 정보 포함
   - 논리적 연결을 위한 전환어 활용
   - 전문 용어 적절히 활용 (필요시 간략한 설명 제공)
   - 심층적인 분석과 비판적 평가 제공
   - 다양한 관점과 이론적 프레임워크 제시
3. 데이터 및 근거 활용
   - 통계, 연구 결과, 사례 연구 등 객관적 데이터 활용
   - 주제 분석을 위한 체계적인 프레임워크 제시
   - 수치 데이터는 명확히 설명 (추세, 상관관계, 인과관계 등)
   - 학술적 근거와 현실 적용의 균형
4. 전문적 정보 제공
   - 최신 연구 동향 및 발전 방향 분석
   - 이론과 실제 적용 사이의 간극 분석
   - 주제 관련 쟁점과 논쟁점 소개
   - 체계적인 문제 해결 접근법 제시
5. 마무리
   - 핵심 정보 요약 및 종합 평가
   - 주제의 학문적, 실용적 의의 분석
   - 향후 연구 방향이나 발전 가능성 제시
주의사항: 전문성을 유지하되, 불필요하게 어려운 용어는 지양하고 명확한 설명 중심으로 구성
"""
    }
    return prompts.get(style, prompts["친근한"])

def get_informational_blog_prompt():
    prompts = [
        """
[중요: 정보성 블로그 글 작성 필수 규칙]
이 규칙을 반드시 따르세요. 어떤 상황에서도 예외는 없습니다:
1. 마크다운 문법(**, *, #, -, 1., 2., 3.)을 절대 사용하지 마세요.
2. 모든 소제목은 번호 없이 일반 문장으로 작성하세요.
3. 모든 목록은 불릿이나 번호 없이 자연스러운 문장으로 서술하세요.
4. "참고글", "참고글에 따르면" 등의 표현을 절대 사용하지 마세요.
5. 주제에 관한 정확하고 신뢰할 수 있는 정보만 작성하세요.
6. 글의 주제는 반드시 주어진 참고글의 내용을 바탕으로 작성하세요.
7. 글의 구성은 다음을 포함해야 합니다:
   - 주제에 대한 명확한 소개와 배경
   - 주제의 역사적/이론적 맥락
   - 현재 동향이나 최신 정보
   - 주요 개념이나 원리에 대한 설명
   - 실용적인 적용 방법이나 사례
   - 다양한 관점이나 비교 분석
   - 향후 전망이나 결론
"""
    ]
    return random.choice(prompts)

def remove_unwanted_phrases(text):
    unwanted_phrases = [
        '여러분', '최근', '마지막으로', '결론적으로', '결국',
        '종합적으로', '따라서', '마무리', '끝으로', '요약',
        '한 줄 요약', '정리하자면', '총정리', '글을 마치며',
        '이상으로', '추천드립니다', '참고하세요', '도움이 되셨길',
        '좋은 하루 되세요', '다음 글에서', '도움이 되었길',
        '즐거운 하루 되세요', '감사합니다'
    ]
    words = re.findall(r'\S+|\n', text)
    result_words = [word for word in words if not any(phrase in word for phrase in unwanted_phrases)]
    return ' '.join(result_words).replace(' \n ', '\n').replace(' \n', '\n').replace('\n ', '\n')

def post_process_blog(blog_content, style="친근한"):
    """생성된 블로그 글의 후처리: 마크다운, 번호/불릿 제거 및 스타일 수정"""
    try:
        # 번호 목록, 불릿, 헤딩 등 제거
        blog_content = re.sub(r'^\d+\.\s+', '', blog_content, flags=re.MULTILINE)
        blog_content = re.sub(r'^[\*\-\•]\s+', '', blog_content, flags=re.MULTILINE)
        blog_content = re.sub(r'^#+\s+', '', blog_content, flags=re.MULTILINE)

        if style == "친근한":
            blog_content = re.sub(r'([가-힣]+)고요', r'\1구요', blog_content)
            blog_content = re.sub(r'답니다', '어요', blog_content)
            blog_content = re.sub(r'였답니다', '였어요', blog_content)
            blog_content = re.sub(r'했답니다', '했어요', blog_content)
            blog_content = re.sub(r'습니다', '요', blog_content)
            blog_content = re.sub(r'합니다', '해요', blog_content)
            blog_content = re.sub(r'됩니다', '돼요', blog_content)
            blog_content = re.sub(r'입니다', '이에요', blog_content)

        # 과장된 표현 정리
        exaggerated_expressions = [
            (r'필수적인', r'중요한'),
            (r'혁명적인', r'중요한'),
            (r'놀라운', r'주목할 만한'),
            (r'기적의', r'효과적인'),
            (r'최고의', r'좋은'),
            (r'세계적인', r'유명한'),
            (r'완벽한', r'우수한'),
            (r'극적인', r'상당한'),
            (r'무한한', r'많은'),
            (r'절대적인', r'상당한'),
            (r'혁신적인', r'새로운'),
            (r'환상적인', r'좋은'),
            (r'근본적인', r'기본적인'),
            (r'획기적인', r'중요한'),
            (r'전례없는', r'특별한'),
            (r'압도적인', r'주목할 만한'),
            (r'황홀한', r'좋은'),
            (r'천상의', r'우수한'),
            (r'기가 막힌', r'효과적인'),
            (r'끝판왕', r'최상위'),
            (r'그 자체', r''),
            (r'이 (.{1,10}) 그 자체였어요', r'이 \1였어요'),
            (r'가 (.{1,10}) 그 자체였어요', r'가 \1였어요'),
            (r'압도적인', r'중요한'),
            (r'천국', r'좋은 곳'),
            (r'황홀했어요', r'좋았어요'),
            (r'환상의', r'좋은')
        ]
            
        for pattern, replacement in exaggerated_expressions:
            blog_content = re.sub(pattern, replacement, blog_content, flags=re.IGNORECASE)
        
        blog_content = re.sub(r'참고글에 따르면', r'알려진 바로는', blog_content)
        blog_content = re.sub(r'참고글', r'관련 정보', blog_content)
        
        # Gemini API를 활용한 추가 후처리 프롬프트 (텍스트 보완 목적)
        prompt = f"""
        다음 정보성 블로그 글을 더 자연스러운 형태로 변경해주세요:
        
        원본 글:
        {blog_content}
        
        변경 요구사항:
        1. 마크다운 형식 및 번호 목록, 불릿 표현 제거
        2. 소제목은 5개 이하로, 각 소제목 아래 내용은 최소 {MIN_SECTION_LENGTH}자 이상으로 상세하게 서술
        3. "참고글" 관련 표현 제거
        4. 구체적인 예시와 실용적인 정보 포함
        5. 스타일: {style} (자연스러운 문체 사용)
        """
        
        # 랜덤 클라이언트 사용으로 변경
        from google.genai import types
        client = get_random_gemini_client()
        
        response = client.models.generate_content(
            model="gemini-2.0-flash",
            contents=[prompt],
            config=types.GenerateContentConfig(
                max_output_tokens=MAX_TOKENS,
                temperature=0.7,
                top_p=0.9
            )
        )
        return response.text.strip()
    except Exception as e:
        logging.error(f"블로그 글 후처리 중 오류 발생: {str(e)}")
        return blog_content

def format_blog_post(blog_post, query=""):
    blog_post = re.sub(r'^#+\s+', '', blog_post, flags=re.MULTILINE)
    blog_post = re.sub(r'^\d+\.\s+', '', blog_post, flags=re.MULTILINE)
    blog_post = re.sub(r'^[\*\-]\s+', '', blog_post, flags=re.MULTILINE)
    
    lines = blog_post.split('\n')
    formatted_lines = []
    in_paragraph = False
    first_line = True
    title_found = False
    first_non_empty_line = ""
    for line in lines:
        if line.strip():
            first_non_empty_line = line.strip()
            break
    
    subtitle_patterns = [
        r'^.{10,100}\?$',
        r'^.{10,100}:$',
        r'^.{5,50}의 [가-힣\s]+$',
        r'^[가-힣\s]{5,50} [가-힣\s]+$'
    ]
    
    previous_line_empty = True
    
    def optimize_title(title, max_length=60):
        if ': ' in title and len(title) > max_length:
            title = title.split(': ')[0]
        if len(title) > max_length:
            title = re.sub(r'\s*\([^)]*\)', '', title)
        if len(title) > max_length and ',' in title:
            title = title.split(',')[0]
        if len(title) > max_length:
            words = title.split()
            shortened_title = []
            current_length = 0
            for word in words:
                if current_length + len(word) + 1 <= max_length:
                    shortened_title.append(word)
                    current_length += len(word) + 1
                else:
                    break
            title = ' '.join(shortened_title)
            endings_to_remove = ['그', '이', '은', '는', '이나', '와', '과', '또는', '그리고']
            for ending in endings_to_remove:
                if title.endswith(f" {ending}"):
                    title = title[:-len(ending)-1]
            if len(title) < 20 and query:
                title = f"{query} 정보 가이드"
        return title
    
    for i, line in enumerate(lines):
        line = line.strip()
        next_line_empty = (i+1 >= len(lines)) or not lines[i+1].strip()
        
        if not line:
            if in_paragraph:
                formatted_lines.append("</p>")
                in_paragraph = False
            formatted_lines.append("<br>")
            previous_line_empty = True
        else:
            if first_line and len(line) > 5:
                optimized_title = optimize_title(line)
                formatted_lines.append(f'<h1 style="font-size: 1.8em; margin-bottom: 20px; font-weight: bold; color: #222;">{html.escape(optimized_title)}</h1>')
                first_line = False
                title_found = True
                previous_line_empty = False
            else:
                is_subtitle = False
                if any(re.match(pattern, line) for pattern in subtitle_patterns):
                    is_subtitle = True
                elif previous_line_empty and next_line_empty and len(line) < 80:
                    is_subtitle = True
                if is_subtitle:
                    if in_paragraph:
                        formatted_lines.append("</p>")
                        in_paragraph = False
                    formatted_lines.append(f'<h2 style="font-size: 1.3em; margin-top: 25px; margin-bottom: 15px; font-weight: bold; color: #333;">{html.escape(line)}</h2>')
                else:
                    if not in_paragraph:
                        formatted_lines.append("<p>")
                        in_paragraph = True
                    content = html.escape(line)
                    bold_content = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', content)
                    formatted_lines.append(bold_content)
                previous_line_empty = False
    if in_paragraph:
        formatted_lines.append("</p>")
    if not title_found:
        default_title = f"{query} 정보 가이드" if query else "정보성 블로그"
        if first_non_empty_line:
            default_title = optimize_title(first_non_empty_line)
        formatted_lines.insert(0, f'<h1 style="font-size: 1.8em; margin-bottom: 20px; font-weight: bold; color: #222;">{html.escape(default_title)}</h1>')
    return '\n'.join(formatted_lines)

# Gemini API 호출 헬퍼 함수 (프롬프트 중복 제거)
def call_gemini_api(prompt):
    # 매번 새로운 랜덤 클라이언트 가져오기
    from google.genai import types
    client = get_random_gemini_client()
    
    response = client.models.generate_content(
        model="gemini-2.0-flash",
        contents=[prompt],
        config=types.GenerateContentConfig(
            max_output_tokens=MAX_TOKENS,
            temperature=TEMPERATURE,
            top_p=TOP_P
        )
    )
    return response.text.strip()

def generate_blog_post(query, style="친근한"):
    try:
        # 참고글 수집
        ref1, ref2, ref3 = fetch_crawl_results(query)
        style_prompt = get_style_prompt(style)
        format_prompt = get_informational_blog_prompt()
        
        # 스타일 세부 지시사항 (원본 내용의 특성을 유지)
        style_specific_instructions = ""
        if style == "친근한":
            style_specific_instructions = """
            이 블로그는 반드시 친근한 대화체로 작성해야 합니다.
            - '해요체' 사용: "~했어요", "~인 것 같아요", "~하네요"
            - 격식체(예: "~합니다", "~입니다") 사용 금지
            - 대화하듯 편안하게 작성
            - 짧고 간결한 문장 사용
            - 복잡한 개념은 일상적인 비유로 설명
            - 실제 사례와 예시를 통한 설명
            - 수사의문문을 활용한 독자와의 소통
            """
        elif style == "일반적인":
            style_specific_instructions = """
            이 블로그는 반드시 일반적인 존댓말체로 작성해야 합니다.
            - '습니다체' 사용: "~했습니다", "~입니다", "~하였습니다"
            - 격식적이지 않은 명확한 표현 사용
            - 간결하고 명료한 문장 사용
            - 객관적인 사실과 분석 중심으로 서술
            - 균형 잡힌 시각에서 다양한 관점 제시
            """
        elif style == "전문적인":
            style_specific_instructions = """
            이 블로그는 반드시 전문적이고 분석적인 어투로 작성해야 합니다.
            - '습니다체' 사용: "~했습니다", "~입니다", "~하였습니다"
            - 역사, 이론, 연구 결과 등 심층 정보 포함
            - 객관적이고 논리적인 분석 중심 작성
            - 구체적인 데이터 및 수치 포함하여 설명
            - 다양한 관점과 이론적 프레임워크 제시
            """
        
        # Phase 1: 초기 생성
        initial_prompt = f"""
주제: {query} 정보성 블로그
참고글 1: {ref1}
참고글 2: {ref2}
참고글 3: {ref3}
목표 글자수: {TARGET_CHAR_LENGTH}
{format_prompt}
스타일 가이드:
{style_prompt}
스타일 세부 지시사항:
{style_specific_instructions}
특별 지시사항:
1. 반드시 글의 처음에 매력적이고 명확한 제목 포함 (주제와 핵심 포인트를 담은 제목).
2. 마크다운 문법(#, *, -, 1., 2., 등) 사용 금지.
3. 소제목은 번호 없이 작성하고, 5개 이하로 제한.
4. 모든 목록은 불릿이나 번호 없이 자연스럽게 서술.
5. "참고글" 관련 표현 사용 금지.
6. 주제에 관한 정확하고 신뢰할 수 있는 정보만 작성.
7. 구체적인 정보(역사적 배경, 주요 개념, 이론, 실용적 적용, 최신 동향 등) 자연스럽게 포함.
8. 글자수가 최소 {TARGET_CHAR_LENGTH}자 이상이어야 함.
9. 각 소제목 아래 내용은 최소 {MIN_SECTION_LENGTH}자 이상 서술.
10. 반드시 다음 구성 요소를 포함할 것:
    - 주제에 대한 명확한 소개와 배경
    - 주제의 역사적/이론적 맥락
    - 현재 동향이나 최신 정보
    - 주요 개념이나 원리에 대한 설명
    - 실용적인 적용 방법이나 사례
    - 다양한 관점이나 비교 분석
    - 향후 전망이나 결론
"""
        
        first_attempt = call_gemini_api(initial_prompt)
        first_attempt_cleaned = remove_unwanted_phrases(first_attempt)
        first_attempt_length = len(first_attempt_cleaned)
        
        if first_attempt_length >= TARGET_CHAR_LENGTH:
            final_post = post_process_blog(first_attempt_cleaned, style)
            final_html = format_blog_post(final_post, query)
            return final_html, ref1, ref2, ref3, first_attempt_length
        
        # Phase 2: 퇴고 (Revision) 시도
        longest_ref = max([ref1, ref2, ref3], key=len)
        revision_prompt = f"""
이전 글:
{first_attempt_cleaned}
참고글: {longest_ref}
포스팅 스타일:
{style_prompt}
스타일 세부 지시사항:
{style_specific_instructions}
문제점:
이전에 작성된 글은 목표 글자수인 {TARGET_CHAR_LENGTH}자에 미치지 못합니다. 현재 글자수는 약 {first_attempt_length}자입니다.
또한, 각 소제목 아래 내용이 너무 짧고 부실합니다.
중요 요구사항:
1. 글의 처음에 매력적인 제목(주제와 핵심 포인트 포함) 추가.
2. 글자수를 최소 {TARGET_CHAR_LENGTH}자 이상으로 늘리고, 각 섹션을 상세히 서술.
3. 마크다운 형식(#, *, -, 1., 2., 등) 사용 금지.
4. 소제목은 번호 없이 작성.
5. 모든 목록은 불릿이나 번호 없이 서술.
6. "참고글" 관련 표현 사용 금지.
7. 주제에 관한 정확하고 신뢰할 수 있는 정보만 작성.
8. 각 소제목 아래 내용을 최소 {MIN_SECTION_LENGTH}자 이상 서술.
9. 소제목 수는 5개 이하로 제한.
상세 보완:
- 주제의 배경 및 맥락에 대한 더 깊은 설명 추가.
- 구체적인 사례, 연구 결과, 통계 등 실증적 데이터 추가.
- 역사적 발전 과정, 주요 이론적 프레임워크 등 심층 정보 추가.
- 실용적인 적용 방법, 팁, 권장사항 등 실행 가능한 정보 추가.
- 다양한 관점, 쟁점, 논쟁점 등 균형 잡힌 시각 제공.
"""
        revised_attempt = call_gemini_api(revision_prompt)
        revised_cleaned = remove_unwanted_phrases(revised_attempt)
        final_post = post_process_blog(revised_cleaned, style)
        final_html = format_blog_post(final_post, query)
        
        soup = BeautifulSoup(final_html, 'html.parser')
        actual_char_length = len(soup.get_text())
        
        # Phase 3: 확장 (Expansion) 시도 (글자수가 부족할 경우)
        if actual_char_length < TARGET_CHAR_LENGTH * 0.8:
            expansion_prompt = f"""
다음 정보성 블로그 글의 내용을 크게 확장해주세요:
원본 글:
{final_post}
문제점:
이 글은 목표 글자수인 {TARGET_CHAR_LENGTH}자에 미치지 못합니다. 현재 글자수는 약 {actual_char_length}자이며, 내용이 부실합니다.
스타일 가이드:
{style_prompt}
스타일 세부 지시사항:
{style_specific_instructions}
요구사항:
1. 각 소제목 아래의 내용을 최소 {MIN_SECTION_LENGTH}자 이상 대폭 확장.
2. 구체적인 사례, 연구 결과, 통계, 예시 등을 추가.
3. 마크다운 형식(#, *, -, 1., 2., 등) 사용 금지.
4. {style} 스타일에 맞춰 일관되게 작성.
5. 소제목 구조는 유지하되, 각 섹션 내용을 3배 이상 풍부하게 확장.
6. 주제의 역사적 발전, 이론적 배경, 주요 개념 등을 더 상세히 서술.
7. 전체 글자수를 최소 {TARGET_CHAR_LENGTH}자 이상 달성.
8. 소제목 수는 최대 5개로 제한.
9. 실용적 정보(적용 방법, 팁, 주의사항 등) 추가.
10. 다양한 관점과 시각에서의 분석 추가.
11. 주제와 관련된 최신 동향이나 발전 방향 추가.
12. 결론 부분에서 주제의 의의와 중요성 강조.
"""
            expanded_attempt = call_gemini_api(expansion_prompt)
            final_post = post_process_blog(expanded_attempt, style)
            final_html = format_blog_post(final_post, query)
            soup = BeautifulSoup(final_html, 'html.parser')
            actual_char_length = len(soup.get_text())
        
        return final_html, ref1, ref2, ref3, actual_char_length
        
    except Exception as e:
        logging.error(f"블로그 글 생성 중 오류 발생: {str(e)}")
        return f"<p>블로그 글 생성 중 오류 발생: {str(e)}</p>", "", "", "", 0