from haystack import Pipeline
from haystack.components.websearch import SerperDevWebSearch
from haystack.components.fetchers import LinkContentFetcher
from haystack.components.converters import HTMLToDocument
from haystack.components.rankers import TransformersSimilarityRanker

def build_research_pipeline() -> Pipeline:
    pipe = Pipeline()

    # Komponenten initialisieren
    pipe.add_component("search", SerperDevWebSearch(api_key="DEIN_API_KEY"))
    pipe.add_component("fetcher", LinkContentFetcher())
    pipe.add_component("html_converter", HTMLToDocument())
    
    # Der Ranker sortiert Dokumente nach Relevanz zur Suchanfrage aus
    pipe.add_component("ranker", TransformersSimilarityRanker(model="cross-encoder/ms-marco-MiniLM-L-6-v2"))

    # Den gerichteten Graphen aufbauen
    pipe.connect("search.links", "fetcher.urls")
    pipe.connect("fetcher.streams", "html_converter.sources")
    pipe.connect("html_converter.documents", "ranker.documents")

    return pipe

from pydantic import BaseModel
from typing import List, Dict, Literal

# Strikte Typisierung eliminiert Halluzinationen in der Struktur
class Ingredient(BaseModel):
    name: str
    amount: float
    unit: str

class RecipeStructure(BaseModel):
    recipe_title: str
    servings: int
    ingredients: List[Ingredient]
    instructions: List[str]
    nutrients: Dict[str, float]
    difficulty: Literal["Einfach", "Mittel", "Schwer"]

# Nutzungshinweis für die Pipeline:
# generator = HuggingFaceAPIChatGenerator(
#     api_type="text_generation_inference",
#     generation_kwargs={"response_format": RecipeStructure.schema_json()}
# )

from haystack import component
from haystack.dataclasses import ImageContent
# import diffusers ...

@component
class StableDiffusionGenerator:
    def __init__(self, model_id="stabilityai/stable-diffusion-xl-base-1.0"):
        self.model_id = model_id
        # Initialisierung z.B. Pipeline Laden inkl. FP16 Optimierung

    # Definition des Output-Sockets für die Validierung vor der Laufzeit
    @component.output_types(image=ImageContent)
    def run(self, prompt: str):
        # image = self.pipe(prompt).images[0]
        # base64_str = convert_to_base64(image)
        
        # Rückgabe als Haystack 2.0 Multimodal Objekt
        return {"image": ImageContent.from_base64(base64_str)}

<!-- Das Template wird vom HTML-Agenten mit Daten befüllt -->
<div class="recipe-card">
    <h1>{{ recipe_title }}</h1>
    
    <!-- Base64 Einbettung erspart externe Bild-Hostings -->
    <img src="data:image/png;base64,{{ image_base64 }}" alt="{{ recipe_title }}">
    
    <div class="meta">
        <span>Schwierigkeit: {{ difficulty }}</span>
    </div>
    
    <h3>Zutaten</h3>
    <ul>
        {% for ingredient in ingredients %}
            <li>{{ ingredient.amount }} {{ ingredient.unit }} {{ ingredient.name}}</li>
        {% endfor %}
    </ul>
    
    <h3>Zubereitung</h3>
    <ol>
        {% for step in instructions %}
            <li>{{ step }}</li>
        {% endfor %}
    </ol>
</div>

from haystack.tools import Tool
from haystack.components.routers import ConditionalRouter
from agents.researcher import build_research_pipeline

# Pipeline laden
research_pipe = build_research_pipeline()

# Pipeline als aufrufbares Werkzeug für das LLM verpacken
research_tool = Tool(
    name="research_tool",
    description="Durchsucht das Web nach authentischen Rezepten.",
    parameters={"query": {"type": "string"}},
    function=research_pipe.run
)

# Fehlerbehandlung: Ein Router, der den Pfad basierend auf Tool-Erfolg wählt
routes = [
    {
        "condition": "{{ 'error' in tool_result.text | lower }}",
        "output": "{{ tool_result }}",
        "output_name": "error_route",
        "output_type": str
    },
    {
        "condition": "{{ 'error' not in tool_result.text | lower }}",
        "output": "{{ tool_result }}",
        "output_name": "success_route",
        "output_type": str
    }
]
router = ConditionalRouter(routes)