from __future__ import annotations

import ast
from dataclasses import dataclass

from src.rules import get_rule
from src.schemas import ChangeSet, Finding, UnknownItem
from src.taint import (
    PASSWORD_NAMES,
    TaintEnv,
    apply_assign,
    call_name,
    expr_taint,
    is_concat_or_format,
    is_constant_str,
    keyword_true,
    name_of,
    seed_function_params,
)

SQL_SINKS = {"execute", "executemany", "executescript", "text"}
CMD_SINKS = {"os.system", "os.popen", "system", "popen"}
SUBPROCESS = {"subprocess.run", "subprocess.call", "subprocess.Popen", "subprocess.check_output", "subprocess.check_call"}
PATH_SINKS = {"open", "Path", "pathlib.Path", "send_file"}
DESER_SINKS = {"pickle.loads", "pickle.load", "marshal.loads", "yaml.load"}
SAFE_YAML = {"SafeLoader", "CSafeLoader"}
SSRF_SINKS = {"urlopen", "urllib.request.urlopen", "urllib.urlopen", "requests.get", "requests.post", "requests.request", "httpx.get", "httpx.post"}
XSS_SINKS = {"Markup", "markupsafe.Markup"}
WEAK_HASH = {"hashlib.md5", "hashlib.sha1", "md5", "sha1"}


@dataclass
class ScanHit:
    rule_id: str
    path: str
    start_line: int
    end_line: int
    function: str
    snippet: str
    taint: str
    missing: list[str]
    node: ast.AST


def _snippet(source: str, lineno: int, end: int) -> str:
    rows = source.splitlines()
    start = max(1, lineno)
    stop = min(len(rows), max(end, start))
    return "\n".join(rows[start - 1 : stop])


def _function_at(stack: list[ast.AST]) -> str:
    for item in reversed(stack):
        if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
            return item.name
    return ""


