PROMPT_TEMPLATE = """
[Role] You are a {role}.
[Task] Please {task}.
[Context] {context}
[Format] Output in {format}.
[Constraints] {constraints}
[Example] {example}
"""

# Zero-shot prompt: classify sentiment without examples
prompt = """
Classify the sentiment of the following review as Positive or Negative:

Review: "The battery life is amazing, lasted 12 hours on a single charge!"
Sentiment:
"""

# Expected output: Positive

# Few-shot prompt: classify sentiment with examples
prompt = """
Classify the sentiment of each review as Positive or Negative.

Review: "Love the screen quality!" -> Positive
Review: "Terrible customer service." -> Negative
Review: "Decent product, nothing special." -> Neutral
Review: "Best purchase I have made this year!" -> Positive

Review: "The price is too high for what you get." ->
"""

# Expected output: Negative

# Chain-of-Thought prompt: solve a math problem step by step
prompt = """
Solve the following problem step by step.

Problem: A store buys a laptop for $800 and sells it for $1,050.
What is the profit margin as a percentage?

Step-by-step solution:
"""

# Expected output:
# Step 1: Calculate profit = 1050 - 800 = $250
# Step 2: Calculate margin = (250 / 800) * 100% = 31.25%
# Answer: The profit margin is 31.25%

# Define a system prompt for a technical interviewer role
system_prompt = """
You are a senior software engineer conducting a technical interview.
Rules:
1. Ask one question at a time
2. Wait for the candidate answer before asking the next
3. If the answer is wrong, give a hint instead of the correct answer
4. Cover topics: data structures, algorithms, system design
5. Rate each answer on a scale of 1-5
"""

user_message = "I am ready for the interview. Please start."

# The AI will behave as a structured interviewer,
# not a generic chatbot

# Prompt that enforces JSON output with a schema
prompt = """
Extract product information from the text below.
Output ONLY valid JSON matching this schema:

{
  "name": "string",
  "price": "number",
  "currency": "string",
  "features": ["string"]
}

Text: "The UltraWidget Pro costs $49.99 and comes with waterproof casing,
solar charging, and a 5-year warranty."

JSON:
"""

# Expected output:
# {
#   "name": "UltraWidget Pro",
#   "price": 49.99,
#   "currency": "USD",
#   "features": ["waterproof casing", "solar charging", "5-year warranty"]
# }

from pydantic import BaseModel
from typing import List

class ProductInfo(BaseModel):
    name: str
    price: float
    currency: str
    features: List[str]

# Validate AI output
try:
    product = ProductInfo.model_validate_json(ai_output)
    print(f"Valid: {product.name} - {product.currency}{product.price}")
except Exception as e:
    print(f"Invalid JSON: {e}")

# Bad: vague prompt
bad_prompt = "Analyze the electric vehicle market."

# Step 1: Add role
step1 = "You are a senior EV market analyst. Analyze the EV market."

# Step 2: Add structure
step2 = """You are a senior EV market analyst.
Analyze the 2025 global EV market with:
1. Three key trends
2. Two major risks
3. One investment recommendation"""

# Step 3: Add format constraint
step3 = """You are a senior EV market analyst with 15 years of experience.
Analyze the 2025 global EV market with:
1. Three key trends (present in a Markdown table)
2. Two major risks (with probability assessment)
3. One investment recommendation (with expected ROI range)

Output in Markdown format with clear headers."""

from string import Template
from pydantic import BaseModel
from typing import List, Optional

# Step 1: System Prompt - define the role
SYSTEM_PROMPT = """You are a senior product analyst with expertise in
market research, competitive analysis, and user experience evaluation.
You produce structured, data-driven product analysis reports.

Rules:
1. Always base analysis on concrete evidence and data points
2. Highlight both strengths and weaknesses objectively
3. Provide actionable recommendations with priority levels
4. Use specific numbers and metrics whenever possible
5. Format output as valid Markdown
"""

