# config.py
OPENAI_API_KEY = "ihr-api-schluessel-hier"

# config.py
# Für lokale Modelle über Ollama
LOCAL_BASE_URL = "http://localhost:11434/v1"

# config.py
GOOGLE_API_KEY = "ihr-api-schluessel-hier"

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":
            # Für lokale Modelle über 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:
        """Generiert eine Antwort mit dem angegebenen Modell und den angegebenen 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":
            # Kombinieren Sie System- und Benutzer-Prompts für 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:
        """Generiert eine Antwort mit Few-Shot-Prompting."""

        # Formatieren Sie die Beispiele in den Prompt
        examples_text = ""
        for example in examples:
            examples_text += f"Beispiel:\nEingabe: {example['input']}\nAusgabe: {example['output']}\n\n"

        # Fügen Sie die Benutzereingabe hinzu
        user_prompt = f"{examples_text}Bitte verarbeiten Sie nun diese Eingabe:\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:
        """Generiert eine Antwort mit Chain-of-Thought-Prompting."""

        # Formatieren Sie die Schritte in den Prompt
        steps_text = "Bitte befolgen Sie diese Schritte:\n"
        for i, step in enumerate(steps, 1):
            steps_text += f"{i}. {step}\n"

        # Kombinieren Sie mit der Benutzereingabe
        user_prompt = f"{steps_text}\nHier sind die zu verarbeitenden Informationen:\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:
        """Generiert eine Antwort mit einer Vorlage mit Variablen."""

        # Ersetzen Sie Variablen in der Vorlage
        user_prompt = template
        for key, value in variables.items():
            user_prompt = user_prompt.replace(f"[{key}]", value)

        # Verwenden Sie den Standard-System-Prompt, wenn keiner angegeben ist
        if system_prompt is None:
            system_prompt = "Sie sind ein hilfreicher Assistent, der Vorlagen genau ausfüllt."

        return self.generate_response(system_prompt, user_prompt, temperature)

# email_assistant.py
from prompt_engineering_helper import PromptEngineeringHelper

# Initialisieren Sie den Helfer mit Ihrem bevorzugten Modell
# Für OpenAI:
# email_helper = PromptEngineeringHelper(model_type="openai", model_name="gpt-3.5-turbo", api_key="ihr-api-schluessel")

# Für lokales Modell (z. B. Gemma):
# email_helper = PromptEngineeringHelper(model_type="local", model_name="gemma", base_url="http://localhost:11434/v1")

# Für Gemini:
# email_helper = PromptEngineeringHelper(model_type="gemini", model_name="gemini-pro", api_key="ihr-api-schluessel")

# Für dieses Beispiel verwenden wir OpenAI
email_helper = PromptEngineeringHelper(model_type="openai", model_name="gpt-3.5-turbo", api_key="ihr-api-schluessel")

def draft_email(recipient, purpose, key_points, tone="professional"):
    """Entwerfen Sie eine E-Mail mit Rollen-Prompting."""

    system_prompt = f"Sie sind ein professioneller E-Mail-Verfasser mit Fachkenntnissen in der Geschäftskommunikation. Schreiben Sie E-Mails, die {tone} und effektiv sind."

    user_prompt = f"""
    Entwerfen Sie eine E-Mail an {recipient} bezüglich {purpose}.

    Wichtige Punkte, die enthalten sein sollen:
    {"\n".join(f'- {point}' for point in key_points)}

    Die E-Mail sollte prägnant, klar und eine spezifische Handlungsaufforderung enthalten.
    """

    return email_helper.generate_response(system_prompt, user_prompt)

# Beispielverwendung
recipient = "das Projektteam"
purpose = "bevorstehender Abgabetermin für den Q3-Bericht"
key_points = [
    "Der Abgabetermin ist diesen Freitag um 17:00 Uhr",
    "Alle Abschnitte müssen ausgefüllt sein",
    "Bitte überprüfen Sie Ihre Arbeit vor dem Einreichen",
    "Kontaktieren Sie mich, wenn Sie zusätzliche Ressourcen benötigen"
]

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

# meeting_notes_summarizer.py
from prompt_engineering_helper import PromptEngineeringHelper

# Initialisieren Sie mit Ihrem bevorzugten Modell
notes_helper = PromptEngineeringHelper(model_type="openai", model_name="gpt-3.5-turbo", api_key="ihr-api-schluessel")

def summarize_meeting_notes(notes, focus_areas=None):
    """Fassen Sie Besprechungsnotizen mit optionalen Fokusbereichen zusammen."""

    system_prompt = "Sie sind ein Experte für die Zusammenfassung von Geschäftsbesprechungen. Extrahieren Sie wichtige Informationen, Entscheidungen und Aktionspunkte in einem klaren, strukturierten Format."

    user_prompt = f"Bitte fassen Sie die folgenden Besprechungsnotizen zusammen:\n\n{notes}"

    if focus_areas:
        user_prompt += f"\n\nBitte konzentrieren Sie sich besonders auf diese Bereiche: {', '.join(focus_areas)}"

    return notes_helper.generate_response(system_prompt, user_prompt)

# Beispielverwendung
meeting_notes = """
Teambesprechung am 15. Juni 2023
Teilnehmer: Sarah, John, Michael, Emily

