import hashlib
import json
import sys
from pathlib import Path
import tokenize

import pytest

sys.path.insert(0, "/app/vendor/pycqa-bandit")
from bandit.core.issue import Issue
from bandit.core.tester import BanditTester
from bandit.plugins.trojansource import BIDI_CHARACTERS, trojansource

FIXTURES = Path("/tests/fixtures")
OUTPUT = Path("/app/output.json")
EXPECTED_NAMES = ["clean_issue.py", "legacy_latin1.py", "trojansource.py"]


class Metrics:
    def note_nosec(self):
        pass

    def note_skipped_test(self):
        pass


class TestSet:
    def __init__(self, tests):
        self.tests = tests

    def get_tests(self, checktype):
        return self.tests if checktype == "File" else []


def run_file(path, tests=None, context_range=None):
    data = path.read_bytes()
    tester = BanditTester(TestSet(tests or [trojansource]), False, {}, Metrics())
    tester.run_tests({
        "file_data": data,
        "filename": str(path),
        "lineno": 0,
        "linerange": context_range or [0, 1],
        "col_offset": 0,
    }, "File")
    return tester.results


def independent_location(path):
    data = path.read_bytes()
    with path.open("rb") as source:
        encoding, _ = tokenize.detect_encoding(source.readline)
    text = data.decode(encoding)
    for lineno, line in enumerate(text.splitlines(), 1):
        for character in BIDI_CHARACTERS:
            if character in line:
                return lineno, line.index(character) + 1
    return None


def load_output():
    assert OUTPUT.is_file(), "producer did not create /app/output.json"
    payload = json.loads(OUTPUT.read_text())
    assert payload["output_schema_version"] == "bandit_trojan_repair.v1"
    assert list(payload) == ["cases", "output_schema_version", "summary"]
    return payload


def case_map(payload):
    return {case["name"]: case for case in payload["cases"]}


def test_gate_schema_and_fixture_coverage():
    payload = load_output()
    cases = case_map(payload)
    assert [case["name"] for case in payload["cases"]] == EXPECTED_NAMES
    assert set(cases) == set(EXPECTED_NAMES)
    assert payload["summary"]["total_findings"] == 1
    assert payload["summary"]["clean_files"] == 2


def test_core_independent_security_location():
    payload = case_map(load_output())
    expected = independent_location(FIXTURES / "trojansource.py")
    assert expected == (4, 25)
    issues = payload["trojansource.py"]["issues"]
    assert len(issues) == 1
    issue = issues[0]
    assert issue["test_id"] == "B613"
    assert issue["severity"] == "HIGH"
    assert issue["confidence"] == "MEDIUM"
    assert (issue["lineno"], issue["col_offset"]) == expected
    assert issue["linerange"] == [4]


def test_core_context_enrichment_and_bytes():
    payload = case_map(load_output())
    issue = payload["trojansource.py"]["issues"][0]
    assert issue["fname"] == "/app/workload/fixtures/trojansource.py"
    assert issue["cwe_id"] == 838
    assert issue["has_fdata"] is True
    assert run_file(FIXTURES / "trojansource.py")[0].linerange == [4]


def test_edge_encoding_clean_and_generic_fallback():
    payload = case_map(load_output())
    assert payload["legacy_latin1.py"]["issues"] == []
    assert payload["clean_issue.py"]["issues"] == []

    def generic(context):
        return Issue(severity="LOW", confidence="LOW", text="generic")

    generic._test_id = "X001"
    generic_results = run_file(FIXTURES / "clean_issue.py", [generic], [7, 8])
    assert len(generic_results) == 1
    assert generic_results[0].linerange == [7, 8]
    assert generic_results[0].lineno == 0


def test_gate_protects_nonmutable_source_assets():
    expected = {
        "bandit/core/issue.py": "d2829a8c785f7ad9029be05125a9c655f59e7a90eed89cddb56612a954832beb",
        "bandit/core/context.py": "dcdd0367efcd944c8e5256deed90d4765f07a5be0af6a3a249ca8e4b84f597b5",
    }
    for relative, digest in expected.items():
        actual = hashlib.sha256((Path("/app/vendor/pycqa-bandit") / relative).read_bytes()).hexdigest()
        assert actual == digest, relative