class RuleVisitor(ast.NodeVisitor):
    def __init__(self, path: str, source: str) -> None:
        self.path = path
        self.source = source
        self.env = TaintEnv()
        self.stack: list[ast.AST] = []
        self.hits: list[ScanHit] = []
        self.unknowns: list[UnknownItem] = []
        self.defined_functions: set[str] = set()

    def visit(self, node: ast.AST) -> None:
        self.stack.append(node)
        try:
            super().visit(node)
        finally:
            self.stack.pop()

    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
        self.defined_functions.add(node.name)
        previous = dict(self.env.names)
        seed_function_params(node, self.env)
        self.generic_visit(node)
        self.env.names = previous

    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
        self.defined_functions.add(node.name)
        previous = dict(self.env.names)
        seed_function_params(node, self.env)
        self.generic_visit(node)
        self.env.names = previous

    def visit_Assign(self, node: ast.Assign) -> None:
        for target in node.targets:
            apply_assign(target, node.value, self.env)
        self.generic_visit(node)

    def visit_AnnAssign(self, node: ast.AnnAssign) -> None:
        if node.value is not None:
            apply_assign(node.target, node.value, self.env)
        self.generic_visit(node)

    def visit_Call(self, node: ast.Call) -> None:
        self._inspect_call(node)
        self.generic_visit(node)

    def _inspect_call(self, node: ast.Call) -> None:
        name = call_name(node)
        short = name.split(".")[-1] if name else ""
        fn = _function_at(self.stack)
        lineno = int(getattr(node, "lineno", 1) or 1)
        end = int(getattr(node, "end_lineno", lineno) or lineno)
        snippet = _snippet(self.source, lineno, end)

        if short in SQL_SINKS or name.endswith(".execute"):
            self._sql(node, lineno, end, fn, snippet)
            return
        if name in CMD_SINKS or short in {"system", "popen"}:
            self._cmd(node, lineno, end, fn, snippet, shell=True)
            return
        if name in SUBPROCESS or short in {"run", "Popen", "call", "check_output", "check_call"} and "subprocess" in name:
            self._cmd(node, lineno, end, fn, snippet, shell=keyword_true(node, "shell"))
            return
        if name in PATH_SINKS or short in PATH_SINKS:
            self._path(node, lineno, end, fn, snippet)
            return
        if name in DESER_SINKS or short in {"loads", "load"} and any(part in name for part in ("pickle", "marshal", "yaml")):
            self._deser(node, name, lineno, end, fn, snippet)
            return
        if name in SSRF_SINKS or short in {"urlopen", "get", "post"} and any(part in name for part in ("request", "httpx", "urllib")):
            self._ssrf(node, lineno, end, fn, snippet)
            return
        if name in XSS_SINKS or short == "Markup":
            self._xss(node, lineno, end, fn, snippet)
            return
        if name in WEAK_HASH or short in {"md5", "sha1"}:
            self._hash(node, lineno, end, fn, snippet)
            return
        if short == "Template" and keyword_true(node, "autoescape") is False:
            pass

    def _emit(self, rule_id: str, node: ast.AST, lineno: int, end: int, fn: str, snippet: str, taint: str, missing: list[str]) -> None:
        self.hits.append(
            ScanHit(
                rule_id=rule_id,
                path=self.path,
                start_line=lineno,
                end_line=end,
                function=fn,
                snippet=snippet,
                taint=taint,
                missing=missing,
                node=node,
            )
        )

    def _arg0(self, node: ast.Call) -> ast.AST | None:
        return node.args[0] if node.args else None

    def _sql(self, node: ast.Call, lineno: int, end: int, fn: str, snippet: str) -> None:
        first = self._arg0(node)
        if first is None:
            return
        if is_constant_str(first):
            return
        taint = expr_taint(first, self.env)
        missing: list[str] = []
        if isinstance(first, ast.Call):
            missing.append(f"callee:{call_name(first) or 'unknown'}")
            taint = "unknown"
        if is_concat_or_format(first) or taint != "clean":
            self._emit("py-sql-concat", node, lineno, end, fn, snippet, taint, missing)

    def _cmd(self, node: ast.Call, lineno: int, end: int, fn: str, snippet: str, shell: bool) -> None:
        first = self._arg0(node)
        if first is None:
            return
        taint = expr_taint(first, self.env)
        if not shell and isinstance(first, ast.List) and taint == "clean":
            return
        if not shell and isinstance(first, ast.List) and all(is_constant_str(item) or isinstance(item, ast.Name) for item in first.elts):
            if taint != "tainted" and not any(is_concat_or_format(item) for item in first.elts):
                if not shell:
                    return
        if shell or is_concat_or_format(first) or taint == "tainted":
            missing = [] if taint != "unknown" else [f"command:{name_of(first) or call_name(first) or 'expr'}"]
            self._emit("py-cmd-shell", node, lineno, end, fn, snippet, taint, missing)

    def _path(self, node: ast.Call, lineno: int, end: int, fn: str, snippet: str) -> None:
        first = self._arg0(node)
        if first is None:
            return
        if is_constant_str(first):
            return
        taint = expr_taint(first, self.env)
        if taint == "clean":
            return
        missing = [] if taint != "unknown" else [f"path:{name_of(first) or 'expr'}"]
        self._emit("py-path-join", node, lineno, end, fn, snippet, taint, missing)

    def _deser(self, node: ast.Call, name: str, lineno: int, end: int, fn: str, snippet: str) -> None:
        if "yaml.load" in name:
            loaders = [call_name(item.value) if isinstance(item.value, ast.Attribute | ast.Name | ast.Call) else name_of(item.value) for item in node.keywords if item.arg == "Loader"]
            if any(item.split(".")[-1] in SAFE_YAML for item in loaders if item):
                return
        first = self._arg0(node)
        if first is None:
            return
        if is_constant_str(first):
            return
        taint = expr_taint(first, self.env)
        missing = [] if taint != "unknown" else [f"payload:{name_of(first) or 'expr'}"]
        self._emit("py-pickle-load", node, lineno, end, fn, snippet, taint, missing)

    def _ssrf(self, node: ast.Call, lineno: int, end: int, fn: str, snippet: str) -> None:
        first = self._arg0(node)
        if first is None:
            return
        if is_constant_str(first):
            return
        taint = expr_taint(first, self.env)
        if taint == "clean":
            return
        missing = [] if taint != "unknown" else [f"url:{name_of(first) or 'expr'}"]
        self._emit("py-ssrf-url", node, lineno, end, fn, snippet, taint, missing)

    def _xss(self, node: ast.Call, lineno: int, end: int, fn: str, snippet: str) -> None:
        first = self._arg0(node)
        if first is None:
            return
        if is_constant_str(first):
            return
        taint = expr_taint(first, self.env)
        missing = [] if taint != "unknown" else [f"html:{name_of(first) or 'expr'}"]
        self._emit("py-xss-markup", node, lineno, end, fn, snippet, taint, missing)

    def _hash(self, node: ast.Call, lineno: int, end: int, fn: str, snippet: str) -> None:
        first = self._arg0(node)
        if first is None:
            return
        names = {fn.lower(), name_of(first).lower()}
        if isinstance(first, ast.Call) and first.args:
            names.add(name_of(first.args[0]).lower())
            names.add(name_of(first.func).lower())
        if isinstance(first, ast.Attribute):
            names.add(name_of(first.value).lower())
        if not names & PASSWORD_NAMES and fn.lower() not in {"store_password", "hash_password", "set_password"}:
            return
        taint = expr_taint(first, self.env)
        if taint == "clean":
            return
        self._emit("py-weak-password-hash", node, lineno, end, fn, snippet, taint, [])


