from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_openai import ChatOpenAI
from langchain.tools import tool
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder

# Writer 에이전트용 LLM 설정
writer_llm = ChatOpenAI(
    model="gpt-4o",
    temperature=0.7  # 창의성을 위해 약간 높게 설정
)

# Writer 에이전트 시스템 프롬프트
WRITER_SYSTEM_PROMPT = """
당신은 전문 콘텐츠 작성 에이전트입니다.
주어진 주제와 요구사항을 바탕으로 고품질 콘텐츠를 생성하세요.

규칙:
1. 명확하고 구조화된 내용을 작성하세요
2. 사실에 기반한 정보만 포함하세요
3. 독자의 수준에 맞는 언어를 사용하세요
4. 작성 완료 후 [DRAFT_COMPLETE] 태그를 붙이세요
"""

# Writer 에이전트가 사용할 도구들
@tool
def search_web(query: str) -> str:
    """웹에서 최신 정보를 검색합니다."""
    # 실제 구현에서는 검색 API 연동
    return f"'{query}'에 대한 검색 결과..."

@tool
def get_template(content_type: str) -> str:
    """콘텐츠 유형에 맞는 템플릿을 가져옵니다."""
    templates = {
        "blog": "# 제목\n## 서론\n## 본론\n## 결론",
        "report": "# 보고서\n## 요약\n## 분석\n## 권고사항",
        "code": "# 코드 설명\n## 목적\n## 구현\n## 사용법"
    }
    return templates.get(content_type, "기본 템플릿")

writer_tools = [search_web, get_template]

# Writer 에이전트 프롬프트 구성
writer_prompt = ChatPromptTemplate.from_messages([
    ("system", WRITER_SYSTEM_PROMPT),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])

# Writer 에이전트 생성
writer_agent = create_openai_tools_agent(
    llm=writer_llm,
    tools=writer_tools,
    prompt=writer_prompt
)

writer_executor = AgentExecutor(
    agent=writer_agent,
    tools=writer_tools,
    verbose=True,
    max_iterations=5
)

from pydantic import BaseModel
from typing import Literal, List
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate

# 리뷰 결과 스키마 정의
class ReviewResult(BaseModel):
    status: Literal["APPROVED", "REVISION_NEEDED", "REJECTED"]
    score: float  # 0.0 ~ 1.0
    issues: List[str]  # 발견된 문제점들
    suggestions: List[str]  # 개선 제안사항들
    critical_errors: List[str]  # 치명적 오류 (있으면 REJECTED)

# Reviewer 에이전트용 LLM (낮은 temperature로 일관성 확보)
reviewer_llm = ChatOpenAI(
    model="gpt-4o",
    temperature=0.1  # 일관된 평가를 위해 낮게 설정
).with_structured_output(ReviewResult)

REVIEWER_SYSTEM_PROMPT = """
당신은 엄격하고 공정한 콘텐츠 검토 에이전트입니다.
주어진 콘텐츠를 다음 기준으로 평가하세요:

평가 기준:
1. 사실 정확성 (30점): 정보의 정확성과 출처 신뢰성
2. 완성도 (25점): 요구사항 충족 여부
3. 논리 일관성 (20점): 내용의 흐름과 구조
4. 가독성 (15점): 명확성과 이해도
5. 규정 준수 (10점): 법적/윤리적 기준

판정 기준:
- APPROVED: 점수 0.8 이상, 치명적 오류 없음
- REVISION_NEEDED: 점수 0.5~0.8, 수정 가능한 문제 있음
- REJECTED: 점수 0.5 미만 또는 치명적 오류 존재

반드시 구체적인 피드백을 제공하세요.
"""

reviewer_prompt = ChatPromptTemplate.from_messages([
    ("system", REVIEWER_SYSTEM_PROMPT),
    ("human", """
검토 대상 콘텐츠:
{content}

원본 요구사항:
{requirements}

위 콘텐츠를 평가하고 구조화된 피드백을 제공하세요.
""")
])

# Reviewer 체인 구성
reviewer_chain = reviewer_prompt | reviewer_llm

# 실제 리뷰 실행
def review_content(content: str, requirements: str) -> ReviewResult:
    result = reviewer_chain.invoke({
        "content": content,
        "requirements": requirements
    })
    return result

from typing import Dict, Any, List
from enum import Enum
import asyncio

