from abc import ABC, abstractmethod
from dataclasses import dataclass
 
@dataclass
class CallResult:
    provider: str
    answer: str
    input_tokens: int
    cached_tokens: int
    output_tokens: int
    latency_sec: float
    cost_usd: float
 
class CachingAssistant(ABC):
    """Üç provider için ortak interface."""
 
    @abstractmethod
    def setup(self, codebase: str) -> None:
        """Cache veya cache_control hazırla."""
        ...
 
    @abstractmethod
    def ask(self, question: str) -> CallResult:
        """Sorgu yap, sonucu döndür."""
        ...
 
    @abstractmethod
    def teardown(self) -> None:
        """Cache'i temizle (gerekirse)."""
        ...

import anthropic
import time
 
class AnthropicAssistant(CachingAssistant):
    PRICE = {"input": 3.0, "output": 15.0, "cache_write": 3.75, "cache_read": 0.30}
 
    def __init__(self):
        self.client = anthropic.Anthropic()
        self.codebase = ""
 
    def setup(self, codebase: str) -> None:
        self.codebase = codebase
 
    def ask(self, question: str) -> CallResult:
        start = time.perf_counter()
        resp = self.client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=400,
            system=[
                {
                    "type": "text",
                    "text": f"Python kod yardımcısısın.\n\nKod tabanı:\n{self.codebase}",
                    "cache_control": {"type": "ephemeral"},
                }
            ],
            messages=[{"role": "user", "content": question}],
        )
        latency = time.perf_counter() - start
        u = resp.usage
        cw = u.cache_creation_input_tokens or 0
        cr = u.cache_read_input_tokens or 0
        cost = (
            u.input_tokens / 1e6 * self.PRICE["input"]
            + cw / 1e6 * self.PRICE["cache_write"]
            + cr / 1e6 * self.PRICE["cache_read"]
            + u.output_tokens / 1e6 * self.PRICE["output"]
        )
        return CallResult(
            provider="anthropic",
            answer=resp.content[0].text,
            input_tokens=u.input_tokens,
            cached_tokens=cr,
            output_tokens=u.output_tokens,
            latency_sec=latency,
            cost_usd=cost,
        )
 
    def teardown(self) -> None:
        pass  # ephemeral, otomatik

from openai import OpenAI
 
class OpenAIAssistant(CachingAssistant):
    PRICE = {"input": 2.5, "output": 10.0, "cached_input": 1.25}
 
    def __init__(self):
        self.client = OpenAI()
        self.codebase = ""
 
    def setup(self, codebase: str) -> None:
        self.codebase = codebase
 
    def ask(self, question: str) -> CallResult:
        start = time.perf_counter()
        resp = self.client.chat.completions.create(
            model="gpt-4o",
            max_tokens=400,
            messages=[
                {"role": "system", "content": f"Python kod yardımcısısın.\n\nKod tabanı:\n{self.codebase}"},
                {"role": "user", "content": question},
            ],
        )
        latency = time.perf_counter() - start
        u = resp.usage
        cached = u.prompt_tokens_details.cached_tokens if u.prompt_tokens_details else 0
        fresh = u.prompt_tokens - cached
        cost = (
            fresh / 1e6 * self.PRICE["input"]
            + cached / 1e6 * self.PRICE["cached_input"]
            + u.completion_tokens / 1e6 * self.PRICE["output"]
        )
        return CallResult(
            provider="openai",
            answer=resp.choices[0].message.content,
            input_tokens=fresh,
            cached_tokens=cached,
            output_tokens=u.completion_tokens,
            latency_sec=latency,
            cost_usd=cost,
        )
 
    def teardown(self) -> None:
        pass

import google.generativeai as genai
 
