"""Rule-based Salesforce governor limit checks for generated Apex and Flows."""

from __future__ import annotations

import re
import xml.etree.ElementTree as ET
from typing import Dict, List, Tuple

from packages.integrations.static_analysis import StaticAnalysisResult, StaticViolation

_LOOP_HEADER = re.compile(r"\b(for|while)\s*\(", re.IGNORECASE)
_DO_BLOCK = re.compile(r"\bdo\s*\{", re.IGNORECASE)

_IN_LOOP_RULES: List[Tuple[str, re.Pattern[str], str, str]] = [
    ("SOQLInLoop", re.compile(r"\[\s*SELECT\b", re.IGNORECASE),
     "SOQL query inside a loop (limit: 100 queries per transaction)", "high"),
    ("SOQLInLoop", re.compile(r"\bDatabase\s*\.\s*(query|countQuery)\s*\(", re.IGNORECASE),
     "Dynamic SOQL inside a loop (limit: 100 queries per transaction)", "high"),
    ("SOSLInLoop", re.compile(r"\[\s*FIND\b", re.IGNORECASE),
     "SOSL search inside a loop (limit: 20 searches per transaction)", "high"),
    ("DMLInLoop", re.compile(r"(?<![\w.])(insert|update|upsert|delete|undelete|merge)\s+(?=[A-Za-z_(\[])", re.IGNORECASE),
     "DML statement inside a loop (limit: 150 DML statements per transaction)", "high"),
    ("DMLInLoop", re.compile(r"\bDatabase\s*\.\s*(insert|update|upsert|delete|undelete|merge)\s*\(", re.IGNORECASE),
     "Database DML call inside a loop (limit: 150 DML statements per transaction)", "high"),
    ("EmailInLoop", re.compile(r"\bMessaging\s*\.\s*sendEmail\s*\(", re.IGNORECASE),
     "Messaging.sendEmail inside a loop (limit: 10 calls per transaction)", "high"),
    ("AsyncInLoop", re.compile(r"\b(System\s*\.\s*enqueueJob|Database\s*\.\s*executeBatch)\s*\(", re.IGNORECASE),
     "Async job enqueued inside a loop (limit: 50 queueable / 5 batch jobs)", "high"),
]

_UNBOUNDED_SOQL = re.compile(r"\[\s*SELECT\b(?P<body>[^\]]*)\]", re.IGNORECASE)
_TRIGGER_FIRST_RECORD = re.compile(r"\bTrigger\s*\.\s*new(Map)?\s*\[\s*0\s*\]", re.IGNORECASE)

_FLOW_NS = "{http://soap.sforce.com/2006/04/metadata}"
_FLOW_DATA_ELEMENTS = {
    "recordLookups": "Get Records",
    "recordCreates": "Create Records",
    "recordUpdates": "Update Records",
    "recordDeletes": "Delete Records",
}
_FLOW_CONNECTOR_TAGS = ("connector", "nextValueConnector", "noMoreValuesConnector", "defaultConnector", "faultConnector")


def check_governor_limits(file_map: Dict[str, str]) -> List[StaticViolation]:
    violations: List[StaticViolation] = []
    for path, content in sorted(file_map.items()):
        if path.endswith(".cls") or path.endswith(".trigger"):
            violations.extend(check_apex(path, content))
        elif path.endswith(".flow-meta.xml"):
            violations.extend(check_flow(path, content))
    return violations


def merge_governor_results(
    static_result: StaticAnalysisResult, governor: List[StaticViolation]
) -> StaticAnalysisResult:
    if not governor:
        return static_result
    return StaticAnalysisResult(
        success=static_result.success,
        violations=list(static_result.violations) + governor,
        message=f"{static_result.message}; governor checks found {len(governor)} violation(s)",
    )


def check_apex(path: str, source: str) -> List[StaticViolation]:
    code = _strip_comments_and_strings(source)
    loop_ranges = _loop_body_ranges(code)
    violations: List[StaticViolation] = []
    seen: set[tuple[str, int]] = set()

    for rule, pattern, message, severity in _IN_LOOP_RULES:
        for m in pattern.finditer(code):
            if not any(start <= m.start() < end for start, end in loop_ranges):
                continue
            line = code.count("\n", 0, m.start()) + 1
            if (rule, line) in seen:
                continue
            seen.add((rule, line))
            violations.append(StaticViolation(rule=rule, file=path, line=line, message=message, severity=severity))

    for m in _UNBOUNDED_SOQL.finditer(code):
        body = m.group("body").upper()
        if " WHERE " not in f" {body} " and " LIMIT " not in f" {body} ":
            violations.append(
                StaticViolation(
                    rule="UnboundedSOQL",
                    file=path,
                    line=code.count("\n", 0, m.start()) + 1,
                    message="SOQL without WHERE or LIMIT (limit: 50,000 rows per transaction)",
                    severity="medium",
                )
            )

    if path.endswith(".trigger"):
        for m in _TRIGGER_FIRST_RECORD.finditer(code):
            violations.append(
                StaticViolation(
                    rule="TriggerNotBulkified",
                    file=path,
                    line=code.count("\n", 0, m.start()) + 1,
                    message="Trigger only processes Trigger.new[0]; handle all records (up to 200 per batch)",
                    severity="high",
                )
            )
    return violations