class PublishChannel(Enum):
    BLOG = "blog"
    GITHUB = "github"
    SLACK = "slack"
    EMAIL = "email"
    DATABASE = "database"
    API = "api"

class PublisherAgent:
    def __init__(self, llm, available_channels: List[PublishChannel]):
        self.llm = llm
        self.available_channels = available_channels
        self.publish_history = []
    
    async def prepare_content(
        self, 
        content: str, 
        target_channel: PublishChannel
    ) -> Dict[str, Any]:
        """채널에 맞게 콘텐츠 포맷 변환"""
        
        format_prompts = {
            PublishChannel.BLOG: "HTML 형식으로 변환, SEO 메타태그 추가",
            PublishChannel.GITHUB: "마크다운 형식 유지, README 구조 적용",
            PublishChannel.SLACK: "Slack Block Kit 형식으로 변환",
            PublishChannel.EMAIL: "HTML 이메일 템플릿 적용",
        }
        
        prompt = format_prompts.get(target_channel, "원본 형식 유지")
        
        # LLM으로 포맷 변환
        formatted = await self.llm.ainvoke(
            f"다음 콘텐츠를 {prompt}:\n\n{content}"
        )
        
        return {
            "content": formatted.content,
            "channel": target_channel.value,
            "metadata": self._generate_metadata(content, target_channel)
        }
    
    def _generate_metadata(
        self, 
        content: str, 
        channel: PublishChannel
    ) -> Dict:
        """메타데이터 자동 생성"""
        import datetime
        return {
            "published_at": datetime.datetime.now().isoformat(),
            "channel": channel.value,
            "version": len(self.publish_history) + 1,
            "word_count": len(content.split()),
            "status": "published"
        }
    
    async def publish(
        self, 
        content: str, 
        channels: List[PublishChannel],
        schedule_time: str = None
    ) -> Dict[str, Any]:
        """실제 배포 실행"""
        
        results = {}
        
        # 여러 채널에 동시 배포 (비동기 처리)
        tasks = []
        for channel in channels:
            if channel in self.available_channels:
                task = self._publish_to_channel(content, channel)
                tasks.append((channel, task))
        
        # 병렬 실행
        for channel, task in tasks:
            try:
                result = await task
                results[channel.value] = {
                    "status": "success",
                    "result": result
                }
            except Exception as e:
                results[channel.value] = {
                    "status": "failed",
                    "error": str(e)
                }
        
        # 배포 이력 기록
        self.publish_history.append({
            "channels": [c.value for c in channels],
            "results": results
        })
        
        return results
    
    async def _publish_to_channel(
        self, 
        content: str, 
        channel: PublishChannel
    ) -> str:
        """채널별 실제 배포 로직"""
        prepared = await self.prepare_content(content, channel)
        
        # 실제 구현에서는 각 채널 API 호출
        channel_apis = {
            PublishChannel.BLOG: self._post_to_blog,
            PublishChannel.GITHUB: self._commit_to_github,
            PublishChannel.SLACK: self._send_to_slack,
        }
        
        api_func = channel_apis.get(channel)
        if api_func:
            return await api_func(prepared)
        
        return f"{channel.value}에 배포 완료"

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

# 전체 워크플로우 상태 정의
class WorkflowState(TypedDict):
    # 입력
    task: str
    requirements: str
    
    # 중간 결과물
    draft: str
    review_result: dict
    
    # 제어 변수
    iteration_count: int
    max_iterations: int
    
    # 최종 결과
    final_content: str
    publish_results: dict
    
    # 메시지 히스토리
    messages: Annotated[list, operator.add]

# 각 노드 함수 정의
def writer_node(state: WorkflowState) -> WorkflowState:
    """Writer 에이전트 실행"""
    
    # 첫 번째 실행인지, 수정 요청인지 확인
    if state["iteration_count"] == 0:
        prompt = f"""
        작업: {state['task']}
        요구사항: {state['requirements']}
        
        위 내용을 바탕으로 고품질 초안을 작성하세요.
        """
    else:
        # 이전 리뷰 피드백 반영
        feedback = state["review_result"].get("suggestions", [])
        issues = state["review_result"].get("issues", [])
        
        prompt = f"""
        이전 초안: {state['draft']}
        
        발견된 문제점: {issues}
        개선 제안: {feedback}
        
        위 피드백을 반영하여 초안을 개선하세요.
        """
    
    # Writer 에이전트 실행
    result = writer_executor.invoke({"input": prompt})
    
    return {
        **state,
        "draft": result["output"],
        "iteration_count": state["iteration_count"] + 1,
        "messages": [f"[Writer] 초안 생성 완료 (반복 {state['iteration_count'] + 1}회)"]
    }

