# config.py
OPENAI_API_KEY = "your-api-key-here"

# config.py
# For local models via Ollama
LOCAL_BASE_URL = "http://localhost:11434/v1"

# config.py
GOOGLE_API_KEY = "your-api-key-here"

import openai
import google.generativeai as genai
import json
from typing import Dict, List, Any, Optional

class PromptEngineeringHelper:
    def __init__(self, model_type="openai", model_name="gpt-3.5-turbo", api_key=None, base_url=None):
        self.model_type = model_type
        self.model_name = model_name

        if model_type == "openai":
            self.client = openai.OpenAI(api_key=api_key)
        elif model_type == "local":
            # For local models via Ollama
            self.client = openai.OpenAI(api_key="ollama", base_url=base_url)
        elif model_type == "gemini":
            genai.configure(api_key=api_key)
            self.client = genai.GenerativeModel(model_name)

    def generate_response(self, system_prompt: str, user_prompt: str, temperature: float = 0.7) -> str:
        """Generate a response using the specified model and prompts."""

        if self.model_type in ["openai", "local"]:
            response = self.client.chat.completions.create(
                model=self.model_name,
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": user_prompt}
                ],
                temperature=temperature
            )
            return response.choices[0].message.content

        elif self.model_type == "gemini":
            # Combine system and user prompts for Gemini
            combined_prompt = f"{system_prompt}\n\n{user_prompt}"
            response = self.client.generate_content(combined_prompt)
            return response.text

    def few_shot_prompt(self, system_prompt: str, examples: List[Dict[str, str]],
                       user_input: str, temperature: float = 0.7) -> str:
        """Generate a response using few-shot prompting."""

        # Format the examples into the prompt
        examples_text = ""
        for example in examples:
            examples_text += f"Example:\nInput: {example['input']}\nOutput: {example['output']}\n\n"

        # Add the user input
        user_prompt = f"{examples_text}Now, please process this input:\n{user_input}"

        return self.generate_response(system_prompt, user_prompt, temperature)

    def chain_of_thought(self, system_prompt: str, steps: List[str],
                        user_input: str, temperature: float = 0.7) -> str:
        """Generate a response using chain-of-thought prompting."""

        # Format the steps into the prompt
        steps_text = "Please follow these steps:\n"
        for i, step in enumerate(steps, 1):
            steps_text += f"{i}. {step}\n"

        # Combine with user input
        user_prompt = f"{steps_text}\nHere is the information to process:\n{user_input}"

        return self.generate_response(system_prompt, user_prompt, temperature)

    def template_prompt(self, template: str, variables: Dict[str, str],
                       system_prompt: str = None, temperature: float = 0.7) -> str:
        """Generate a response using a template with variables."""

        # Replace variables in the template
        user_prompt = template
        for key, value in variables.items():
            user_prompt = user_prompt.replace(f"[{key}]", value)

        # Use default system prompt if none provided
        if system_prompt is None:
            system_prompt = "You are a helpful assistant that fills in templates accurately."

        return self.generate_response(system_prompt, user_prompt, temperature)

# email_assistant.py
from prompt_engineering_helper import PromptEngineeringHelper

# Initialize the helper with your preferred model
# For OpenAI:
# email_helper = PromptEngineeringHelper(model_type="openai", model_name="gpt-3.5-turbo", api_key="your-api-key")

# For local model (e.g., Gemma):
# email_helper = PromptEngineeringHelper(model_type="local", model_name="gemma", base_url="http://localhost:11434/v1")

# For Gemini:
# email_helper = PromptEngineeringHelper(model_type="gemini", model_name="gemini-pro", api_key="your-api-key")

# For this example, we'll use OpenAI
email_helper = PromptEngineeringHelper(model_type="openai", model_name="gpt-3.5-turbo", api_key="your-api-key")

def draft_email(recipient, purpose, key_points, tone="professional"):
    """Draft an email using role prompting."""

    system_prompt = f"You are a professional email writer with expertise in business communication. Write emails that are {tone} and effective."

    user_prompt = f"""
    Draft an email to {recipient} regarding {purpose}.

    Key points to include:
    {"\n".join(f'- {point}' for point in key_points)}

    The email should be concise, clear, and include a specific call to action.
    """

    return email_helper.generate_response(system_prompt, user_prompt)

