# 초기 규칙 기반 분류
political_categories = {
    "정책": ["정책", "공약", "법안", "제도", "개혁", "복지", "경제"],
    "인사": ["인사", "임명", "해임", "사퇴", "후보", "지명"],
    "선거": ["선거", "투표", "후보", "공천", "캠페인", "여론조사"],
    "논란": ["논란", "비판", "갈등", "반발", "문제", "스캔들"]
}

def classify_category_simple(title, content):
    full_text = f"{title} {content}".lower()
    category_scores = {}
    
    for category, keywords in political_categories.items():
        score = sum(full_text.count(keyword) for keyword in keywords)
        category_scores[category] = score
    
    return max(category_scores, key=category_scores.get) if category_scores else "기타"

class ImprovedMLService:
    def __init__(self):
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        
        # 모델 설정
        self.models_config = {
            "summarizer": {
                "model_name": "facebook/bart-large-cnn",
                "fallback": "t5-small"
            },
            "classifier": {
                "model_name": "klue/bert-base"
            },
            "ner": {
                "model_name": "klue/bert-base-ner",
                "fallback": "dbmdz/bert-large-cased-finetuned-conll03-english"
            }
        }

async def _generate_metadata_with_ai(self, title: str, content: str):
    """AI 기반 메타데이터 생성 (비동기 처리)"""
    
    # 비동기 처리를 위한 태스크 생성
    tasks = []
    
    # 1. 요약 생성 태스크
    summary_task = asyncio.create_task(
        self._run_in_executor(self.ml_service.extract_summary, content)
    )
    tasks.append(("summary", summary_task))
    
    # 2. 카테고리 분류 태스크  
    category_task = asyncio.create_task(
        self._run_in_executor(self.ml_service.classify_category, title, content)
    )
    tasks.append(("category", category_task))
    
    # 3. 개체명 인식 태스크
    entities_task = asyncio.create_task(
        self._run_in_executor(self.ml_service.extract_entities, f"{title} {content}")
    )
    tasks.append(("entities", entities_task))
    
    # 4. 키워드 추출 태스크
    keywords_task = asyncio.create_task(
        self._run_in_executor(self.ml_service.extract_keywords, f"{title} {content}")
    )
    tasks.append(("keywords", keywords_task))
    
    # 모든 태스크 실행 및 결과 수집
    results = {}
    for task_name, task in tasks:
        results[task_name] = await task

def extract_summary(self, text: str, max_length: int = 150) -> str:
    """BART 기반 텍스트 요약"""
    try:
        # 텍스트 전처리
        cleaned_text = self._preprocess_text(text)
        
        # BART 요약 생성
        summary = self.summarizer(
            cleaned_text,
            max_length=max_length,
            min_length=50,
            do_sample=False,
            truncation=True
        )
        
        return summary[0]['summary_text']
    except Exception as e:
        # 폴백: 첫 2문장 추출
        return self._fallback_summary(text)

def _embedding_based_classification(self, title: str, content: str) -> str:
    """임베딩 기반 카테고리 분류"""
    
    # 입력 텍스트 임베딩
    input_text = f"{title} {content[:500]}"
    input_embedding = self.sentence_transformer.encode([input_text])
    
    # 카테고리별 대표 문장들
    category_examples = {
        "정책": ["정부가 새로운 정책을 발표했다", "경제 정책 개혁안이 논의되고 있다"],
        "인사": ["새로운 장관이 임명되었다", "고위 공직자 인사 발표가 있었다"],
        "선거": ["선거 캠페인이 시작되었다", "후보자들이 공약을 발표했다"],
        "논란": ["정치인의 발언이 논란이 되고 있다", "정책을 두고 갈등이 발생했다"]
    }
    
    # 코사인 유사도로 가장 적합한 카테고리 선정
    best_category = "기타"
    best_score = -1
    
    for category, examples in category_examples.items():
        category_embeddings = self.sentence_transformer.encode(examples)
        similarities = cosine_similarity(input_embedding, category_embeddings)
        avg_similarity = similarities.mean()
        
        if avg_similarity > best_score:
            best_score = avg_similarity
            best_category = category
    
    return best_category if best_score > 0.3 else "기타"

def extract_entities(self, text: str) -> List[Dict]:
    """KLUE-BERT 기반 개체명 인식"""
    
    # NER 실행
    entities = self.ner_pipeline(text)
    
    # 결과 정리 및 후처리
    processed_entities = []
    seen_entities = set()
    
    for entity in entities:
        entity_text = entity.get("word", "").replace("##", "").strip()
        entity_type = entity.get("entity_group", "MISC")
        confidence = entity.get("score", 0.0)
        
        # 중복 제거 및 필터링
        if (entity_text, entity_type) not in seen_entities and len(entity_text) > 1:
            seen_entities.add((entity_text, entity_type))
            processed_entities.append({
                "entity_type": entity_type,
                "entity_text": entity_text,
                "confidence_score": f"{confidence:.3f}"
            })
    
    return processed_entities[:15]