def reviewer_node(state: WorkflowState) -> WorkflowState:
    """Reviewer 에이전트 실행"""
    
    review = review_content(
        content=state["draft"],
        requirements=state["requirements"]
    )
    
    return {
        **state,
        "review_result": review.dict(),
        "messages": [f"[Reviewer] 검토 완료: {review.status} (점수: {review.score:.2f})"]
    }

def publisher_node(state: WorkflowState) -> WorkflowState:
    """Publisher 에이전트 실행"""
    
    import asyncio
    publisher = PublisherAgent(
        llm=ChatOpenAI(model="gpt-4o"),
        available_channels=[PublishChannel.BLOG, PublishChannel.DATABASE]
    )
    
    results = asyncio.run(publisher.publish(
        content=state["draft"],
        channels=[PublishChannel.BLOG, PublishChannel.DATABASE]
    ))
    
    return {
        **state,
        "final_content": state["draft"],
        "publish_results": results,
        "messages": [f"[Publisher] 배포 완료: {list(results.keys())}"]
    }

# 라우팅 로직 (핵심!)
def should_continue(state: WorkflowState) -> str:
    """리뷰 결과에 따라 다음 단계 결정"""
    
    review = state["review_result"]
    status = review.get("status")
    iteration = state["iteration_count"]
    max_iter = state["max_iterations"]
    
    if status == "APPROVED":
        return "publish"  # 승인 → 배포
    elif status == "REJECTED":
        return "end"  # 거절 → 종료 (사람 개입 필요)
    elif iteration >= max_iter:
        return "end"  # 최대 반복 초과 → 종료
    else:
        return "revise"  # 수정 필요 → Writer로 돌아가기

# LangGraph 워크플로우 구성
workflow = StateGraph(WorkflowState)

# 노드 추가
workflow.add_node("writer", writer_node)
workflow.add_node("reviewer", reviewer_node)
workflow.add_node("publisher", publisher_node)

# 엣지 연결
workflow.set_entry_point("writer")
workflow.add_edge("writer", "reviewer")

# 조건부 엣지 (핵심 분기 로직)
workflow.add_conditional_edges(
    "reviewer",
    should_continue,
    {
        "publish": "publisher",
        "revise": "writer",
        "end": END
    }
)
workflow.add_edge("publisher", END)

# 컴파일
app = workflow.compile()

# 실행
result = app.invoke({
    "task": "AI 에이전트 협업에 관한 기술 블로그 포스트 작성",
    "requirements": "1000자 이상, 코드 예시 포함, 초보자도 이해 가능",
    "draft": "",
    "review_result": {},
    "iteration_count": 0,
    "max_iterations": 3,
    "final_content": "",
    "publish_results": {},
    "messages": []
})

# 멀티 Reviewer 패턴
class MultiReviewerSystem:
    def __init__(self):
        # 각 전문 분야별 Reviewer
        self.reviewers = {
            "factual": FactualReviewer(),      # 사실 정확성 전문
            "security": SecurityReviewer(),    # 보안 전문
            "style": StyleReviewer(),          # 스타일/가독성 전문
            "seo": SEOReviewer(),              # SEO 최적화 전문
        }
    
    async def parallel_review(self, content: str) -> dict:
        """모든 Reviewer를 병렬로 실행"""
        import asyncio
        
        tasks = {
            name: reviewer.review(content)
            for name, reviewer in self.reviewers.items()
        }
        
        results = await asyncio.gather(*tasks.values())
        
        # 결과 통합
        combined_result = {
            name: result
            for name, result in zip(tasks.keys(), results)
        }
        
        # 최종 판정: 모든 Reviewer가 통과해야 APPROVED
        all_approved = all(
            r.status == "APPROVED" 
            for r in combined_result.values()
        )
        
        return {
            "final_status": "APPROVED" if all_approved else "REVISION_NEEDED",
            "detailed_reviews": combined_result,
            "aggregated_issues": self._aggregate_issues(combined_result)
        }
    
    def _aggregate_issues(self, reviews: dict) -> list:
        """모든 리뷰의 이슈를 통합"""
        all_issues = []
        for reviewer_name, review in reviews.items():
            for issue in review.issues:
                all_issues.append(f"[{reviewer_name}] {issue}")
        return all_issues