Tagesordnung:
1. Ergebnisse der Q2-Marketingkampagne
   - Sarah berichtete, dass die Kampagne die Ziele um 15 % übertroffen hat
   - John schlug vor, das Budget für das nächste Quartal zu erhöhen
   - Entscheidung: Das Budget für Q3 wird um 10 % erhöht

2. Zeitplan für die Produkteinführung
   - Michael erwähnte, dass die Entwicklung 2 Wochen hinter dem Zeitplan liegt
   - Emily schlug vor, temporäre Ressourcen hinzuzufügen, um aufzuholen
   - Entscheidung: 2 Auftragnehmer für 4 Wochen einstellen

3. Renovierung der Büroräume
   - Die Renovierung soll am 1. Juli beginnen
   - Für 3 Wochen muss ein temporärer Arbeitsbereich eingerichtet werden
   - Aktion: Sarah kontaktiert die Gebäudeverwaltung

Nächstes Treffen: 29. Juni 2023
"""

summary = summarize_meeting_notes(meeting_notes, ["Entscheidungen", "Aktionspunkte"])
print(summary)

# data_analyst.py
from prompt_engineering_helper import PromptEngineeringHelper

# Initialisieren Sie mit Ihrem bevorzugten Modell
data_helper = PromptEngineeringHelper(model_type="openai", model_name="gpt-3.5-turbo", api_key="ihr-api-schluessel")

def analyze_sales_data(data_description, analysis_type="trends"):
    """Analysieren Sie Verkaufsdaten mit Chain-of-Thought-Prompting."""

    system_prompt = "Sie sind ein leitender Geschäftsanalyst mit Fachkenntnissen in der Verkaufsdatenanalyse und Berichterstattung."

    steps = [
        "Identifizieren Sie die wichtigsten Kennzahlen in den Daten",
        "Berechnen Sie relevante Leistungsindikatoren",
        "Identifizieren Sie signifikante Muster oder Trends",
        "Ziehen Sie aussagekräftige Erkenntnisse aus der Analyse",
        "Geben Sie umsetzbare Empfehlungen"
    ]

    user_prompt = f"Analysieren Sie die folgenden Verkaufsdaten mit Schwerpunkt auf {analysis_type}:\n\n{data_description}"

    return data_helper.chain_of_thought(system_prompt, steps, user_prompt)

# Beispielverwendung
sales_data = """
Q2 2023 Verkaufsdaten nach Region:
- Nord-Region: 1,2 Mio. $ (12 % Steigerung gegenüber Q1)
- Süd-Region: 980.000 $ (5 % Rückgang gegenüber Q1)
- Ost-Region: 1,5 Mio. $ (18 % Steigerung gegenüber Q1)
- West-Region: 1,1 Mio. $ (8 % Steigerung gegenüber Q1)

Leistung der Produktkategorien:
- Elektronik: 1,8 Mio. $ (15 % des Gesamtumsatzes)
- Kleidung: 1,3 Mio. $ (11 % des Gesamtumsatzes)
- Haus & Garten: 1,7 Mio. $ (14 % des Gesamtumsatzes)

Bemerkenswerte Ereignisse:
- Neue Marketingkampagne in den Regionen Nord und Ost Mitte April gestartet
- In der Süd-Region gab es im Mai Probleme mit der Lieferkette
- Im April wurden 15 neue Produkte in allen Kategorien eingeführt
"""

analysis = analyze_sales_data(sales_data, "regionale Leistungsunterschiede")
print(analysis)

# document_generator.py
from prompt_engineering_helper import PromptEngineeringHelper

# Initialisieren Sie mit Ihrem bevorzugten Modell
doc_helper = PromptEngineeringHelper(model_type="openai", model_name="gpt-3.5-turbo", api_key="ihr-api-schluessel")

def generate_report(template, variables):
    """Generieren Sie einen Bericht mit vorlagenbasiertem Prompting."""

    system_prompt = "Sie sind ein professioneller Verfasser von Geschäftsberichten. Erstellen Sie genaue, gut strukturierte Berichte basierend auf der bereitgestellten Vorlage und den Informationen."

    return doc_helper.template_prompt(template, variables, system_prompt)

# Beispielverwendung
report_template = """
# [Titel des Berichts]