def extract_keywords(self, text: str, top_k: int = 10) -> List[Dict]:
    """KoNLPy 기반 키워드 추출"""
    
    # 형태소 분석으로 명사 추출
    nouns = self.okt.nouns(cleaned_text)
    
    # 길이 2 이상인 명사만 필터링
    filtered_nouns = [noun for noun in nouns if len(noun) >= 2]
    
    # 불용어 제거
    stopwords = {'것', '등', '및', '또한', '하지만', '그러나', '따라서', '위해', '통해', '대해'}
    words = [word for word in filtered_nouns if word not in stopwords]
    
    # 빈도 계산 및 중요도 점수
    word_freq = Counter(words)
    top_words = word_freq.most_common(top_k)
    
    max_freq = max(word_freq.values()) if word_freq else 1
    
    keywords = []
    for word, freq in top_words:
        importance = freq / max_freq
        keywords.append({
            "keyword": word,
            "importance_score": f"{importance:.3f}"
        })
    
    return keywords

try:
    # AI 모델 사용 시도
    result = self.ai_model.process(text)
except Exception as e:
    logger.warning(f"AI model failed: {e}")
    # 폴백: 규칙 기반 처리
    result = self.fallback_process(text)

@property
def summarizer(self):
    if self._summarizer is None:
        self._summarizer = self._load_summarizer()
    return self._summarizer

def _load_summarizer(self):
    models_to_try = [
        "facebook/bart-large-cnn",
        "t5-small"
    ]
    
    for model_name in models_to_try:
        try:
            return pipeline("summarization", model=model_name)
        except Exception as e:
            logger.warning(f"Failed to load {model_name}: {e}")
            continue
    
    return "fallback"

@router.get("/health/ai")
async def ai_health_check():
    """AI 모델 상태 확인"""
    health_status = {
        "summarizer": "active" if ml_service.summarizer != "fallback" else "fallback",
        "classifier": "active" if ml_service.classifier != "fallback" else "fallback",
        "ner_pipeline": "active" if ml_service.ner_pipeline != "fallback" else "fallback"
    }
    
    overall_status = "healthy" if any(
        status == "active" for status in health_status.values()
    ) else "degraded"
    
    return {
        "overall_status": overall_status,
        "models": health_status,
        "device": str(ml_service.device)
    }

# 모델 캐싱
TRANSFORMERS_CACHE = "./models_cache"
HF_HOME = "./huggingface_cache"

import pytest
from app.services.safe_ml_service import SafeMLService

class TestMLService:
    def setup_method(self):
        self.ml_service = SafeMLService()
    
    def test_extract_summary(self):
        text = "대통령이 새로운 정책을 발표했다. 이는 경제 회복을 위한 조치이다."
        summary = self.ml_service.extract_summary(text)
        
        assert len(summary) > 0
        assert len(summary) < len(text)
        assert "대통령" in summary
    
    def test_classify_category(self):
        title = "새로운 경제정책 발표"
        content = "정부가 경제 활성화를 위한 새로운 정책을 발표했다."
        category = self.ml_service.classify_category(title, content)
        
        assert category == "정책"
    
    def test_extract_keywords(self):
        text = "윤석열 대통령이 경제정책을 발표했다."
        keywords = self.ml_service.extract_keywords(text, 3)
        
        assert len(keywords) <= 3
        assert any(kw["keyword"] == "윤석열" for kw in keywords)
        assert any(kw["keyword"] == "대통령" for kw in keywords)

import asyncio
import pytest
from app.services.metadata_service import metadata_service

@pytest.mark.asyncio
async def test_full_pipeline():
    title = "정치 개혁 법안 통과"
    content = "국회에서 정치개혁 특별법이 통과되었다. 이는 정치 투명성을 높이기 위한 조치이다."
    
    # 메타데이터 생성 테스트
    metadata = await metadata_service.analyze_article_only(title, content)
    
    assert metadata.category in ["정책", "인사", "선거", "논란", "기타"]
    assert len(metadata.keywords) > 0
    assert len(metadata.tags) > 0
    assert metadata.summary is not None

import time
import statistics

def test_performance():
    """처리 시간 성능 테스트"""
    
    test_articles = [
        {"title": "제목1", "content": "내용1" * 100},
        {"title": "제목2", "content": "내용2" * 100},
        # ... 더 많은 테스트 케이스
    ]
    
    processing_times = []
    
    for article in test_articles:
        start_time = time.time()
        
        # AI 분석 실행
        result = ml_service.extract_summary(article["content"])
        
        processing_time = time.time() - start_time
        processing_times.append(processing_time)
    
    avg_time = statistics.mean(processing_times)
    p95_time = statistics.quantiles(processing_times, n=20)[18]  # 95퍼센타일
    
    print(f"평균 처리 시간: {avg_time:.2f}초")
    print(f"95퍼센타일: {p95_time:.2f}초")
    
    # 성능 기준 검증
    assert avg_time < 5.0  # 평균 5초 이내
    assert p95_time < 10.0  # 95%가 10초 이내