import re
from typing import Dict, Optional


FUNC_RE = re.compile(r"\bdef\s+([a-zA-Z_]\w*)\s*\(|\bfunction\s+([a-zA-Z_]\w*)\s*\(")
CLASS_RE = re.compile(r"\bclass\s+([a-zA-Z_]\w*)")
DOCSTRING_RE = re.compile(r'"""(.*?)"""|\'\'\'(.*?)\'\'\'', re.DOTALL)
COMMENT_RE = re.compile(r"^\s*(#|//)\s*(.+)$", re.MULTILINE)


def normalize_spaces(text: str) -> str:
    if not text:
        return ""
    return text.replace("\r\n", "\n").replace("\r", "\n").strip()


def _first_non_empty(*vals: Optional[str]) -> str:
    for v in vals:
        if v and str(v).strip():
            return str(v).strip()
    return ""


def infer_language(lang: str = "", path: str = "") -> str:
    lang = (lang or "").lower()
    path = (path or "").lower()
    if lang:
        return lang
    if path.endswith(".py"):
        return "python"
    if path.endswith(".js"):
        return "javascript"
    if path.endswith(".ts"):
        return "typescript"
    if path.endswith(".java"):
        return "java"
    return "code"


def extract_function_name(code: str) -> str:
    if not code:
        return ""
    m = FUNC_RE.search(code)
    if m:
        return m.group(1) or m.group(2) or ""
    c = CLASS_RE.search(code)
    if c:
        return c.group(1) or ""
    return ""


def extract_doc_or_comment(code: str) -> str:
    if not code:
        return ""
    doc = DOCSTRING_RE.search(code)
    if doc:
        return _first_non_empty(doc.group(1), doc.group(2))
    com = COMMENT_RE.search(code)
    if com:
        return com.group(2).strip()
    return ""


def code_to_instruction(code: str, *, language: str = "", path: str = "", title: str = "") -> str:
    code = normalize_spaces(code)
    lang = infer_language(language, path)
    func = extract_function_name(code)
    hint = _first_non_empty(title, extract_doc_or_comment(code))

    if func and hint:
        return f"Write a {lang} implementation of `{func}`. Requirements: {hint}"
    if func:
        return f"Write a {lang} function `{func}`."
    if hint:
        return f"Implement this {lang} code task: {hint}"
    if path:
        return f"Implement or refactor the {lang} code from `{path}`."
    return f"Write a correct and production-ready {lang} code snippet."


def build_instruction_sample(
    *,
    instruction: str = "",
    response: str = "",
    code: str = "",
    language: str = "",
    path: str = "",
    title: str = "",
    source: str,
    category: str,
) -> Dict[str, str]:
    if not instruction:
        instruction = code_to_instruction(code, language=language, path=path, title=title)
    if not response:
        response = code
    return {
        "instruction": normalize_spaces(instruction),
        "response": normalize_spaces(response),
        "_source": source,
        "_category": category,
    }