# Example usage
recipient = "the project team"
purpose = "upcoming deadline for the Q3 report"
key_points = [
    "The deadline is this Friday at 17:00",
    "All sections must be completed",
    "Please review your work before submitting",
    "Contact me if you need additional resources"
]

email = draft_email(recipient, purpose, key_points)
print(email)

# meeting_notes_summarizer.py
from prompt_engineering_helper import PromptEngineeringHelper

# Initialize with your preferred model
notes_helper = PromptEngineeringHelper(model_type="openai", model_name="gpt-3.5-turbo", api_key="your-api-key")

def summarize_meeting_notes(notes, focus_areas=None):
    """Summarize meeting notes with optional focus areas."""

    system_prompt = "You are an expert at summarizing business meetings. Extract key information, decisions, and action items in a clear, structured format."

    user_prompt = f"Please summarize the following meeting notes:\n\n{notes}"

    if focus_areas:
        user_prompt += f"\n\nPlease focus particularly on these areas: {', '.join(focus_areas)}"

    return notes_helper.generate_response(system_prompt, user_prompt)

# Example usage
meeting_notes = """
Team meeting on June 15, 2023
Attendees: Sarah, John, Michael, Emily

Agenda:
1. Q2 Marketing Campaign Results
   - Sarah reported that the campaign exceeded targets by 15%
   - John suggested we should increase budget for next quarter
   - Decision: Budget will be increased by 10% for Q3

2. Product Launch Timeline
   - Michael mentioned that development is 2 weeks behind schedule
   - Emily proposed adding temporary resources to catch up
   - Decision: Hire 2 contractors for 4 weeks

3. Office Space Renovation
   - Planning to start renovation on July 1st
   - Will need to arrange temporary workspace for 3 weeks
   - Action: Sarah to contact building management

Next meeting: June 29, 2023
"""

summary = summarize_meeting_notes(meeting_notes, ["decisions", "action items"])
print(summary)

# data_analyst.py
from prompt_engineering_helper import PromptEngineeringHelper

# Initialize with your preferred model
data_helper = PromptEngineeringHelper(model_type="openai", model_name="gpt-3.5-turbo", api_key="your-api-key")

def analyze_sales_data(data_description, analysis_type="trends"):
    """Analyze sales data using chain-of-thought prompting."""

    system_prompt = "You are a senior business analyst with expertise in sales data analysis and reporting."

    steps = [
        "Identify the key metrics in the data",
        "Calculate relevant performance indicators",
        "Identify significant patterns or trends",
        "Draw meaningful insights from the analysis",
        "Provide actionable recommendations"
    ]

    user_prompt = f"Analyze the following sales data focusing on {analysis_type}:\n\n{data_description}"

    return data_helper.chain_of_thought(system_prompt, steps, user_prompt)

# Example usage
sales_data = """
Q2 2023 Sales Data by Region:
- North Region: $1.2M (12% increase from Q1)
- South Region: $980K (5% decrease from Q1)
- East Region: $1.5M (18% increase from Q1)
- West Region: $1.1M (8% increase from Q1)

Product Category Performance:
- Electronics: $1.8M (15% of total sales)
- Clothing: $1.3M (11% of total sales)
- Home & Garden: $1.7M (14% of total sales)

Notable Events:
- Launched new marketing campaign in North and East regions in mid-April
- South Region experienced supply chain issues in May
- Introduced 15 new products across all categories in April
"""

analysis = analyze_sales_data(sales_data, "regional performance differences")
print(analysis)

# document_generator.py
from prompt_engineering_helper import PromptEngineeringHelper

# Initialize with your preferred model
doc_helper = PromptEngineeringHelper(model_type="openai", model_name="gpt-3.5-turbo", api_key="your-api-key")

def generate_report(template, variables):
    """Generate a report using template-based prompting."""

    system_prompt = "You are a professional business report writer. Create accurate, well-structured reports based on the provided template and information."

    return doc_helper.template_prompt(template, variables, system_prompt)

# Example usage
report_template = """
# [Report Title]

**Date:** [Date]
**Prepared by:** [Author]
**Department:** [Department]

## Executive Summary
[Executive Summary]

## Key Findings
[Key Findings]

## Recommendations
[Recommendations]

## Next Steps
[Next Steps]
"""