def scan_source(path: str, source: str) -> tuple[list[ScanHit], list[UnknownItem], bool]:
    if not source.strip():
        return [], [], True
    try:
        tree = ast.parse(source)
    except SyntaxError as exc:
        unknown = UnknownItem(
            code="syntax_error",
            locator=f"{path}:{exc.lineno or 1}",
            message=f"{path} is not valid Python and was not executed. Static parse failed.",
            path=path,
        )
        return [], [unknown], False
    visitor = RuleVisitor(path, source)
    visitor.visit(tree)
    return visitor.hits, visitor.unknowns, True


def hits_to_findings(hits: list[ScanHit], method: str = "ast_rules") -> list[Finding]:
    findings: list[Finding] = []
    for index, hit in enumerate(hits, start=1):
        rule = get_rule(hit.rule_id)
        locator = f"{hit.path}:{hit.start_line}"
        findings.append(
            Finding(
                finding_id=f"F{index:03d}-{rule.family}",
                rule_id=rule.rule_id,
                family=rule.family,
                cwe=rule.cwe,
                severity=rule.severity,
                path=hit.path,
                start_line=hit.start_line,
                end_line=hit.end_line,
                function=hit.function,
                snippet=hit.snippet,
                missing_context=hit.missing,
                method=method,
                evidence_locator=locator,
                summary=rule.message,
                references=rule.references,
            )
        )
    return findings


def scan_changeset(change: ChangeSet) -> tuple[list[Finding], list[UnknownItem]]:
    hits: list[ScanHit] = []
    unknowns: list[UnknownItem] = []
    for item in change.files:
        if not item.path.endswith(".py"):
            continue
        source = item.after if item.after.strip() else item.before
        file_hits, file_unknowns, _ok = scan_source(item.path, source)
        if item.added_lines:
            file_hits = [hit for hit in file_hits if _overlaps_change(hit, item.added_lines)]
        hits.extend(file_hits)
        unknowns.extend(file_unknowns)
    findings = hits_to_findings(hits)
    return findings, unknowns


def _overlaps_change(hit: ScanHit, added: list[int]) -> bool:
    if not added:
        return True
    span = set(range(hit.start_line, hit.end_line + 1))
    return bool(span & set(added))