from self_evolving.adapters import *
from self_evolving.orchestrator.registry import InterfaceRegistry
from self_evolving.orchestrator.evolution_loop import EvolutionLoop

class MyTaskAdapter(TaskAdapter):
    def parse(self, external_input: dict) -> TaskSpec: ...

class MyCandidateApplier(CandidateApplier):
    def apply(self, task, base_workspace, candidate) -> str: ...

class MyResultParser(ResultParser):
    def parse(self, task, run_artifacts) -> EvalResult: ...

class MyFitnessFunction(FitnessFunction):
    def score(self, task, result, candidate) -> Fitness: ...

class MyFitnessComparator(FitnessComparator):
    def better(self, a: Fitness, b: Fitness) -> bool: ...

# Register, configure, and run
registry = InterfaceRegistry()
registry.register_task_adapter(MyTaskAdapter())
# ... register all 5 adapters

loop = EvolutionLoop(registry=registry, config=config, ...)
result = loop.run({"repo": "my-project", "issue": "bug-123"})

from prompt_optimization.config import *
from prompt_optimization.engine import OptimizationEngine
from prompt_optimization.evaluation.dataset import EvaluationDataset
from prompt_optimization.evaluation.models import DatasetItem
from prompt_optimization.llm.client import LLMClient, LLMResponse

# 1️⃣  Connect to GLM API
from zhipuai import ZhipuAI
_zhipu = ZhipuAI(api_key="your-api-key")

def glm_request(model, prompt, temperature, max_tokens):
    resp = _zhipu.chat.completions.create(
        model="glm-5",
        messages=[{"role": "user", "content": prompt}],
        temperature=max(0.01, temperature),
        max_tokens=max_tokens,
    )
    return LLMResponse(
        text=resp.choices[0].message.content,
        prompt_tokens=resp.usage.prompt_tokens,
        completion_tokens=resp.usage.completion_tokens,
        model="glm-5",
    )

cfg = LLMClientConfig(backend="glm", api_key="your-key", max_retries=3)
client = LLMClient(config=cfg, request_fn=glm_request)

# 2️⃣  Prepare evaluation dataset
dataset = EvaluationDataset(items=[
    DatasetItem(
        input_text="Build an alert management module with multi-level alerts",
        reference_output="Alert page with severity filters, aggregation view...",
    ),
    DatasetItem(
        input_text="Create a server resource monitoring page with real-time CPU/memory",
        reference_output="Monitoring page with metric cards, time-series charts...",
    ),
    # ... more evaluation pairs
], split_ratios=(0.6, 0.2, 0.2), seed=42)

# 3️⃣  Configure the optimization engine
config = PromptOptimizationConfig(
    llm_configs={"glm": cfg},
    mutation_model="glm",
    judge_model="glm",
    evaluation_weights={
        "accuracy": 1.5,                  # Feature completeness
        "fluency": 0.8,                   # Code readability
        "terminology_consistency": 1.2,    # Domain terminology
        "format_compliance": 1.0,          # Output format
        "safety": 0.5,                     # Safety
    },
    max_iterations=30,
    population_size=5,
    token_budget=2_000_000,
    annealing=AnnealingConfig(
        initial_temp=1.0, final_temp=0.1, schedule="cosine"
    ),
)

# 4️⃣  Launch optimization
engine = OptimizationEngine(config=config, llm_clients={"glm": client})
result = engine.run(
    seed_prompt_text="You are a senior full-stack engineer. Generate frontend code.",
    dataset=dataset,
)

print(f"Best prompt:  {result['best_prompt']}")
print(f"Best score:   {result['best_fitness']:.4f}")
print(f"Iterations:   {result['iterations']}")
print(f"Token usage:  {result['token_usage']['total_tokens']}")

# NLP Scoring (pure Python, no external deps for BLEU/ROUGE-L)
from prompt_optimization.evaluation.nlp_scorer import NLPScorer
scorer = NLPScorer()
result = scorer.score("The weather is nice", "The weather is nice")
# → BLEU-1=1.0, ROUGE-L=1.0

# LLM-as-Judge (5-dimension scoring)
from prompt_optimization.evaluation.llm_judge import LLMJudge
judge = LLMJudge(llm_client=client, model="glm-5")
scores = judge.judge(generated, reference, task_description)
# → {accuracy: 0.9, fluency: 0.85, terminology_consistency: 0.78, ...}

# Overfitting Detection
from prompt_optimization.overfitting.detector import OverfittingDetector
detector = OverfittingDetector(config=overfitting_config)
detector.check_dataset_separation(dev_score=0.9, val_score=0.7)  # → True
detector.detect_gaming("prompt with ground_truth leaked")         # → True

# A/B Testing with Statistical Significance
from prompt_optimization.online.ab_test import ABTestManager
ab = ABTestManager()
exp_id = ab.create_experiment("old_prompt", "new_prompt", traffic_ratio=0.3)
# ... collect metrics ...
result = ab.evaluate_experiment(exp_id)
# → lift=+15.2%, p=0.003, recommendation="promote"

# Structured Prompt Serialization
from prompt_optimization.prompt.structured import StructuredPrompt, PromptExample
sp = StructuredPrompt(
    role="Expert translator",
    task_description="Translate English to Chinese",
    examples=[PromptExample(input_text="Hello", output_text="你好")],
    cot_instruction="First understand the meaning, then choose the right expression",
)
json_str = sp.to_json()                        # Serialize
restored = StructuredPrompt.from_json(json_str) # Deserialize (round-trip safe)
print(sp.render_formatted())                    # Human-readable output