class GeminiAssistant(CachingAssistant):
    PRICE = {"input": 1.25, "output": 10.0, "cached": 0.31, "storage_per_hour": 0.31}
 
    def __init__(self):
        self.cache = None
        self.model = None
 
    def setup(self, codebase: str) -> None:
        self.cache = genai.caching.CachedContent.create(
            model="gemini-2.5-pro",
            contents=[{"role": "user", "parts": [{"text": codebase}]}],
            system_instruction="Python kod yardımcısısın.",
            ttl="3600s",
        )
        self.model = genai.GenerativeModel.from_cached_content(self.cache)
 
    def ask(self, question: str) -> CallResult:
        start = time.perf_counter()
        response = self.model.generate_content(question)
        latency = time.perf_counter() - start
        u = response.usage_metadata
        cached = u.cached_content_token_count
        fresh = u.prompt_token_count - cached
        cost = (
            cached / 1e6 * self.PRICE["cached"]
            + fresh / 1e6 * self.PRICE["input"]
            + u.candidates_token_count / 1e6 * self.PRICE["output"]
        )
        return CallResult(
            provider="gemini",
            answer=response.text,
            input_tokens=fresh,
            cached_tokens=cached,
            output_tokens=u.candidates_token_count,
            latency_sec=latency,
            cost_usd=cost,
        )
 
    def teardown(self) -> None:
        if self.cache:
            self.cache.delete()

# Yukarıdaki sınıflar var sayalım
 
CODEBASE = """
# Sahte ~30K token Python kod tabanı
def calculate_compound_interest(principal, rate, time):
    \"\"\"Bileşik faiz hesaplar.\"\"\"
    return principal * (1 + rate) ** time
 
class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
    # ... çok daha fazla sınıf ve fonksiyon
""" * 200  # ~30K token
 
QUESTIONS = [
    "calculate_compound_interest fonksiyonu ne yapıyor?",
    "BankAccount sınıfında balance neden ön ödemeli?",
    "Bu kodun en zayıf güvenlik noktası?",
    # ... 47 soru daha
] * 17
QUESTIONS = QUESTIONS[:50]
 
# Üç provider'ı paralel çalıştırma için sequential
results = {"anthropic": [], "openai": [], "gemini": []}
 
for AssistantClass, name in [
    (AnthropicAssistant, "anthropic"),
    (OpenAIAssistant, "openai"),
    (GeminiAssistant, "gemini"),
]:
    print(f"\n═══ {name.upper()} ═══")
    assistant = AssistantClass()
    assistant.setup(CODEBASE)
 
    for q in QUESTIONS:
        r = assistant.ask(q)
        results[name].append(r)
 
    assistant.teardown()
 
    total_cost = sum(r.cost_usd for r in results[name])
    avg_latency = sum(r.latency_sec for r in results[name]) / len(QUESTIONS)
    total_cached = sum(r.cached_tokens for r in results[name])
    total_input = sum(r.input_tokens for r in results[name])
    hit_rate = total_cached / (total_cached + total_input + 1) * 100
 
    print(f"Toplam cost:   ${total_cost:.4f}  |  {total_cost * 33.5:.2f} TL")
    print(f"Avg latency:   {avg_latency:.2f}sn")
    print(f"Cache hit:     {hit_rate:.1f}%")
 
# Karşılaştırma
print(f"\n╔══════════════════════════════════════════════════════════╗")
print(f"║                  KARŞILAŞTIRMA TABLOSU                     ║")
print(f"╠══════════════════════════════════════════════════════════╣")
print(f"║ Provider    │ Cost (USD) │ Cost (TL) │ Latency │ Hit%   ║")
print(f"╠══════════════════════════════════════════════════════════╣")
for name in ["anthropic", "openai", "gemini"]:
    tc = sum(r.cost_usd for r in results[name])
    al = sum(r.latency_sec for r in results[name]) / 50
    tt = sum(r.cached_tokens for r in results[name])
    tf = sum(r.input_tokens for r in results[name])
    hr = tt / (tt + tf + 1) * 100
    print(f"║ {name:<11}│  ${tc:>8.4f}│{tc*33.5:>10.2f}│ {al:>6.2f}s │ {hr:>5.1f}% ║")
print(f"╚══════════════════════════════════════════════════════════╝")