variables = {
    "Report Title": "Q2 2023 Customer Satisfaction Analysis",
    "Date": "June 20, 2023",
    "Author": "Alex Brenner",
    "Department": "Customer Experience",
    "Executive Summary": "Customer satisfaction increased by 8% compared to Q1, driven by improvements in product quality and customer service response times.",
    "Key Findings": "- Product quality scores increased from 4.2 to 4.5/5\n- Customer service response times decreased by 30%\n- Net Promoter Score improved from 45 to 53",
    "Recommendations": "- Continue investing in product quality improvements\n- Expand customer service team during peak hours\n- Implement customer feedback loop for product development",
    "Next Steps": "- Schedule follow-up survey in Q3\n- Present findings to executive team\n- Develop action plan for Q4"
}

report = generate_report(report_template, variables)
print(report)

# prompt_evaluator.py
from prompt_engineering_helper import PromptEngineeringHelper

class PromptEvaluator:
    def __init__(self, model_type, model_name, api_key=None, base_url=None):
        self.helper = PromptEngineeringHelper(model_type, model_name, api_key, base_url)

    def evaluate_prompt(self, system_prompt, user_prompt, expected_aspects):
        """Evaluate a prompt based on expected aspects."""

        response = self.helper.generate_response(system_prompt, user_prompt)

        # Create evaluation prompt
        eval_system = "You are an expert evaluator of AI-generated content. Rate how well the response addresses the specified aspects on a scale of 1-5."

        eval_user = f"""
        Response to evaluate:
        {response}

        Aspects to evaluate:
        {"\n".join(f'- {aspect}' for aspect in expected_aspects)}

        Provide a rating (1-5) for each aspect and brief justification.
        """

        evaluation = self.helper.generate_response(eval_system, eval_user)

        return {
            "response": response,
            "evaluation": evaluation
        }

    def compare_models(self, system_prompt, user_prompt, models):
        """Compare the same prompt across different models."""

        results = {}

        for model_name, model_config in models.items():
            helper = PromptEngineeringHelper(
                model_type=model_config["type"],
                model_name=model_config["name"],
                api_key=model_config.get("api_key"),
                base_url=model_config.get("base_url")
            )

            response = helper.generate_response(system_prompt, user_prompt)
            results[model_name] = response

        return results

# Example usage
evaluator = PromptEvaluator("openai", "gpt-3.5-turbo", api_key="your-api-key")

system_prompt = "You are a professional business email writer."
user_prompt = "Draft a polite but firm email to a client who is late on their payment."
expected_aspects = ["Professional tone", "Clarity of payment request", "Maintaining good client relationship"]

evaluation = evaluator.evaluate_prompt(system_prompt, user_prompt, expected_aspects)
print("Response:", evaluation["response"])
print("\nEvaluation:", evaluation["evaluation"])

# prompt_ab_test.py
from prompt_engineering_helper import PromptEngineeringHelper

def ab_test_prompts(prompt_variants, test_cases):
    """Compare multiple prompt variants across test cases."""

    results = {}

    for variant_name, prompt_config in prompt_variants.items():
        helper = PromptEngineeringHelper(
            model_type=prompt_config["model_type"],
            model_name=prompt_config["model_name"],
            api_key=prompt_config.get("api_key"),
            base_url=prompt_config.get("base_url")
        )

        variant_results = []

        for test_case in test_cases:
            response = helper.generate_response(
                prompt_config["system_prompt"],
                test_case["user_prompt"]
            )

            variant_results.append({
                "test_case": test_case["name"],
                "response": response
            })

        results[variant_name] = variant_results

    return results

# Example usage
prompt_variants = {
    "direct_approach": {
        "model_type": "openai",
        "model_name": "gpt-3.5-turbo",
        "api_key": "your-api-key",
        "system_prompt": "You are a direct and concise business communicator."
    },
    "detailed_approach": {
        "model_type": "openai",
        "model_name": "gpt-3.5-turbo",
        "api_key": "your-api-key",
        "system_prompt": "You are a thorough business communicator who provides detailed explanations and context."
    }
}

test_cases = [
    {
        "name": "project_update_request",
        "user_prompt": "Request a status update on the Q3 marketing campaign from the team lead."
    },
    {
        "name": "meeting_scheduling",
        "user_prompt": "Schedule a meeting with the finance team to review the budget."
    }
]

ab_results = ab_test_prompts(prompt_variants, test_cases)

# Print results
for variant_name, results in ab_results.items():
    print(f"\n=== {variant_name.upper()} ===")
    for result in results:
        print(f"\nTest Case: {result['test_case']}")
        print(f"Response: {result['response'][:200]}...")  # Show first 200 characters