# /// script
# dependencies = ["transformers>=4.46.0", "torch", "peft", "bitsandbytes", "accelerate", "datasets", "evalplus", "tqdm", "protobuf", "sentencepiece", "mistral-common>=1.5.0", "huggingface_hub"]
# ///

"""
Prompt Comparison: Direct Code vs Reasoning
Tests if "code only" prompt improves fine-tuned model scores

VERSION: 1.0
"""

import os
import re
import json
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
from peft import PeftModel
from datasets import load_dataset
from tqdm import tqdm
from huggingface_hub import HfApi

print("=" * 60)
print("PROMPT COMPARISON TEST")
print("Direct Code vs Reasoning Prompt")
print("Benchmark: HumanEval")
print("=" * 60)

# Configuration
BASE_MODEL = "mistralai/Devstral-Small-2505"
FINETUNED_ADAPTER = "stmasson/alizee-coder-devstral-1-small"
OUTPUT_REPO = "stmasson/alizee-coder-devstral-1-small"
TEMPERATURE = 0.1
MAX_NEW_TOKENS = 512

# Check GPU
print(f"\nGPU available: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"GPU: {torch.cuda.get_device_name(0)}")
    print(f"Memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")

# 4-bit quantization config
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

def load_humaneval():
    """Load HumanEval dataset from EvalPlus"""
    print("\nLoading HumanEval dataset...")
    dataset = load_dataset("evalplus/humanevalplus", split="test")
    print(f"Loaded {len(dataset)} problems")
    return dataset

def load_model(model_name, adapter_name=None):
    """Load model with optional LoRA adapter"""
    print(f"\nLoading model: {model_name}")
    if adapter_name:
        print(f"With adapter: {adapter_name}")

    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token

    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        quantization_config=bnb_config,
        device_map="auto",
        trust_remote_code=True,
        torch_dtype=torch.bfloat16,
    )

    if adapter_name:
        print("Loading LoRA adapter...")
        model = PeftModel.from_pretrained(model, adapter_name)
        model = model.merge_and_unload()
        print("Adapter merged")

    model.eval()
    return model, tokenizer

def extract_python_code(text):
    """Extract Python code from model output"""
    pattern = r'```python\s*(.*?)\s*```'
    matches = re.findall(pattern, text, re.DOTALL)
    if matches:
        return matches[-1].strip()

    pattern = r'```\s*(.*?)\s*```'
    matches = re.findall(pattern, text, re.DOTALL)
    if matches:
        return matches[-1].strip()

    return text.strip()

def generate_direct_prompt(model, tokenizer, prompt):
    """Generate with DIRECT CODE prompt - no reasoning, just code"""
    instruct_prompt = f"<s>[INST] Complete this Python function. Output ONLY the function body code, no explanations or markdown:\n\n{prompt}[/INST]"

    inputs = tokenizer(instruct_prompt, return_tensors="pt", truncation=True, max_length=4096).to(model.device)

    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=MAX_NEW_TOKENS,
            temperature=TEMPERATURE,
            do_sample=True if TEMPERATURE > 0 else False,
            pad_token_id=tokenizer.pad_token_id,
            eos_token_id=tokenizer.eos_token_id,
        )

    raw = tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
    completion = extract_python_code(raw)

    # Extract function body if full function
    if completion.strip().startswith("def "):
        lines = completion.split('\n')
        body_lines = []
        in_function = False
        for line in lines:
            if line.strip().startswith("def "):
                in_function = True
                continue
            if in_function:
                body_lines.append(line)
        if body_lines:
            completion = '\n'.join(body_lines)
    elif completion == raw.strip():
        completion = raw

    # Stop at boundaries
    for stop in ["\ndef ", "\nclass ", "\nif __name__", "\n\n\n"]:
        if stop in completion:
            completion = completion[:completion.index(stop)]

    return completion

def generate_reasoning_prompt(model, tokenizer, prompt):
    """Generate with REASONING prompt - original approach"""
    instruct_prompt = f"<s>[INST] Solve this programming problem with detailed reasoning:\n\nComplete the following function:\n{prompt}\n[/INST]"

    inputs = tokenizer(instruct_prompt, return_tensors="pt", truncation=True, max_length=4096).to(model.device)

    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=MAX_NEW_TOKENS * 2,
            temperature=TEMPERATURE,
            do_sample=True if TEMPERATURE > 0 else False,
            pad_token_id=tokenizer.pad_token_id,
            eos_token_id=tokenizer.eos_token_id,
        )

    full_response = tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
    code = extract_python_code(full_response)

    if "def " in code:
        lines = code.split('\n')
        result_lines = []
        in_function = False
        for line in lines:
            if line.strip().startswith("def "):
                in_function = True
                continue
            if in_function:
                result_lines.append(line)
        if result_lines:
            return '\n'.join(result_lines)

    return code

def simple_syntax_check(code):
    """Basic syntax validation"""
    try:
        compile(code, '<string>', 'exec')
        return True
    except SyntaxError:
        return False