from langchain.memory import ConversationSummaryMemory
from langchain_openai import ChatOpenAI

class WriterWithMemory:
    def __init__(self):
        self.llm = ChatOpenAI(model="gpt-4o", temperature=0.7)
        
        # 피드백 메모리 - 이전 리뷰 내용을 요약해서 기억
        self.feedback_memory = ConversationSummaryMemory(
            llm=ChatOpenAI(model="gpt-4o-mini"),
            memory_key="feedback_history",
            return_messages=True
        )
        
        # 스타일 가이드 메모리 - 승인된 콘텐츠의 패턴 학습
        self.style_memory = []
    
    def write(self, task: str) -> str:
        # 이전 피드백 히스토리 가져오기
        history = self.feedback_memory.load_memory_variables({})
        
        # 승인된 스타일 패턴 참고
        style_examples = "\n".join(self.style_memory[-3:])  # 최근 3개
        
        prompt = f"""
        작업: {task}
        
        이전 피드백 히스토리:
        {history.get('feedback_history', '없음')}
        
        승인된 콘텐츠 스타일 예시:
        {style_examples if style_examples else '없음'}
        
        위 내용을 참고하여 이전 실수를 반복하지 않도록 주의하며 작성하세요.
        """
        
        result = self.llm.invoke(prompt)
        return result.content
    
    def update_memory(self, draft: str, review: dict):
        """리뷰 결과를 메모리에 저장"""
        feedback_text = f"작성한 내용에 대한 피드백: {review['issues']}"
        self.feedback_memory.save_context(
            {"input": draft[:200]},  # 초안 요약
            {"output": feedback_text}
        )
        
        # 승인된 경우 스타일 메모리에 추가
        if review["status"] == "APPROVED":
            self.style_memory.append(draft[:500])  # 승인된 스타일 저장

import time
import logging
from dataclasses import dataclass, field
from typing import List, Optional
from datetime import datetime

@dataclass
class AgentMetrics:
    """에이전트 성능 지표"""
    agent_name: str
    start_time: float = field(default_factory=time.time)
    end_time: Optional[float] = None
    success: bool = False
    error_message: Optional[str] = None
    token_usage: int = 0
    
    @property
    def duration(self) -> float:
        if self.end_time:
            return self.end_time - self.start_time
        return 0

class WorkflowMonitor:
    """전체 워크플로우 모니터링"""
    
    def __init__(self):
        self.sessions = {}
        self.logger = logging.getLogger("WorkflowMonitor")
    
    def start_session(self, session_id: str, task: str):
        self.sessions[session_id] = {
            "task": task,
            "start_time": datetime.now().isoformat(),
            "metrics": [],
            "iteration_count": 0,
            "final_status": None
        }
        self.logger.info(f"세션 시작: {session_id}")
    
    def record_agent_run(
        self, 
        session_id: str, 
        agent_name: str,
        duration: float,
        success: bool,
        token_usage: int = 0
    ):
        if session_id not in self.sessions:
            return
        
        self.sessions[session_id]["metrics"].append({
            "agent": agent_name,
            "duration": duration,
            "success": success,
            "token_usage": token_usage,
            "timestamp": datetime.now().isoformat()
        })
        
        if agent_name == "writer":
            self.sessions[session_id]["iteration_count"] += 1
        
        self.logger.info(
            f"[{session_id}] {agent_name} 완료: "
            f"{'성공' if success else '실패'}, "
            f"{duration:.2f}초, {token_usage}토큰"
        )
    
    def end_session(self, session_id: str, final_status: str):
        if session_id not in self.sessions:
            return
        
        session = self.sessions[session_id]
        session["final_status"] = final_status
        session["end_time"] = datetime.now().isoformat()
        
        # 성능 요약 계산
        total_duration = sum(m["duration"] for m in session["metrics"])
        total_tokens = sum(m["token_usage"] for m in session["metrics"])
        
        summary = {
            "session_id": session_id,
            "final_status": final_status,
            "total_duration": total_duration,
            "total_tokens": total_tokens,
            "iteration_count": session["iteration_count"],
            "approved": final_status == "APPROVED"
        }
        
        self.logger.info(f"세션 완료: {summary}")
        return summary
    
    def get_aggregate_stats(self) -> dict:
        """전체 세션 통계"""
        completed = [
            s for s in self.sessions.values() 
            if s.get("final_status")
        ]
        
        if not completed:
            return {}
        
        approval_rate = sum(
            1 for s in completed 
            if s["final_status"] == "APPROVED"
        ) / len(completed)
        
        avg_iterations = sum(
            s["iteration_count"] for s in completed
        ) / len(completed)
        
        return {
            "total_sessions": len(completed),
            "approval_rate": f"{approval_rate:.1%}",
            "avg_iterations": f"{avg_iterations:.1f}",
            "success_rate": f"{approval_rate:.1%}"
        }

