import anthropic
import os

client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

def generate_with_reflection(task: str, context: str, quality_criteria: list):
    """
    Generates an output, critiques it, and returns an improved version.
    This is the self-critique loop pattern.
    """

    # Step 1: Initial generation
    print("[Agent] Generating initial output...")
    initial_response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=2000,
        messages=[{
            "role": "user",
            "content": f"Context: {context}\n\nTask: {task}\n\nGenerate a complete, high-quality response."
        }]
    )
    initial_output = initial_response.content[0].text

    # Step 2: Self-critique
    criteria_text = "\n".join([f"- {c}" for c in quality_criteria])
    print("[Agent] Critiquing initial output...")
    critique_response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1500,
        messages=[{
            "role": "user",
            "content": f"""You are a quality reviewer. Critique the following output against these criteria:

QUALITY CRITERIA:
{criteria_text}

OUTPUT TO REVIEW:
{initial_output}

Provide:
1. A score (1-10) for each criterion
2. Specific issues found (be precise, not general)
3. A list of improvements needed
4. Overall quality verdict: ACCEPTABLE (8+) or NEEDS_REVISION"""
        }]
    )
    critique = critique_response.content[0].text

    # Step 3: Check if revision needed
    if "NEEDS_REVISION" in critique:
        print("[Agent] Revising based on critique...")
        final_response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=2000,
            messages=[{
                "role": "user",
                "content": f"""Improve the following output based on this critique.

ORIGINAL OUTPUT:
{initial_output}

CRITIQUE:
{critique}

Produce a revised version that addresses all issues. Do not explain the changes — just produce the improved output."""
            }]
        )
        return final_response.content[0].text, critique
    else:
        print("[Agent] Output meets quality criteria.")
        return initial_output, critique

# Example usage for a Pakistani SEO audit agent
if __name__ == "__main__":
    result, critique = generate_with_reflection(
        task="Write an SEO audit summary for a Karachi restaurant website that has no meta descriptions, slow mobile speed (LCP 4.2s), and no schema markup.",
        context="The client is a restaurant owner in DHA Phase 5, Karachi. They have basic digital literacy.",
        quality_criteria=[
            "Technical issues explained in plain Urdu/English, no jargon",
            "Each issue must include a severity rating (Critical/High/Medium/Low)",
            "Each issue must include a specific action step the client can take",
            "Report must include PKR cost estimates for fixes",
            "Maximum 500 words — restaurant owner has limited time"
        ]
    )
    print("\nFINAL OUTPUT:")
    print(result)

def dual_agent_review(task: str, content: str):
    """
    Agent A writes, Agent B critiques from a different persona.
    """

    # Agent B's critique persona — deliberately adversarial
    critique = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1000,
        messages=[{
            "role": "user",
            "content": f"""You are a senior quality assurance reviewer.
Your job is to find every flaw in the following content.
Be thorough, specific, and demanding.

TASK THE CONTENT WAS SUPPOSED TO ACCOMPLISH:
{task}

CONTENT TO REVIEW:
{content}

List every issue you find, ordered by severity. Be precise."""
        }]
    )
    return critique.content[0].text

SEO REPORT QUALITY CRITERIA (Pakistan Context):
1. All issues ranked by estimated monthly revenue impact (PKR)
2. Technical jargon explained in simple English (or Romanized Urdu)
3. Each recommendation must include: "How to fix" + "Time to fix" + "Cost estimate"
4. Priority issues shown first — client must know what to do Monday morning
5. No more than 5 priority issues per report (decision fatigue)
6. Positive findings must come first (builds client confidence before bad news)

import anthropic
import os

client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

def run_dual_agent_reflection(
    task: str,
    context: str,
    quality_criteria: list,
    max_iterations: int = 3
) -> str:
    """Run a dual-agent reflection loop: Generator → Critic → Revise."""

    current_output = None

    for iteration in range(max_iterations):
        # AGENT 1: Generator
        if current_output is None:
            gen_prompt = f"Task: {task}\n\nContext: {context}\n\nGenerate the output:"
        else:
            gen_prompt = f"Task: {task}\n\nContext: {context}\n\nPrevious version:\n{current_output}\n\nFeedback:\n{feedback}\n\nRevised version:"

        gen_response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=800,
            messages=[{"role": "user", "content": gen_prompt}]
        )
        current_output = gen_response.content[0].text

        # AGENT 2: Critic
        criteria_str = "\n".join(f"{i+1}. {c}" for i, c in enumerate(quality_criteria))
        critic_prompt = f"""Evaluate this output against each criterion.
Be specific about what fails and why.

CRITERIA:
{criteria_str}

OUTPUT TO EVALUATE:
{current_output}

For each criterion: PASS or FAIL with specific reason.
If ALL pass, write: ALL_CRITERIA_PASSED"""

        critic_response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=500,
            messages=[{"role": "user", "content": critic_prompt}]
        )
        feedback = critic_response.content[0].text

        if "ALL_CRITERIA_PASSED" in feedback:
            print(f"Quality achieved in {iteration + 1} iteration(s)")
            return current_output

    print(f"Max iterations ({max_iterations}) reached. Returning best version.")
    return current_output

# Example: SEO report for a Karachi business
result = run_dual_agent_reflection(
    task="Write a 3-priority SEO report for a Karachi restaurant",
    context="Website: biryanihouse.pk. Issues: LCP 8.2s, no Google Business listing, 0 backlinks.",
    quality_criteria=[
        "Each issue has PKR revenue impact estimate",
        "No unexplained technical jargon",
        "Issues ranked by priority (highest first)",
        "Each issue has: how to fix + time + cost",
        "Report under 300 words"
    ]
)
print(result)