def evaluate_samples(samples, dataset):
    """Evaluate samples"""
    results = {"passed": 0, "failed": 0, "error": 0}

    for sample in samples:
        task_id = sample["task_id"]
        completion = sample["completion"]

        problem = None
        for p in dataset:
            if p["task_id"] == task_id:
                problem = p
                break

        if problem is None:
            results["error"] += 1
            continue

        full_code = problem["prompt"] + completion

        if not simple_syntax_check(full_code):
            results["failed"] += 1
            continue

        try:
            exec_globals = {}
            exec(full_code, exec_globals)
            entry_point = problem.get("entry_point", task_id.split("/")[-1])
            if entry_point in exec_globals:
                results["passed"] += 1
            else:
                results["failed"] += 1
        except Exception:
            results["error"] += 1

    total = len(samples)
    pass_rate = results["passed"] / total if total > 0 else 0

    return {
        "pass@1": pass_rate,
        "passed": results["passed"],
        "failed": results["failed"],
        "error": results["error"],
        "total": total
    }

def main():
    dataset = load_humaneval()

    # Load fine-tuned model
    print("\n" + "=" * 60)
    print("LOADING FINE-TUNED MODEL")
    print("=" * 60)
    model, tokenizer = load_model(BASE_MODEL, FINETUNED_ADAPTER)

    results = {}

    # Test 1: Direct prompt
    print("\n" + "=" * 60)
    print("TEST 1: DIRECT CODE PROMPT")
    print("'Output ONLY the code, no explanations'")
    print("=" * 60)
    direct_samples = []
    for problem in tqdm(dataset, desc="Direct Prompt"):
        task_id = problem["task_id"]
        prompt = problem["prompt"]
        try:
            completion = generate_direct_prompt(model, tokenizer, prompt)
            direct_samples.append({"task_id": task_id, "completion": completion})
        except Exception as e:
            print(f"Error on {task_id}: {e}")
            direct_samples.append({"task_id": task_id, "completion": "# Error"})

    results["direct"] = evaluate_samples(direct_samples, dataset)
    print(f"\nDirect Prompt Results: pass@1 = {results['direct']['pass@1']*100:.2f}%")

    # Test 2: Reasoning prompt
    print("\n" + "=" * 60)
    print("TEST 2: REASONING PROMPT (original)")
    print("'Solve with detailed reasoning'")
    print("=" * 60)
    reasoning_samples = []
    for problem in tqdm(dataset, desc="Reasoning Prompt"):
        task_id = problem["task_id"]
        prompt = problem["prompt"]
        try:
            completion = generate_reasoning_prompt(model, tokenizer, prompt)
            reasoning_samples.append({"task_id": task_id, "completion": completion})
        except Exception as e:
            print(f"Error on {task_id}: {e}")
            reasoning_samples.append({"task_id": task_id, "completion": "# Error"})

    results["reasoning"] = evaluate_samples(reasoning_samples, dataset)
    print(f"\nReasoning Prompt Results: pass@1 = {results['reasoning']['pass@1']*100:.2f}%")

    # Summary
    print("\n" + "=" * 60)
    print("PROMPT COMPARISON SUMMARY - HumanEval")
    print("=" * 60)
    print(f"\n{'Prompt Type':<30} {'pass@1':>10} {'Passed':>8} {'Failed':>8}")
    print("-" * 60)
    print(f"{'Direct Code Prompt':<30} {results['direct']['pass@1']*100:>9.2f}% {results['direct']['passed']:>8} {results['direct']['failed']:>8}")
    print(f"{'Reasoning Prompt (original)':<30} {results['reasoning']['pass@1']*100:>9.2f}% {results['reasoning']['passed']:>8} {results['reasoning']['failed']:>8}")

    improvement = (results['direct']['pass@1'] - results['reasoning']['pass@1']) * 100
    sign = "+" if improvement >= 0 else ""
    print(f"\n{'Improvement (Direct vs Reasoning):':<30} {sign}{improvement:>9.2f}%")

    # Reference
    print(f"\n{'Reference - Base Model (v2):':<30} {'82.93%':>10}")
    print(f"{'Reference - Reasoning (v2):':<30} {'62.20%':>10}")

    # Save results
    output = {
        "benchmark": "HumanEval",
        "experiment": "Prompt Comparison",
        "model": FINETUNED_ADAPTER,
        "results": {
            "direct_prompt": {
                "pass@1": float(results['direct']['pass@1']),
                "passed": results['direct']['passed'],
                "failed": results['direct']['failed'],
                "total": results['direct']['total']
            },
            "reasoning_prompt": {
                "pass@1": float(results['reasoning']['pass@1']),
                "passed": results['reasoning']['passed'],
                "failed": results['reasoning']['failed'],
                "total": results['reasoning']['total']
            },
            "improvement": float(improvement),
            "base_model_reference": 0.8293,
            "reasoning_reference": 0.6220
        },
        "samples": {
            "direct": direct_samples[:3],
            "reasoning": reasoning_samples[:3]
        }
    }

    with open("eval_prompt_comparison.json", "w") as f:
        json.dump(output, f, indent=2)
    print("\nResults saved to eval_prompt_comparison.json")

    try:
        api = HfApi()
        api.upload_file(
            path_or_fileobj="eval_prompt_comparison.json",
            path_in_repo="eval_prompt_comparison.json",
            repo_id=OUTPUT_REPO,
            repo_type="model",
        )
        print(f"Results uploaded to {OUTPUT_REPO}")
    except Exception as e:
        print(f"Could not upload results: {e}")

    print("\n" + "=" * 60)
    print("EVALUATION COMPLETE")
    print("=" * 60)

if __name__ == "__main__":
    main()