import pdfplumber
import re

def extract_text_from_pdf(pdf_path):
    """PDF 파일에서 텍스트를 추출하는 함수"""
    text = ""
    
    with pdfplumber.open(pdf_path) as pdf:
        for page in pdf.pages:
            # 각 페이지에서 텍스트 추출
            page_text = page.extract_text()
            if page_text:
                text += page_text + "\n"
    
    # 불필요한 공백 제거
    text = re.sub(r'\n+', '\n', text)
    text = re.sub(r' +', ' ', text)
    
    return text

# 사용 예시
report_text = extract_text_from_pdf("삼성전자_투자리포트.pdf")
print(f"추출된 텍스트 길이: {len(report_text)} 글자")

import re
from typing import Dict, List

def preprocess_report(text: str) -> Dict[str, any]:
    """리포트 텍스트를 구조화하는 함수"""
    
    # 섹션 구분 (일반적인 리포트 구조)
    sections = {
        'title': '',
        'summary': '',
        'company_info': '',
        'financial_analysis': '',
        'investment_opinion': '',
        'target_price': '',
        'risks': ''
    }
    
    # 제목 추출 (보통 첫 줄)
    lines = text.split('\n')
    sections['title'] = lines[0] if lines else ''
    
    # 투자의견 추출 (매수, 매도, 중립 등)
    opinion_pattern = r'(투자의견|투자등급|Investment Rating)[:\s]*(매수|매도|중립|BUY|SELL|HOLD)'
    opinion_match = re.search(opinion_pattern, text, re.IGNORECASE)
    if opinion_match:
        sections['investment_opinion'] = opinion_match.group(2)
    
    # 목표주가 추출
    target_pattern = r'목표주가[:\s]*([0-9,]+)\s*원'
    target_match = re.search(target_pattern, text)
    if target_match:
        sections['target_price'] = target_match.group(1)
    
    # 핵심 재무 지표 추출
    financial_keywords = ['영업이익', '매출액', 'EPS', 'PER', 'PBR', 'ROE']
    financial_sentences = []
    
    for line in lines:
        if any(keyword in line for keyword in financial_keywords):
            financial_sentences.append(line.strip())
    
    sections['financial_analysis'] = '\n'.join(financial_sentences)
    
    return sections

# 사용 예시
structured_data = preprocess_report(report_text)
print("투자의견:", structured_data['investment_opinion'])
print("목표주가:", structured_data['target_price'])

import openai
from typing import Dict

# API 키 설정 (실제 사용 시 환경변수로 관리하세요!)
openai.api_key = "your-api-key-here"