**Datum:** [Datum]
**Erstellt von:** [Autor]
**Abteilung:** [Abteilung]

## Zusammenfassung für die Geschäftsführung
[Zusammenfassung für die Geschäftsführung]

## Wichtige Erkenntnisse
[Wichtige Erkenntnisse]

## Empfehlungen
[Empfehlungen]

## Nächste Schritte
[Nächste Schritte]
"""

variables = {
    "Titel des Berichts": "Q2 2023 Kundenzufriedenheitsanalyse",
    "Datum": "20. Juni 2023",
    "Autor": "Alex Brenner",
    "Abteilung": "Kundenerfahrung",
    "Zusammenfassung für die Geschäftsführung": "Die Kundenzufriedenheit stieg im Vergleich zu Q1 um 8 %, was auf Verbesserungen der Produktqualität und der Reaktionszeiten des Kundendienstes zurückzuführen ist.",
    "Wichtige Erkenntnisse": "- Die Produktqualitätsbewertungen stiegen von 4,2 auf 4,5/5\n- Die Reaktionszeiten des Kundendienstes sanken um 30 %\n- Der Net Promoter Score verbesserte sich von 45 auf 53",
    "Empfehlungen": "- Weiter in die Verbesserung der Produktqualität investieren\n- Das Kundendienstteam während der Spitzenzeiten erweitern\n- Eine Feedbackschleife für die Produktentwicklung implementieren",
    "Nächste Schritte": "- Eine Folgeumfrage in Q3 planen\n- Die Ergebnisse dem Führungsteam präsentieren\n- Einen Aktionsplan für Q4 entwickeln"
}

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):
        """Bewerten Sie einen Prompt basierend auf den erwarteten Aspekten."""

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

        # Erstellen Sie einen Bewertungs-Prompt
        eval_system = "Sie sind ein Experte für die Bewertung von KI-generierten Inhalten. Bewerten Sie, wie gut die Antwort die angegebenen Aspekte auf einer Skala von 1-5 berücksichtigt."

        eval_user = f"""
        Zu bewertende Antwort:
        {response}

        Zu bewertende Aspekte:
        {"\n".join(f'- {aspect}' for aspect in expected_aspects)}

        Geben Sie für jeden Aspekt eine Bewertung (1-5) und eine kurze Begründung an.
        """

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

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

    def compare_models(self, system_prompt, user_prompt, models):
        """Vergleichen Sie denselben Prompt über verschiedene Modelle hinweg."""

        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

# Beispielverwendung
evaluator = PromptEvaluator("openai", "gpt-3.5-turbo", api_key="ihr-api-schluessel")

system_prompt = "Sie sind ein professioneller Verfasser von Geschäfts-E-Mails."
user_prompt = "Entwerfen Sie eine höfliche, aber bestimmte E-Mail an einen Kunden, der mit seiner Zahlung im Verzug ist."
expected_aspects = ["Professioneller Ton", "Klarheit der Zahlungsaufforderung", "Aufrechterhaltung einer guten Kundenbeziehung"]

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

# prompt_ab_test.py
from prompt_engineering_helper import PromptEngineeringHelper

def ab_test_prompts(prompt_variants, test_cases):
    """Vergleichen Sie mehrere Prompt-Varianten über Testfälle hinweg."""

    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

# Beispielverwendung
prompt_variants = {
    "direct_approach": {
        "model_type": "openai",
        "model_name": "gpt-3.5-turbo",
        "api_key": "ihr-api-schluessel",
        "system_prompt": "Sie sind ein direkter und prägnanter Geschäftskommunikator."
    },
    "detailed_approach": {
        "model_type": "openai",
        "model_name": "gpt-3.5-turbo",
        "api_key": "ihr-api-schluessel",
        "system_prompt": "Sie sind ein gründlicher Geschäftskommunikator, der detaillierte Erklärungen und Kontext liefert."
    }
}

test_cases = [
    {
        "name": "project_update_request",
        "user_prompt": "Fordern Sie ein Status-Update zur Q3-Marketingkampagne vom Teamleiter an."
    },
    {
        "name": "meeting_scheduling",
        "user_prompt": "Vereinbaren Sie ein Treffen mit dem Finanzteam, um das Budget zu überprüfen."
    }
]

ab_results = ab_test_prompts(prompt_variants, test_cases)

# Ergebnisse drucken
for variant_name, results in ab_results.items():
    print(f"\n=== {variant_name.upper()} ===")
    for result in results:
        print(f"\nTestfall: {result['test_case']}")
        print(f"Antwort: {result['response'][:200]}...")  # Die ersten 200 Zeichen anzeigen