# 사용 예시
monitor = WorkflowMonitor()
monitor.start_session("session_001", "블로그 포스트 작성")
# ... 에이전트 실행 ...
monitor.record_agent_run("session_001", "writer", 12.3, True, 850)
monitor.record_agent_run("session_001", "reviewer", 8.7, True, 420)
monitor.record_agent_run("session_001", "publisher", 3.2, True, 150)
stats = monitor.end_session("session_001", "APPROVED")
print(monitor.get_aggregate_stats())

from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o", temperature=0.7)

# Writer 에이전트 정의
writer = Agent(
    role="콘텐츠 작성 전문가",
    goal="고품질의 정확하고 매력적인 콘텐츠를 작성한다",
    backstory="""
    당신은 10년 경력의 전문 작가입니다.
    다양한 분야의 기술 문서와 마케팅 콘텐츠를 작성해왔으며,
    독자의 눈높이에 맞는 명확한 글쓰기로 유명합니다.
    """,
    llm=llm,
    verbose=True
)

# Reviewer 에이전트 정의
reviewer = Agent(
    role="콘텐츠 품질 검토 전문가",
    goal="콘텐츠의 정확성, 완성도, 품질을 엄격하게 검토한다",
    backstory="""
    당신은 출판사 편집장 출신의 품질 관리 전문가입니다.
    사실 확인, 논리적 일관성, 가독성을 꼼꼼하게 검토하며
    구체적이고 실행 가능한 피드백을 제공합니다.
    """,
    llm=ChatOpenAI(model="gpt-4o", temperature=0.1),
    verbose=True
)

# Publisher 에이전트 정의
publisher = Agent(
    role="콘텐츠 배포 전문가",
    goal="검토 완료된 콘텐츠를 최적의 형태로 배포한다",
    backstory="""
    당신은 디지털 마케팅 전문가로, 다양한 플랫폼에
    콘텐츠를 최적화하여 배포하는 전문가입니다.
    SEO, 포맷 변환, 멀티채널 배포에 능숙합니다.
    """,
    llm=ChatOpenAI(model="gpt-4o-mini", temperature=0.3),
    verbose=True
)

# 태스크 정의
write_task = Task(
    description="""
    주제: {topic}
    요구사항: {requirements}
    
    위 주제로 고품질 콘텐츠를 작성하세요.
    반드시 사실에 기반하고, 구조적으로 작성하세요.
    """,
    agent=writer,
    expected_output="완성된 콘텐츠 초안 (마크다운 형식)"
)

review_task = Task(
    description="""
    Writer가 작성한 콘텐츠를 검토하세요.
    
    검토 항목:
    1. 사실 정확성
    2. 논리적 일관성
    3. 완성도
    4. 가독성
    
    문제가 있으면 구체적인 수정 사항을 제시하고,
    문제가 없으면 APPROVED 판정을 내리세요.
    """,
    agent=reviewer,
    expected_output="검토 결과 보고서 (상태, 점수, 피드백 포함)"
)

publish_task = Task(
    description="""
    검토 완료된 콘텐츠를 배포 준비하세요.
    
    작업:
    1. HTML 형식으로 변환
    2. SEO 메타태그 추가
    3. 소셜 미디어용 요약본 생성
    4. 배포 체크리스트 완성
    """,
    agent=publisher,
    expected_output="배포 준비 완료된 콘텐츠 패키지"
)

# Crew 구성 및 실행
crew = Crew(
    agents=[writer, reviewer, publisher],
    tasks=[write_task, review_task, publish_task],
    process=Process.sequential,  # 순차 처리
    verbose=True
)

result = crew.kickoff(inputs={
    "topic": "AI 에이전트 협업 시스템의 미래",
    "requirements": "1500자 이상, 기술적 정확성, 초보자 친화적"
})

print(result)