def summarize_with_gpt(report_text: str, max_length: int = 500) -> Dict[str, str]:
    """GPT를 사용해 투자 리포트를 요약하는 함수"""
    
    # 프롬프트 엔지니어링이 핵심!
    prompt = f"""
    다음은 투자 리포트의 내용입니다. 이 리포트를 분석하여 다음 항목들을 추출해주세요:
    
    1. 핵심 투자 포인트 (3가지)
    2. 투자의견 및 목표주가
    3. 주요 재무 전망
    4. 리스크 요인
    
    리포트 내용:
    {report_text[:4000]}  # GPT 토큰 제한 고려
    
    위 내용을 {max_length}자 이내로 명확하고 간결하게 요약해주세요.
    """
    
    try:
        response = openai.ChatCompletion.create(
            model="gpt-4",  # 또는 "gpt-3.5-turbo"
            messages=[
                {"role": "system", "content": "당신은 전문 금융 애널리스트입니다. 투자 리포트를 정확하고 간결하게 요약하는 것이 특기입니다."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.3,  # 낮을수록 일관성 있는 답변
            max_tokens=1000
        )
        
        summary = response.choices[0].message.content
        
        # 결과를 구조화
        result = {
            'summary': summary,
            'model': 'gpt-4',
            'tokens_used': response.usage.total_tokens
        }
        
        return result
        
    except Exception as e:
        print(f"오류 발생: {e}")
        return {'summary': '', 'error': str(e)}

# 사용 예시
summary_result = summarize_with_gpt(report_text)
print("=== AI 요약 결과 ===")
print(summary_result['summary'])
print(f"\n사용된 토큰: {summary_result['tokens_used']}")

from transformers import pipeline
import torch

def summarize_with_opensource(text: str, max_length: int = 500) -> str:
    """오픈소스 모델로 요약하는 함수"""
    
    # GPU 사용 가능 여부 확인
    device = 0 if torch.cuda.is_available() else -1
    
    # 한국어 요약 모델 로드
    # 예: "eenzeenee/t5-base-korean-summarization"
    summarizer = pipeline(
        "summarization",
        model="facebook/bart-large-cnn",  # 영어 모델
        device=device
    )
    
    # 텍스트가 너무 길면 청크로 나누기
    max_chunk_length = 1024
    chunks = [text[i:i+max_chunk_length] 
              for i in range(0, len(text), max_chunk_length)]
    
    summaries = []
    for chunk in chunks[:3]:  # 처음 3개 청크만 처리
        try:
            summary = summarizer(
                chunk,
                max_length=max_length,
                min_length=50,
                do_sample=False
            )
            summaries.append(summary[0]['summary_text'])
        except Exception as e:
            print(f"청크 처리 중 오류: {e}")
            continue
    
    # 모든 요약을 합치기
    final_summary = " ".join(summaries)
    
    return final_summary

# 사용 예시
opensource_summary = summarize_with_opensource(report_text)
print("=== 오픈소스 모델 요약 ===")
print(opensource_summary)

import re
from datetime import datetime
from typing import Dict, List

class InvestmentReportAnalyzer:
    """투자 리포트 분석 클래스"""
    
    def __init__(self, text: str):
        self.text = text
        self.analysis = {}
    
    def extract_key_metrics(self) -> Dict[str, any]:
        """핵심 지표 추출"""
        metrics = {}
        
        # 목표주가 추출
        target_price_pattern = r'목표주?가[:\s]*([0-9,]+)\s*원'
        match = re.search(target_price_pattern, self.text)
        if match:
            metrics['target_price'] = int(match.group(1).replace(',', ''))
        
        # 현재주가 추출
        current_price_pattern = r'현재주?가[:\s]*([0-9,]+)\s*원'
        match = re.search(current_price_pattern, self.text)
        if match:
            metrics['current_price'] = int(match.group(1).replace(',', ''))
        
        # 상승여력 계산
        if 'target_price' in metrics and 'current_price' in metrics:
            upside = ((metrics['target_price'] - metrics['current_price']) 
                     / metrics['current_price'] * 100)
            metrics['upside_potential'] = round(upside, 2)
        
        # EPS 추출
        eps_pattern = r'EPS[:\s]*([0-9,]+)\s*원'
        match = re.search(eps_pattern, self.text)
        if match:
            metrics['eps'] = int(match.group(1).replace(',', ''))
        
        # PER 추출
        per_pattern = r'PER[:\s]*([0-9.]+)\s*배'
        match = re.search(per_pattern, self.text)
        if match:
            metrics['per'] = float(match.group(1))
        
        return metrics
    
    def extract_investment_opinion(self) -> Dict[str, str]:
        """투자의견 추출"""
        opinion_data = {}
        
        # 투자의견 매핑
        opinion_map = {
            '매수': 'BUY',
            'BUY': 'BUY',
            '적극매수': 'STRONG_BUY',
            '중립': 'HOLD',
            'HOLD': 'HOLD',
            '매도': 'SELL',
            'SELL': 'SELL'
        }
        
        # 투자의견 찾기
        for korean, english in opinion_map.items():
            if korean in self.text:
                opinion_data['opinion'] = english
                opinion_data['opinion_kr'] = korean
                break
        
        # 이전 의견과 비교
        change_pattern = r'(상향|하향|유지)'
        match = re.search(change_pattern, self.text)
        if match:
            opinion_data['change'] = match.group(1)
        
        return opinion_data
    
    def extract_financial_forecast(self) -> List[Dict]:
        """재무 전망 추출"""
        forecasts = []
        
        # 연도별 실적 전망 패턴
        year_pattern = r'(20\d{2})년.*?매출.*?([0-9,]+).*?영업이익.*?([0-9,]+)'
        matches = re.finditer(year_pattern, self.text)
        
        for match in matches:
            forecast = {
                'year': match.group(1),
                'revenue': match.group(2).replace(',', ''),
                'operating_profit': match.group(3).replace(',', '')
            }
            forecasts.append(forecast)
        
        return forecasts
    
    def extract_key_points(self) -> List[str]:
        """핵심 포인트 추출"""
        key_points = []
        
        # "핵심", "포인트", "주목" 같은 키워드가 있는 문장 찾기
        keywords = ['핵심', '포인트', '주목', '주요', '특징']
        sentences = self.text.split('.')
        
        for sentence in sentences:
            if any(keyword in sentence for keyword in keywords):
                cleaned = sentence.strip()
                if len(cleaned) > 20:  # 너무 짧은 문장 제외
                    key_points.append(cleaned)
        
        return key_points[:5]  # 상위 5개만
    
    def analyze(self) -> Dict[str, any]:
        """전체 분석 실행"""
        self.analysis = {
            'metrics': self.extract_key_metrics(),
            'opinion': self.extract_investment_opinion(),
            'forecast': self.extract_financial_forecast(),
            'key_points': self.extract_key_points(),
            'analyzed_at': datetime.now().isoformat()
        }
        
        return self.analysis

# 사용 예시
analyzer = InvestmentReportAnalyzer(report_text)
analysis_result = analyzer.analyze()

print("=== 분석 결과 ===")
print(f"목표주가: {analysis_result['metrics'].get('target_price', 'N/A'):,}원")
print(f"상승여력: {analysis_result['metrics'].get('upside_potential', 'N/A')}%")
print(f"투자의견: {analysis_result['opinion'].get('opinion_kr', 'N/A')}")
print("\n핵심 포인트:")
for i, point in enumerate(analysis_result['key_points'], 1):
    print(f"{i}. {point}")

import schedule
import time
from datetime import datetime
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

class AutomatedReportAnalyzer:
    """자동화된 리포트 분석 시스템"""
    
    def __init__(self, email_config: Dict[str, str]):
        self.email_config = email_config
        self.reports_processed = 0
    
    def collect_new_reports(self) -> List[str]:
        """새로운 리포트 수집"""
        # 실제로는 웹 크롤링이나 API 호출로 구현
        # 여기서는 예시로 파일 시스템 체크
        import os
        
        reports_dir = "./reports"
        new_reports = []
        
        if os.path.exists(reports_dir):
            for filename in os.listdir(reports_dir):
                if filename.endswith('.pdf'):
                    filepath = os.path.join(reports_dir, filename)
                    # 오늘 생성된 파일만
                    if self._is_today_file(filepath):
                        new_reports.append(filepath)
        
        return new_reports
    
    def _is_today_file(self, filepath: str) -> bool:
        """파일이 오늘 생성되었는지 확인"""
        import os
        from datetime import date
        
        file_time = os.path.getmtime(filepath)
        file_date = datetime.fromtimestamp(file_time).date()
        return file_date == date.today()
    
    def process_report(self, pdf_path: str) -> Dict[str, any]:
        """리포트 처리 파이프라인"""
        print(f"처리 중: {pdf_path}")
        
        # 1. PDF에서 텍스트 추출
        text = extract_text_from_pdf(pdf_path)
        
        # 2. 전처리
        structured = preprocess_report(text)
        
        # 3. AI 요약
        summary = summarize_with_gpt(text, max_length=300)
        
        # 4. 핵심 정보 추출
        analyzer = InvestmentReportAnalyzer(text)
        analysis = analyzer.analyze()
        
        # 결과 통합
        result = {
            'filename': pdf_path.split('/')[-1],
            'summary': summary['summary'],
            'analysis': analysis,
            'processed_at': datetime.now().isoformat()
        }
        
        return result
    
    def send_email_report(self, results: List[Dict]):
        """이메일로 결과 전송"""
        if not results:
            print("전송할 리포트가 없습니다.")
            return
        
        # 이메일 내용 생성
        html_content = self._generate_email_html(results)
        
        # 이메일 설정
        msg = MIMEMultipart('alternative')
        msg['Subject'] = f"📊 투자 리포트 요약 - {datetime.now().strftime('%Y-%m-%d')}"
        msg['From'] = self.email_config['from']
        msg['To'] = self.email_config['to']
        
        html_part = MIMEText(html_content, 'html')
        msg.attach(html_part)
        
        # 이메일 전송
        try:
            with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
                server.login(
                    self.email_config['username'],
                    self.email_config['password']
                )
                server.send_message(msg)
            print("✅ 이메일 전송 완료!")
        except Exception as e:
            print(f"❌ 이메일 전송 실패: {e}")
    
    def _generate_email_html(self, results: List[Dict]) -> str:
        """이메일 HTML 생성"""
        html = f"""
        <html>
        <head>
            <style>.tx-header{background:linear-gradient(135deg,#f5f7fa 0%,#e8ecf1 100%);
border-radius:16px;
padding:40px 30px;
text-align:center;
margin-bottom:40px;
box-shadow:0 4px 15px rgba(0,0,0,0.08)}
.tx-section{margin:50px 0;
line-height:1.9}
.tx-highlight{background:linear-gradient(120deg,#fef5e7 0%,#fdebd0 100%);
padding:25px;
border-radius:12px;
margin:30px 0;
border-left:5px solid #f39c12}
.tx-point-box{background:#f8f9fa;
padding:20px;
border-radius:10px;
margin:25px 0;
border-left:4px solid #3498db}
.tx-tip{background:linear-gradient(135deg,#e8f5e9 0%,#c8e6c9 100%);
padding:20px;
border-radius:10px;
margin:25px 0}
.tx-warning{background:linear-gradient(135deg,#fff3e0 0%,#ffe0b2 100%);
padding:20px;
border-radius:10px;
margin:25px 0}
.tx-table-wrap{overflow-x:auto;
margin:25px 0}
.tx-table{width:100%;
border-collapse:collapse;
background:white;
border-radius:8px;
overflow:hidden}
.tx-table th{background:#34495e;
color:white;
padding:15px;
text-align:left}
.tx-table td{padding:12px 15px;
border-bottom:1px solid #ecf0f1}
.tx-step{background:white;
padding:20px;
margin:20px 0;
border-radius:10px;
box-shadow:0 2px 8px rgba(0,0,0,0.06)}
.tx-icon-text{display:inline-block;
margin:8px 15px 8px 0}
h2{color:#2c3e50;
padding:15px 20px;
background:linear-gradient(120deg,#e3f2fd 0%,#bbdefb 100%);
border-radius:10px;
margin:40px 0 25px 0;
border-left:6px solid #2196f3}
h3{color:#34495e;
padding:12px 18px;
background:linear-gradient(120deg,#f3e5f5 0%,#e1bee7 100%);
border-radius:8px;
margin:30px 0 20px 0;
border-left:5px solid #9c27b0}
h4{color:#455a64;
margin:25px 0 15px 0;
padding-left:15px;
border-left:4px solid #90a4ae}</style>
        </head>
        <body>
            <h2>📊 오늘의 투자 리포트 요약</h2>
            <p>총 {len(results)}개의 리포트가 분석되었습니다.</p>
        """
        
        for result in results:
            analysis = result['analysis']
            metrics = analysis.get('metrics', {})
            opinion = analysis.get('opinion', {})
            
            html += f"""
            <div class="report">
                <div class="title">{result['filename']}</div>
                <p><strong>투자의견:</strong> {opinion.get('opinion_kr', 'N/A')}</p>
                <p><strong>목표주가:</strong> <span class="metric">{metrics.get('target_price', 'N/A'):,}원</span></p>
                <p><strong>상승여력:</strong> <span class="metric">{metrics.get('upside_potential', 'N/A')}%</span></p>
                <div class="summary">
                    <strong>요약:</strong><br>
                    {result['summary'][:200]}...
                </div>
            </div>
            """
        
        html += """
        </body>
        </html>
        """
        
        return html
    
    def daily_job(self):
        """매일 실행될 작업"""
        print(f"\n{'='*50}")
        print(f"🤖 자동 분석 시작: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        print(f"{'='*50}\n")
        
        # 1. 새 리포트 수집
        new_reports = self.collect_new_reports()
        print(f"📥 새로운 리포트 {len(new_reports)}개 발견")
        
        # 2. 각 리포트 처리
        results = []
        for report_path in new_reports:
            try:
                result = self.process_report(report_path)
                results.append(result)
                self.reports_processed += 1
            except Exception as e:
                print(f"❌ 처리 실패 ({report_path}): {e}")
        
        # 3. 결과 이메일 전송
        if results:
            self.send_email_report(results)
        
        print(f"\n✅ 작업 완료! (총 처리: {self.reports_processed}개)")
    
    def start_scheduler(self):
        """스케줄러 시작"""
        # 매일 오전 9시에 실행
        schedule.every().day.at("09:00").do(self.daily_job)
        
        # 테스트용: 매 1분마다 실행
        # schedule.every(1).minutes.do(self.daily_job)
        
        print("🚀 스케줄러 시작!")
        print("매일 오전 9시에 자동으로 리포트를 분석합니다.")
        
        while True:
            schedule.run_pending()
            time.sleep(60)  # 1분마다 체크

# 사용 예시
email_config = {
    'from': 'your-email@gmail.com',
    'to': 'recipient@gmail.com',
    'username': 'your-email@gmail.com',
    'password': 'your-app-password'  # Gmail 앱 비밀번호
}

analyzer = AutomatedReportAnalyzer(email_config)
# analyzer.start_scheduler()  # 실제 운영 시 주석 해제

import streamlit as st
import pandas as pd
import plotly.graph_objects as go
from datetime import datetime, timedelta

# 페이지 설정
st.set_page_config(
    page_title="투자 리포트 분석 대시보드",
    page_icon="📊",
    layout="wide"
)

# 타이틀
st.title("📊 AI 투자 리포트 분석 대시보드")
st.markdown("---")

# 사이드바
with st.sidebar:
    st.header("⚙️ 설정")
    
    # 날짜 범위 선택
    date_range = st.date_input(
        "분석 기간",
        value=(datetime.now() - timedelta(days=7), datetime.now())
    )
    
    # 종목 선택
    stocks = st.multiselect(
        "종목 선택",
        ["삼성전자", "SK하이닉스", "NAVER", "카카오", "LG에너지솔루션"],
        default=["삼성전자", "SK하이닉스"]
    )
    
    # 투자의견 필터
    opinions = st.multiselect(
        "투자의견",
        ["매수", "중립", "매도"],
        default=["매수", "중립"]
    )

# 메인 컨텐츠
col1, col2, col3 = st.columns(3)

with col1:
    st.metric(
        label="📄 분석된 리포트",
        value="127",
        delta="15"
    )

with col2:
    st.metric(
        label="🎯 평균 목표주가 상승률",
        value="12.5%",
        delta="2.3%"
    )

with col3:
    st.metric(
        label="📈 매수 의견 비율",
        value="68%",
        delta="5%"
    )

st.markdown("---")

# 리포트 목록
st.subheader("📋 최근 분석 리포트")

# 샘플 데이터
data = {
    '종목': ['삼성전자', 'SK하이닉스', 'NAVER', '카카오'],
    '증권사': ['한국투자증권', 'NH투자증권', '미래에셋증권', 'KB증권'],
    '투자의견': ['매수', '매수', '중립', '매수'],
    '목표주가': ['85,000원', '145,000원', '250,000원', '65,000원'],
    '상승여력': ['+15.2%', '+18.5%', '+8.3%', '+12.7%'],
    '발행일': ['2024-01-15', '2024-01-15', '2024-01-14', '2024-01-14']
}

df = pd.DataFrame(data)

# 스타일 적용
def highlight_opinion(val):
    if val == '매수':
        return 'background-color: #d4edda; color: #155724'
    elif val == '매도':
        return 'background-color: #f8d7da; color: #721c24'
    else:
        return 'background-color: #fff3cd; color: #856404'

styled_df = df.style.applymap(
    highlight_opinion,
    subset=['투자의견']
)

st.dataframe(styled_df, use_container_width=True)

# 차트
st.markdown("---")
st.subheader("📈 목표주가 추이")

# 샘플 차트 데이터
chart_data = pd.DataFrame({
    '날짜': pd.date_range(start='2024-01-01', periods=15, freq='D'),
    '삼성전자': [75000, 76000, 77000, 78000, 79000, 80000, 81000, 
                82000, 81500, 82500, 83000, 83500, 84000, 84500, 85000],
    'SK하이닉스': [120000, 122000, 125000, 127000, 130000, 132000, 135000,
                  137000, 138000, 140000, 141000, 142000, 143000, 144000, 145000]
})

fig = go.Figure()

for stock in ['삼성전자', 'SK하이닉스']:
    fig.add_trace(go.Scatter(
        x=chart_data['날짜'],
        y=chart_data[stock],
        mode='lines+markers',
        name=stock,
        line=dict(width=3)
    ))

fig.update_layout(
    title="종목별 목표주가 변동 추이",
    xaxis_title="날짜",
    yaxis_title="목표주가 (원)",
    hovermode='x unified',
    height=400
)

st.plotly_chart(fig, use_container_width=True)

# 요약 섹션
st.markdown("---")
st.subheader("💡 AI 요약")

with st.expander("삼성전자 - 한국투자증권 (2024-01-15)", expanded=True):
    st.markdown("""
    **투자의견:** 매수 (유지)  
    **목표주가:** 85,000원 (상향)  
    
    **핵심 포인트:**
    1. 메모리 반도체 가격 상승세 지속 전망
    2. 2024년 1분기 영업이익 4.5조원 예상 (전년 대비 300% 증가)
    3. HBM3 수요 증가로 고부가 제품 비중 확대
    
    **리스크:**
    - 중국 경기 둔화에 따른 수요 감소 가능성
    - 환율 변동성
    """)

# 푸터
st.markdown("---")
st.caption("🤖 Powered by AI Report Analyzer | 마지막 업데이트: " + 
          datetime.now().strftime("%Y-%m-%d %H:%M:%S"))

import hashlib
import json
from functools import lru_cache
import redis

class ReportCache:
    """리포트 분석 결과 캐싱"""
    
    def __init__(self, use_redis=False):
        self.use_redis = use_redis
        if use_redis:
            self.redis_client = redis.Redis(
                host='localhost',
                port=6379,
                decode_responses=True
            )
    
    def get_cache_key(self, text: str) -> str:
        """텍스트의 해시값으로 캐시 키 생성"""
        return hashlib.md5(text.encode()).hexdigest()
    
    def get(self, text: str):
        """캐시에서 결과 가져오기"""
        key = self.get_cache_key(text)
        
        if self.use_redis:
            cached = self.redis_client.get(key)
            if cached:
                return json.loads(cached)
        else:
            # 메모리 캐시 (간단한 딕셔너리)
            if hasattr(self, '_cache') and key in self._cache:
                return self._cache[key]
        
        return None
    
    def set(self, text: str, result: dict, expire: int = 86400):
        """결과를 캐시에 저장 (기본 24시간)"""
        key = self.get_cache_key(text)
        
        if self.use_redis:
            self.redis_client.setex(
                key,
                expire,
                json.dumps(result)
            )
        else:
            if not hasattr(self, '_cache'):
                self._cache = {}
            self._cache[key] = result

# 사용 예시
cache = ReportCache(use_redis=False)

def analyze_with_cache(text: str):
    """캐시를 활용한 분석"""
    # 캐시 확인
    cached_result = cache.get(text)
    if cached_result:
        print("✅ 캐시에서 결과 로드!")
        return cached_result
    
    # 캐시 없으면 새로 분석
    print("🔄 새로 분석 중...")
    result = summarize_with_gpt(text)
    
    # 결과 캐싱
    cache.set(text, result)
    
    return result

from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import List
import time

def batch_process_reports(report_paths: List[str], max_workers: int = 5):
    """여러 리포트를 병렬로 처리"""
    results = []
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        # 모든 작업 제출
        future_to_path = {
            executor.submit(process_single_report, path): path 
            for path in report_paths
        }
        
        # 완료된 작업부터 결과 수집
        for future in as_completed(future_to_path):
            path = future_to_path[future]
            try:
                result = future.result()
                results.append(result)
                print(f"✅ 완료: {path}")
            except Exception as e:
                print(f"❌ 실패: {path} - {e}")
    
    return results

def process_single_report(path: str):
    """단일 리포트 처리"""
    text = extract_text_from_pdf(path)
    summary = summarize_with_gpt(text)
    return {
        'path': path,
        'summary': summary,
        'processed_at': time.time()
    }

# 사용 예시
report_files = [
    "report1.pdf",
    "report2.pdf",
    "report3.pdf",
    "report4.pdf",
    "report5.pdf"
]

start_time = time.time()
results = batch_process_reports(report_files, max_workers=3)
end_time = time.time()

print(f"\n총 처리 시간: {end_time - start_time:.2f}초")
print(f"리포트당 평균: {(end_time - start_time) / len(report_files):.2f}초")

def smart_chunk_text(text: str, max_chunk_size: int = 3000) -> List[str]:
    """텍스트를 의미 단위로 청킹"""
    
    # 문단 단위로 분리
    paragraphs = text.split('\n\n')
    
    chunks = []
    current_chunk = ""
    
    for para in paragraphs:
        # 현재 청크에 추가해도 크기가 괜찮으면
        if len(current_chunk) + len(para) < max_chunk_size:
            current_chunk += para + "\n\n"
        else:
            # 현재 청크 저장하고 새 청크 시작
            if current_chunk:
                chunks.append(current_chunk.strip())
            current_chunk = para + "\n\n"
    
    # 마지막 청크 추가
    if current_chunk:
        chunks.append(current_chunk.strip())
    
    return chunks

def summarize_long_report(text: str) -> str:
    """긴 리포트를 청크별로 요약 후 통합"""
    
    # 1단계: 텍스트를 청크로 나누기
    chunks = smart_chunk_text(text, max_chunk_size=3000)
    print(f"📄 {len(chunks)}개 청크로 분할")
    
    # 2단계: 각 청크 요약
    chunk_summaries = []
    for i, chunk in enumerate(chunks):
        print(f"처리 중: 청크 {i+1}/{len(chunks)}")
        summary = summarize_with_gpt(chunk, max_length=200)
        chunk_summaries.append(summary['summary'])
    
    # 3단계: 요약들을 다시 통합 요약
    combined = "\n\n".join(chunk_summaries)
    final_summary = summarize_with_gpt(combined, max_length=500)
    
    return final_summary['summary']

import logging
from datetime import datetime
import traceback

# 로거 설정
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('report_analyzer.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger('ReportAnalyzer')

class RobustReportAnalyzer:
    """에러 처리가 강화된 분석기"""
    
    def __init__(self):
        self.success_count = 0
        self.error_count = 0
        self.errors = []
    
    def safe_process(self, pdf_path: str, max_retries: int = 3):
        """안전한 리포트 처리 (재시도 포함)"""
        
        for attempt in range(max_retries):
            try:
                logger.info(f"처리 시작: {pdf_path} (시도 {attempt + 1}/{max_retries})")
                
                # 1. PDF 추출
                text = self._safe_extract_pdf(pdf_path)
                if not text:
                    raise ValueError("텍스트 추출 실패")
                
                # 2. 요약 생성
                summary = self._safe_summarize(text)
                if not summary:
                    raise ValueError("요약 생성 실패")
                
                # 3. 분석
                analysis = self._safe_analyze(text)
                
                self.success_count += 1
                logger.info(f"✅ 처리 성공: {pdf_path}")
                
                return {
                    'success': True,
                    'path': pdf_path,
                    'summary': summary,
                    'analysis': analysis
                }
                
            except Exception as e:
                logger.error(f"❌ 오류 발생 (시도 {attempt + 1}): {str(e)}")
                logger.error(traceback.format_exc())
                
                if attempt == max_retries - 1:
                    # 마지막 시도도 실패
                    self.error_count += 1
                    self.errors.append({
                        'path': pdf_path,
                        'error': str(e),
                        'timestamp': datetime.now().isoformat()
                    })
                    
                    return {
                        'success': False,
                        'path': pdf_path,
                        'error': str(e)
                    }
                
                # 재시도 전 대기
                time.sleep(2 ** attempt)  # 지수 백오프
    
    def _safe_extract_pdf(self, pdf_path: str) -> str:
        """안전한 PDF 추출"""
        try:
            return extract_text_from_pdf(pdf_path)
        except Exception as e:
            logger.error(f"PDF 추출 실패: {e}")
            raise
    
    def _safe_summarize(self, text: str) -> str:
        """안전한 요약 생성"""
        try:
            # 텍스트 길이 체크
            if len(text) < 100:
                raise ValueError("텍스트가 너무 짧음")
            
            # 요약 생성
            result = summarize_with_gpt(text)
            return result.get('summary', '')
            
        except Exception as e:
            logger.error(f"요약 생성 실패: {e}")
            # 폴백: 간단한 추출 요약
            return self._fallback_summary(text)
    
    def _fallback_summary(self, text: str) -> str:
        """폴백 요약 (AI 실패 시)"""
        # 첫 500자만 반환
        return text[:500] + "..."
    
    def _safe_analyze(self, text: str):
        """안전한 분석"""
        try:
            analyzer = InvestmentReportAnalyzer(text)
            return analyzer.analyze()
        except Exception as e:
            logger.error(f"분석 실패: {e}")
            return {}
    
    def get_statistics(self):
        """처리 통계"""
        total = self.success_count + self.error_count
        success_rate = (self.success_count / total * 100) if total > 0 else 0
        
        return {
            'total': total,
            'success': self.success_count,
            'errors': self.error_count,
            'success_rate': f"{success_rate:.2f}%"
        }

class CostTracker:
    """API 비용 추적"""
    
    def __init__(self):
        self.total_tokens = 0
        self.total_cost = 0
        self.requests = []
    
    def track_request(self, model: str, input_tokens: int, output_tokens: int):
        """요청 추적"""
        
        # 모델별 가격 (2024년 기준, 1000 토큰당)
        prices = {
            'gpt-4': {'input': 0.03, 'output': 0.06},
            'gpt-3.5-turbo': {'input': 0.001, 'output': 0.002}
        }
        
        if model in prices:
            cost = (
                input_tokens / 1000 * prices[model]['input'] +
                output_tokens / 1000 * prices[model]['output']
            )
            
            self.total_tokens += (input_tokens + output_tokens)
            self.total_cost += cost
            
            self.requests.append({
                'timestamp': datetime.now(),
                'model': model,
                'tokens': input_tokens + output_tokens,
                'cost': cost
            })
    
    def get_summary(self):
        """비용 요약"""
        return {
            'total_requests': len(self.requests),
            'total_tokens': self.total_tokens,
            'total_cost': f"${self.total_cost:.2f}",
            'avg_cost_per_request': f"${self.total_cost / len(self.requests):.4f}" if self.requests else "$0"
        }
    
    def should_switch_model(self, threshold: float = 10.0) -> bool:
        """비용이 임계값을 넘으면 모델 전환 제안"""
        return self.total_cost > threshold

# 사용 예시
tracker = CostTracker()

def summarize_with_tracking(text: str):
    """비용 추적이 포함된 요약"""
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": text}]
    )
    
    # 비용 추적
    tracker.track_request(
        model="gpt-3.5-turbo",
        input_tokens=response.usage.prompt_tokens,
        output_tokens=response.usage.completion_tokens
    )
    
    # 비용 경고
    if tracker.should_switch_model(threshold=10.0):
        logger.warning("⚠️ 월 비용이 $10를 초과했습니다!")
    
    return response.choices[0].message.content

def compare_reports(reports: List[Dict]) -> Dict:
    """여러 리포트 비교 분석"""
    
    comparison = {
        'stock': reports[0]['stock_name'],
        'report_count': len(reports),
        'opinions': {},
        'target_prices': [],
        'consensus': {}
    }
    
    # 투자의견 집계
    for report in reports:
        opinion = report.get('opinion', 'N/A')
        comparison['opinions'][opinion] = comparison['opinions'].get(opinion, 0) + 1
        
        target_price = report.get('target_price')
        if target_price:
            comparison['target_prices'].append({
                'firm': report['firm'],
                'price': target_price
            })
    
    # 컨센서스 계산
    if comparison['target_prices']:
        prices = [tp['price'] for tp in comparison['target_prices']]
        comparison['consensus'] = {
            'avg_target_price': sum(prices) / len(prices),
            'max_target_price': max(prices),
            'min_target_price': min(prices),
            'std_deviation': statistics.stdev(prices) if len(prices) > 1 else 0
        }
    
    # 가장 많은 의견
    if comparison['opinions']:
        comparison['majority_opinion'] = max(
            comparison['opinions'].items(),
            key=lambda x: x[1]
        )[0]
    
    return comparison

# 사용 예시
samsung_reports = [
    {'stock_name': '삼성전자', 'firm': '한국투자증권', 'opinion': '매수', 'target_price': 85000},
    {'stock_name': '삼성전자', 'firm': 'NH투자증권', 'opinion': '매수', 'target_price': 87000},
    {'stock_name': '삼성전자', 'firm': '미래에셋증권', 'opinion': '중립', 'target_price': 80000},
]

comparison = compare_reports(samsung_reports)
print(f"컨센서스 목표주가: {comparison['consensus']['avg_target_price']:,.0f}원")
print(f"다수 의견: {comparison['majority_opinion']}")

import requests

class AlertSystem:
    """알림 시스템"""
    
    def __init__(self, slack_webhook: str = None, telegram_token: str = None):
        self.slack_webhook = slack_webhook
        self.telegram_token = telegram_token
    
    def should_alert(self, analysis: Dict) -> bool:
        """알림이 필요한지 판단"""
        
        # 알림 조건들
        conditions = [
            # 목표주가 대폭 상향 (10% 이상)
            analysis.get('target_price_change', 0) > 10,
            
            # 투자의견 변경
            analysis.get('opinion_changed', False),
            
            # 상승여력 20% 이상
            analysis.get('upside_potential', 0) > 20,
            
            # 실적 서프라이즈
            'surprise' in analysis.get('keywords', [])
        ]
        
        return any(conditions)
    
    def send_slack(self, message: str):
        """슬랙 알림"""
        if not self.slack_webhook:
            return
        
        payload = {
            'text': message,
            'username': 'Report Analyzer Bot',
            'icon_emoji': ':chart_with_upwards_trend:'
        }
        
        try:
            response = requests.post(self.slack_webhook, json=payload)
            if response.status_code == 200:
                logger.info("✅ 슬랙 알림 전송 완료")
        except Exception as e:
            logger.error(f"슬랙 알림 실패: {e}")
    
    def send_telegram(self, message: str, chat_id: str):
        """텔레그램 알림"""
        if not self.telegram_token:
            return
        
        url = f"https://api.telegram.org/bot{self.telegram_token}/sendMessage"
        payload = {
            'chat_id': chat_id,
            'text': message,
            'parse_mode': 'Markdown'
        }
        
        try:
            response = requests.post(url, json=payload)
            if response.status_code == 200:
                logger.info("✅ 텔레그램 알림 전송 완료")
        except Exception as e:
            logger.error(f"텔레그램 알림 실패: {e}")
    
    def format_alert_message(self, analysis: Dict) -> str:
        """알림 메시지 포맷"""
        message = f"""
🚨 *중요 리포트 알림*

📊 종목: {analysis.get('stock_name', 'N/A')}
🏢 증권사: {analysis.get('firm', 'N/A')}

💰 목표주가: {analysis.get('target_price', 'N/A'):,}원
📈 상승여력: {analysis.get('upside_potential', 'N/A')}%
⭐ 투자의견: {analysis.get('opinion', 'N/A')}

📝 핵심 요약:
{analysis.get('summary', 'N/A')[:200]}...
        """
        return message.strip()

# 사용 예시
alert_system = AlertSystem(
    slack_webhook="your-slack-webhook-url",
    telegram_token="your-telegram-bot-token"
)

def process_with_alert(report_path: str):
    """알림 포함 처리"""
    analysis = process_report(report_path)
    
    if alert_system.should_alert(analysis):
        message = alert_system.format_alert_message(analysis)
        alert_system.send_slack(message)
        alert_system.send_telegram(message, chat_id="your-chat-id")

from flask import Flask, request, jsonify
from flask_cors import CORS

app = Flask(__name__)
CORS(app)  # 모바일 앱에서 접근 가능하도록

# 전역 분석기
analyzer = RobustReportAnalyzer()

@app.route('/api/reports', methods=['GET'])
def get_reports():
    """리포트 목록 조회"""
    # 실제로는 데이터베이스에서 조회
    reports = [
        {
            'id': 1,
            'stock': '삼성전자',
            'firm': '한국투자증권',
            'date': '2024-01-15',
            'opinion': '매수',
            'target_price': 85000
        },
        # ... 더 많은 리포트
    ]
    
    return jsonify({
        'success': True,
        'data': reports,
        'count': len(reports)
    })

@app.route('/api/reports/<int:report_id>', methods=['GET'])
def get_report_detail(report_id):
    """리포트 상세 조회"""
    # 실제로는 데이터베이스에서 조회
    report = {
        'id': report_id,
        'stock': '삼성전자',
        'firm': '한국투자증권',
        'date': '2024-01-15',
        'opinion': '매수',
        'target_price': 85000,
        'summary': 'AI가 생성한 요약 내용...',
        'key_points': [
            '메모리 반도체 가격 상승',
            '1분기 실적 개선 전망',
            'HBM3 수요 증가'
        ]
    }
    
    return jsonify({
        'success': True,
        'data': report
    })

@app.route('/api/analyze', methods=['POST'])
def analyze_report():
    """새 리포트 분석"""
    
    # 파일 업로드 받기
    if 'file' not in request.files:
        return jsonify({
            'success': False,
            'error': '파일이 없습니다'
        }), 400
    
    file = request.files['file']
    
    # 임시 저장
    temp_path = f"/tmp/{file.filename}"
    file.save(temp_path)
    
    # 분석 실행
    try:
        result = analyzer.safe_process(temp_path)
        
        return jsonify({
            'success': True,
            'data': result
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/search', methods=['GET'])
def search_reports():
    """리포트 검색"""
    query = request.args.get('q', '')
    stock = request.args.get('stock', '')
    
    # 검색 로직 (실제로는 데이터베이스 쿼리)
    results = []
    
    return jsonify({
        'success': True,
        'data': results,
        'query': query
    })

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