# ai_linter.py
import anthropic
import json
import subprocess
import sys
from pathlib import Path

client = anthropic.Anthropic()

LINTING_SYSTEM = """You are a senior code reviewer acting as an AI linting tool.
Analyze the provided code for:

1. Security vulnerabilities (SQL injection, XSS, hardcoded secrets, unsafe eval)
2. Performance anti-patterns (N+1 queries, unnecessary re-renders, unbounded loops)
3. Error handling gaps (unhandled promise rejections, missing try/catch on async ops)
4. Memory leak patterns (event listeners not removed, timers not cleared)
5. Team convention violations (from context provided)

For each issue:
- Provide file:line reference
- Severity: error | warning | info
- Short rule name (snake_case)
- One-sentence description
- Code fix suggestion

Return JSON array of findings. Return empty array [] if no issues found.
Do NOT report issues already caught by ESLint/Pylint."""


def run_ai_lint(file_path: str, existing_lint_output: str = "") -> list[dict]:
    """Run AI linting on a file."""
    source = Path(file_path).read_text()

    context = f"Existing linter found: {existing_lint_output}" if existing_lint_output else ""

    message = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=2048,
        system=LINTING_SYSTEM,
        messages=[{
            "role": "user",
            "content": f"File: {file_path}\n{context}\n\nCode:\n{source}"
        }]
    )

    response = message.content[0].text
    if "```json" in response:
        response = response.split("```json")[1].split("```")[0]

    try:
        return json.loads(response.strip())
    except json.JSONDecodeError:
        return []


def format_findings(findings: list[dict], file_path: str) -> str:
    if not findings:
        return ""

    lines = [f"\nAI Lint: {file_path}"]
    for f in findings:
        severity = f.get("severity", "warning").upper()
        line = f.get("line", "?")
        rule = f.get("rule", "unknown")
        desc = f.get("description", "")
        lines.append(f"  {severity} line {line} [{rule}]: {desc}")
        if fix := f.get("fix"):
            lines.append(f"    Fix: {fix}")
    return "\n".join(lines)


if __name__ == "__main__":
    files = sys.argv[1:]
    total_issues = 0
    for f in files:
        findings = run_ai_lint(f)
        if findings:
            print(format_findings(findings, f))
            total_issues += len([x for x in findings if x.get("severity") == "error"])

    sys.exit(1 if total_issues > 0 else 0)

def lint_file_with_chain(file_path: str) -> list[dict]:
    """Run ESLint first, then pass output to AI linter."""
    import subprocess

    # Run ESLint
    result = subprocess.run(
        ['npx', 'eslint', '--format', 'compact', file_path],
        capture_output=True, text=True
    )
    eslint_output = result.stdout.strip()

    # AI layer with ESLint context
    return run_ai_lint(file_path, existing_lint_output=eslint_output)

# checkers/no_print_statements.py
"""Pylint checker: disallow print() calls in production code."""
from pylint.checkers import BaseChecker
from pylint.interfaces import IAstroidChecker
import astroid


class NoPrintStatementChecker(BaseChecker):
    __implements__ = IAstroidChecker

    name = 'no-print-statements'
    msgs = {
        'W9001': (
            'print() call found — use logging instead',
            'no-print-statement',
            'Use the logging module instead of print() for production output.',
        ),
    }
    options = (
        (
            'allow-print-in-tests',
            {
                'default': True,
                'type': 'yn',
                'metavar': '<y or n>',
                'help': 'Allow print() calls in test files (test_*.py)',
            },
        ),
    )

    def visit_call(self, node: astroid.Call) -> None:
        if isinstance(node.func, astroid.Name) and node.func.name == 'print':
            filename = node.root().file or ''
            if self.config.allow_print_in_tests and 'test_' in filename:
                return
            self.add_message('no-print-statement', node=node)


def register(linter):
    linter.register_checker(NoPrintStatementChecker(linter))

# Cost-aware wrapper
import hashlib
import json
from pathlib import Path

CACHE_DIR = Path(".ai-lint-cache")
CACHE_DIR.mkdir(exist_ok=True)

def cached_ai_lint(file_path: str) -> list[dict]:
    content = Path(file_path).read_bytes()
    file_hash = hashlib.sha256(content).hexdigest()[:16]
    cache_file = CACHE_DIR / f"{file_hash}.json"

    if cache_file.exists():
        return json.loads(cache_file.read_text())

    findings = run_ai_lint(file_path)
    cache_file.write_text(json.dumps(findings))
    return findings