def _strip_comments_and_strings(src: str) -> str:
    """Blank out comments and string literals, keeping offsets and newlines intact."""
    out = list(src)
    i, n = 0, len(src)
    while i < n:
        if src.startswith("//", i):
            j = src.find("\n", i)
            j = n if j < 0 else j
            for k in range(i, j):
                out[k] = " "
            i = j
        elif src.startswith("/*", i):
            j = src.find("*/", i + 2)
            j = n if j < 0 else j + 2
            for k in range(i, j):
                if out[k] != "\n":
                    out[k] = " "
            i = j
        elif src[i] == "'":
            j = i + 1
            while j < n and src[j] != "'":
                j += 2 if src[j] == "\\" else 1
            for k in range(i + 1, min(j, n)):
                if out[k] != "\n":
                    out[k] = " "
            i = j + 1
        else:
            i += 1
    return "".join(out)


def _matching(code: str, open_idx: int, open_ch: str, close_ch: str) -> int:
    depth = 0
    for i in range(open_idx, len(code)):
        if code[i] == open_ch:
            depth += 1
        elif code[i] == close_ch:
            depth -= 1
            if depth == 0:
                return i
    return len(code)


def _loop_body_ranges(code: str) -> List[Tuple[int, int]]:
    ranges: List[Tuple[int, int]] = []
    for m in _LOOP_HEADER.finditer(code):
        paren_open = m.end() - 1
        paren_close = _matching(code, paren_open, "(", ")")
        j = paren_close + 1
        while j < len(code) and code[j].isspace():
            j += 1
        if j >= len(code):
            continue
        if code[j] == "{":
            ranges.append((j, _matching(code, j, "{", "}")))
        elif code[j] != ";":
            end = code.find(";", j)
            ranges.append((j, len(code) if end < 0 else end + 1))
    for m in _DO_BLOCK.finditer(code):
        brace = m.end() - 1
        ranges.append((brace, _matching(code, brace, "{", "}")))
    return ranges


def check_flow(path: str, xml_text: str) -> List[StaticViolation]:
    try:
        root = ET.fromstring(xml_text)
    except ET.ParseError:
        return []

    def local(tag: str) -> str:
        return tag[len(_FLOW_NS):] if tag.startswith(_FLOW_NS) else tag

    elements: Dict[str, str] = {}
    edges: Dict[str, List[str]] = {}
    loop_entry: Dict[str, str] = {}
    for el in list(root):
        kind = local(el.tag)
        name_el = el.find(f"{_FLOW_NS}name")
        if name_el is None:
            name_el = el.find("name")
        if name_el is None or not (name_el.text or "").strip():
            continue
        name = name_el.text.strip()
        elements[name] = kind
        targets: List[str] = []
        for node in el.iter():
            if local(node.tag) in _FLOW_CONNECTOR_TAGS:
                ref = node.find(f"{_FLOW_NS}targetReference")
                if ref is None:
                    ref = node.find("targetReference")
                if ref is not None and ref.text:
                    targets.append(ref.text.strip())
                    if kind == "loops" and local(node.tag) == "nextValueConnector":
                        loop_entry[name] = ref.text.strip()
        edges[name] = targets

    violations: List[StaticViolation] = []
    for loop_name, entry in loop_entry.items():
        stack, visited = [entry], set()
        while stack:
            current = stack.pop()
            if current == loop_name or current in visited:
                continue
            visited.add(current)
            kind = elements.get(current)
            if kind in _FLOW_DATA_ELEMENTS:
                violations.append(
                    StaticViolation(
                        rule="FlowDataElementInLoop",
                        file=path,
                        line=None,
                        message=(
                            f"{_FLOW_DATA_ELEMENTS[kind]} element '{current}' runs inside loop "
                            f"'{loop_name}' (counts against SOQL/DML limits per iteration)"
                        ),
                        severity="high",
                    )
                )
            stack.extend(edges.get(current, []))
    return violations