# Step 2: User Prompt template with all 6 elements
USER_PROMPT_TEMPLATE = Template("""
[Task] Analyze the following product and produce a comprehensive report.

[Product Info]
- Name: $product_name
- Category: $category
- Price: $price
- Target Users: $target_users

[Report Structure]
Please include the following sections:
1. Product Overview - Brief description and positioning
2. Strengths - Top 3 advantages with evidence
3. Weaknesses - Top 3 limitations with examples
4. Market Position - Competitive landscape analysis
5. Recommendations - Prioritized improvement suggestions

[Format] Output as Markdown with headers and a summary table.
[Constraints] Maximum 500 words. Be concise and specific.
[Example]
Product Overview
The ProductX is a mid-range smartphone targeting young professionals...

Summary Table
| Aspect | Rating | Key Insight |
|--------|--------|-------------|
| Design | 4/5 | Premium feel at mid-range price |
""")

# Step 3: Fill template and call API (pseudo-code)
def analyze_product(product_name: str, category: str,
                    price: str, target_users: str) -> str:
    user_prompt = USER_PROMPT_TEMPLATE.substitute(
        product_name=product_name,
        category=category,
        price=price,
        target_users=target_users
    )
    # In real usage, call your LLM API here
    # response = client.chat.completions.create(
    #     model="gpt-4",
    #     messages=[
    #         {"role": "system", "content": SYSTEM_PROMPT},
    #         {"role": "user", "content": user_prompt}
    #     ],
    #     temperature=0.3
    # )
    # return response.choices[0].message.content
    return user_prompt  # Return the prompt for demo

# Step 4: Use the template
result = analyze_product(
    product_name="EcoBike S3",
    category="Electric Bicycle",
    price="$1,299",
    target_users="Urban commuters aged 25-40"
)
print(result[:300] + "...")

# Task: Translate English to Chinese

# Bad prompt
prompt_v1 = "Translate this: The quick brown fox jumps over the lazy dog."

# Better prompt (add context and constraints)
prompt_v2 = "Translate the following English sentence to natural, fluent Chinese. Preserve the original tone and meaning.\n\nThe quick brown fox jumps over the lazy dog."

# Best prompt (add role, format, and example)
prompt_v3 = """You are a professional English-Chinese translator.

Rules:
- Translate to natural, idiomatic Chinese
- Preserve the original tone and nuance
- If the sentence has cultural references, add a brief note

Example:
EN: "Break a leg!"
CN: "Break a leg! (English idiom for wishing good luck before a performance)"

Now translate:
The quick brown fox jumps over the lazy dog."""

# TODO: Run each prompt through an LLM and compare outputs

# Few-shot sentiment classification
prompt = """Classify the sentiment of each review.

Review: "Absolutely love this product! Five stars!" -> Positive
Review: "Waste of money, broke after one week." -> Negative
Review: "It works as expected, nothing more." -> Neutral
Review: "The design is gorgeous but battery drains fast." -> ?

Now classify these 5 reviews:
1. "Best coffee maker I have ever owned!"
2. "Delivery was late and the box was damaged."
3. "Average quality for the price, decent but not impressive."
4. "Customer support resolved my issue in 10 minutes, amazing!"
5. "The instructions are confusing but the product works fine."
"""

# TODO: Run through an LLM and verify accuracy

# Technical interviewer system
SYSTEM_PROMPT = """You are a senior backend engineer conducting a coding interview.
Rules:
1. Ask one question at a time about Python/data structures/algorithms
2. Evaluate each answer: rate 1-5 and give brief feedback
3. If wrong, provide a hint, not the full answer
4. After 5 questions, give an overall assessment
5. Difficulty should gradually increase
"""

# Simulated multi-turn conversation
conversation = [
    {"role": "system", "content": SYSTEM_PROMPT},
    {"role": "user", "content": "I am ready for the interview."},
]

# TODO: Implement a loop that:
# 1. Sends conversation to LLM
# 2. Prints the interviewer question
# 3. Takes user input as answer
# 4. Appends both to conversation
# 5. Repeats until interview ends