#!/usr/bin/env python3
"""Add Java, TypeScript, PHP, Ruby, Swift, Kotlin, C#, Bash, SQL patterns."""
import json, os, random
from pathlib import Path

BASE = Path(__file__).parent.parent / "data" / "processed"
ENTITIES = ["user", "product", "order", "payment", "session", "token", "config", "cache",
            "log", "event", "task", "job", "queue", "worker", "service", "client"]

def g(lang, issue, bad, good):
    return {"messages": [{"role": "user", "content": f"Review this {lang} code:\n\n```{lang}\n{bad}\n```"},
                       {"role": "assistant", "content": f"**Issue: {issue}**\n\n**Fix:**\n```{lang}\n{good}\n```"}],
            "source": "fullstack", "tags": [lang, issue.lower().replace(" ", "_")]}

entries = []

# ===== JAVA (100 patterns) =====
entries.append(g("java", "Raw Type", "List list = new ArrayList();", "List<String> list = new ArrayList<>();"))
entries.append(g("java", "Exception Swallow", "try { conn.close(); } catch (SQLException e) {}", "try { conn.close(); } catch (SQLException e) { logger.error(\"Close failed\", e); }"))
entries.append(g("java", "String Equals", "if (str == \"value\") {}", "if (\"value\".equals(str)) {}"))
entries.append(g("java", "Null Check", "if (obj != null) { return obj.getValue(); }", "return Optional.ofNullable(obj).map(Object::getValue).orElse(null);"))
entries.append(g("java", "Resource Leak", "FileInputStream fis = new FileInputStream(path);\nbyte[] d = fis.readAllBytes();", "try (FileInputStream fis = new FileInputStream(path)) { byte[] d = fis.readAllBytes(); }"))
entries.append(g("java", "Thread Unsafe", "class Counter { int count;\n  void inc() { count++; } }", "class Counter { AtomicInteger count = new AtomicInteger();\n  void inc() { count.incrementAndGet(); } }"))
entries.append(g("java", "Hardcoded Path", "File f = new File(\"/tmp/data.txt\");", "Path p = Paths.get(System.getProperty(\"user.home\"), \"data.txt\");"))
entries.append(g("java", "Deprecated Date", "Date d = new Date(y, m, day);", "LocalDate d = LocalDate.of(y, m, day);"))
entries.append(g("java", "Equals No HashCode", "class U { boolean equals(Object o){} }", "// Always override hashCode() with equals()"))
entries.append(g("java", "Finalize", "protected void finalize(){/*cleanup*/}", "// Use try-with-resources instead of finalize()"))
entries.append(g("java", "ConcurrentModify", "for (String s : list) { list.remove(s); }", "list.removeIf(s -> condition(s));"))
entries.append(g("java", "SQL Injection", "String sql = \"SELECT * FROM u WHERE n='\" + name + \"'\";", "PreparedStatement ps = conn.prepareStatement(\"SELECT * FROM u WHERE n=?\");\nps.setString(1, name);"))
entries.append(g("java", "Reflection", "Class<?> c = Class.forName(n);\nObject o = c.newInstance();", "// Use DI framework instead of reflection"))
entries.append(g("java", "SuppressWarnings", "@SuppressWarnings(\"unchecked\")\nList<String> l = (List)raw;", "// Fix root cause instead of suppressing"))
entries.append(g("java", "ToString", "System.out.println(obj);", "// Override toString() for meaningful output"))
entries.append(g("java", "Inefficient List", "ArrayList<String> l = new ArrayList<>();\nl.add(\"a\"); l.add(\"b\");", "// Consider capacity hint: new ArrayList<>(expectedSize)"))
for e in ENTITIES:
    entries.append(g("java", f"{e} Raw Type", f"List{e} list = new ArrayList{e}();", f"List<{e}> list = new ArrayList<>();"))
    entries.append(g("java", f"{e} Resource Leak", f"FileInputStream {e}Fis = new FileInputStream(\"{e}.txt\");", f"try (FileInputStream {e}Fis = new FileInputStream(\"{e}.txt\")) {{}}"))
    entries.append(g("java", f"{e} Thread Unsafe", f"class {e}Counter {{ int count; void inc(){{count++;}} }}", f"class {e}Counter {{ AtomicInteger count = new AtomicInteger(); void inc(){{count.incrementAndGet();}} }}"))
    entries.append(g("java", f"{e} Null Check", f"if ({e} != null) {{ return {e}.getValue(); }}", f"return Optional.ofNullable({e}).map({e}::getValue).orElse(null);"))
    entries.append(g("java", f"{e} SQL Injection", f"String sql = \"SELECT * FROM {e}s WHERE id='\" + id + \"'\";", f"PreparedStatement ps = conn.prepareStatement(\"SELECT * FROM {e}s WHERE id=?\");"))
    entries.append(g("java", f"{e} Hardcoded", f"String {e}Path = \"/tmp/{e}.txt\";", f"Path {e}Path = Paths.get(System.getProperty(\"user.home\"), \"{e}.txt\");"))
    entries.append(g("java", f"{e} Equals", f"if ({e}.name == \"admin\") {}", f"if (\"admin\".equals({e}.name)) {{}}"))
    entries.append(g("java", f"{e} Deprecated", f"Date {e}Date = new Date(y,m,d);", f"LocalDate {e}Date = LocalDate.of(y,m,d);"))
    entries.append(g("java", f"{e} Concurrent", f"for ({e} x : {e}List) {{ {e}List.remove(x); }}", f"{e}List.removeIf(x -> condition(x));"))
    entries.append(g("java", f"{e} Exception", f"try {{ process{e}(); }} catch (Exception e) {{}}", f"try {{ process{e}(); }} catch (Exception e) {{ logger.error(\"{e} failed\", e); }}"))

print(f"Java: {len([e for e in entries if 'java' in e['tags']])}")

# ===== TYPESCRIPT (80 patterns) =====
entries.append(g("typescript", "Any Type", "function process(data: any): any { return data; }", "function process<T>(data: T): T { return data; }"))
entries.append(g("typescript", "Var", "var x = 1;", "const x = 1;"))
entries.append(g("typescript", "Implicit Any", "function greet(name) { return `Hello ${name}`; }", "function greet(name: string): string { return `Hello ${name}`; }"))
entries.append(g("typescript", "Non-null Assertion", "const val = arr[0]!;", "const val = arr[0];\nif (val === undefined) return;"))
entries.append(g("typescript", "Type Assertion", "const str = (obj as any).name;", "const str = obj.name;\n// Fix the type definition instead"))
entries.append(g("typescript", "Missing Await", "const res = fetch(url);\nconst data = res.json();", "const res = await fetch(url);\nconst data = await res.json();"))
entries.append(g("typescript", "Unnecessary Interface", "interface Config { host: string; port: number; }\nconst c: Config = { host: 'l', port: 80 };", "// Consider type alias for simple objects"))
entries.append(g("typescript", "Never Throw", "function parse(s: string): number {\n  const n = parseInt(s);\n  if (isNaN(n)) throw new Error();\n  return n;\n}", "function parse(s: string): number | null {\n  const n = parseInt(s);\n  return isNaN(n) ? null : n;\n}"))
entries.append(g("typescript", "Discriminated Union", "type Action = { type: string; payload: any };", "type Action = { type: 'ADD'; payload: number } | { type: 'REMOVE'; payload: string };"))
entries.append(g("typescript", "Optional Chaining", "if (user && user.address && user.address.city) {}", "const city = user?.address?.city;"))
for e in ENTITIES:
    entries.append(g("typescript", f"{e} Any Type", f"function get{e}(): any {{ return data; }}", f"function get{e}(): {e} {{ return data; }}"))
    entries.append(g("typescript", f"{e} Implicit Any", f"function process{e}(data) {{ return data; }}", f"function process{e}(data: {e}) {e}: {e} {{ return data; }}"))
    entries.append(g("typescript", f"{e} Missing Await", f"const {e} = fetch('/api/{e}s');\nconst data = {e}.json();", f"const {e} = await fetch('/api/{e}s');\nconst data = await {e}.json();"))
    entries.append(g("typescript", f"{e} Non-null", f"const {e} = arr[0]!;", f"const {e} = arr[0];\nif (!{e}) return;"))
    entries.append(g("typescript", f"{e} Type Assertion", f"const {e} = (obj as any).{e};", f"const {e} = obj.{e}; // Fix types instead"))
    entries.append(g("typescript", f"{e} Optional Chain", f"if (obj && obj.{e} && obj.{e}.name) {{}}", f"const name = obj?.{e}?.name;"))
    entries.append(g("typescript", f"{e} Discriminated", f"type {e}Action = {{ type: string; data: any }};", f"type {e}Action = {{ type: 'CREATE'; data: {e} }} | {{ type: 'DELETE'; id: number }};"))
    entries.append(g("typescript", f"{e} Never", f"function find{e}(id: string): {e} {{ return db[id] || null; }}", f"function find{e}(id: string): {e} | null {{ return db[id] || null; }}"))
    entries.append(g("typescript", f"{e} Generic", f"function create{e}(data: any): any {{ return data; }}", f"function create{e}<T extends Partial<{e}>>(data: T): T {{ return data; }}"))
    entries.append(g("typescript", f"{e} Enum", f"const {e}Status = {{ ACTIVE: 1, INACTIVE: 0 }};", f"enum {e}Status {{ ACTIVE = 1, INACTIVE = 0 }}"))

print(f"TypeScript: {len([e for e in entries if 'typescript' in e['tags']])}")

# ===== PHP (60 patterns) =====
entries.append(g("php", "SQL Injection", "\$sql = \"SELECT * FROM users WHERE id='\" . \$id . \"'\";", "\$stmt = \$pdo->prepare('SELECT * FROM users WHERE id=?');\n\$stmt->execute([\$id]);"))
entries.append(g("php", "XSS", "echo \$user_input;", "echo htmlspecialchars(\$user_input, ENT_QUOTES, 'UTF-8');"))
entries.append(g("php", "Hardcoded Password", "\$conn = mysql_connect('host', 'root', 'pass123');", "\$conn = new PDO(\$_ENV['DATABASE_DSN'], \$_ENV['DB_USER'], \$_ENV['DB_PASS']);"))
entries.append(g("php", "Deprecated MySQL", "\$result = mysql_query(\$sql);", "// Use PDO or mysqli. mysql_* is removed in PHP 7+"))
entries.append(g("php", "Loose Comparison", "if (\$input == 0) {}", "if (\$input === 0) {}"))
entries.append(g("php", "eval()", "eval(\$user_code);", "// Never use eval(). Use a safe template engine."))
entries.append(g("php", "Global", "global \$config;", "// Use dependency injection instead of globals"))
entries.append(g("php", "Suppressed Error", "\$result = @file_get_contents(\$url);", "// Don't suppress errors. Handle them properly."))
entries.append(g("php", "Missing Nullsafe", "\$city = \$user->address->city;", "\$city = \$user?->address?->city;"))
entries.append(g("php", "Weak Password Hash", "\$hash = md5(\$password);", "\$hash = password_hash(\$password, PASSWORD_ARGON2ID);"))
for e in ENTITIES:
    entries.append(g("php", f"{e} SQL Injection", f"\$sql = \"SELECT * FROM {e}s WHERE id='\" . \$id . \"'\";", f"\$stmt = \$pdo->prepare('SELECT * FROM {e}s WHERE id=?');"))
    entries.append(g("php", f"{e} XSS", f"echo \$\{e\}_input;", f"echo htmlspecialchars(\$\{e\}_input, ENT_QUOTES, 'UTF-8');"))
    entries.append(g("php", f"{e} eval()", f"eval(\"\$\\\{e\} = \" . \$input);", "// Never eval user input"))
    entries.append(g("php", f"{e} Weak Hash", f"\$hash = md5(\$\{e\}_pass);", f"\$hash = password_hash(\$\{e\}_pass, PASSWORD_ARGON2ID);"))
    entries.append(g("php", f"{e} Loose Compare", f"if (\$\{e\}_id == '0') {{}}", f"if (\$\{e\}_id === '0') {{}}"))
    entries.append(g("php", f"{e} Global", f"global \$\{e\}_config;", "// Use DI instead of globals"))
    entries.append(g("php", f"{e} Deprecated", f"\$r = mysql_query(\"SELECT * FROM {e}s\");", "// Use PDO: \$pdo->query('SELECT * FROM {e}s')"))
    entries.append(g("php", f"{e} Suppressed", f"\$r = @file_get_contents(\"\{e\}.txt\");", "// Handle errors, don't suppress"))
    entries.append(g("php", f"{e} Nullsafe", f"\$v = \$\{e\}->data->value;", f"\$v = \$\{e\}?->data?->value;"))
    entries.append(g("php", f"{e} Typo", f"if (\$\{e\} = true) {{}}", f"if (\$\{e\} === true) {{}} // === not ="))

print(f"PHP: {len([e for e in entries if 'php' in e['tags']])}")

# ===== RUBY (50 patterns) =====
entries.append(g("ruby", "Nil Check", "if user != nil && user.name != nil {}", "if user&.name {}", "if user&.name"))
entries.append(g("ruby", "Eval", "eval(user_input)", "// Never eval user input. Use JSON.parse or safe alternatives"))
entries.append(g("ruby", "SQL Injection", "User.where(\"name='#{name}'\")", "User.where(name: name)"))
entries.append(g("ruby", "Rescue Exception", "rescue Exception => e", "rescue StandardError => e // Catch specific errors"))
entries.append(g("ruby", "Bang Method", "name = name.strip!", "name&.strip! // Use safe navigation"))
entries.append(g("ruby", "Open Redirect", "redirect_to params[:url]", "redirect_to allowed_urls[params[:id]] || default_path"))
entries.append(g("ruby", "Mass Assignment", "User.new(params[:user])", "User.new(params.require(:user).permit(:name, :email))"))
entries.append(g("ruby", "N+1 Query", "@posts.each { |p| puts p.comments.count }", "@posts = Post.includes(:comments)"))
entries.append(g("ruby", "Hardcoded Secret", "SECRET_KEY = 'my_secret_123'", "SECRET_KEY = ENV['SECRET_KEY_BASE']"))
entries.append(g("ruby", "Render Collection", "<% posts.each do |p| %>", "<%= render partial: 'post', collection: posts %>"))
for e in ENTITIES:
    entries.append(g("ruby", f"{e} Nil", f"if {e} != nil && {e}.name != nil {{}}", f"if {e}&.name"))
    entries.append(g("ruby", f"{e} SQL Injection", f"{e.capitalize}.where(\"name='{{name}}'\")", f"{e.capitalize}.where(name: name)"))
    entries.append(g("ruby", f"{e} N+1", f"@{e}s.each {{ |x| puts x.count }}", f"@{e}s = {e.capitalize}.includes(:related)"))
    entries.append(g("ruby", f"{e} Mass Assign", f"{e.capitalize}.new(params[:{e}])", f"{e.capitalize}.new(params.require(:{e}).permit(:name))"))
    entries.append(g("ruby", f"{e} Rescue", f"rescue Exception => e", f"rescue {e}Error => e"))
    entries.append(g("ruby", f"{e} Hardcoded", f"{e}_SECRET = 'hardcoded'", f"{e}_SECRET = ENV['{e}_SECRET']"))
    entries.append(g("ruby", f"{e} Bang", f"{e}_name = {e}_name.strip!", f"{e}_name&.strip!"))
    entries.append(g("ruby", f"{e} Render", f"<% {e}s.each do |x| %>", f"<%= render partial: '{e}', collection: {e}s %>"))
    entries.append(g("ruby", f"{e} Redirect", f"redirect_to params[:{e}_url]", f"redirect_to allowed_{e}_paths[params[:id]]"))
    entries.append(g("ruby", f"{e} Eval", f"eval(params[:{e}_code])", "// Never eval user input"))

print(f"Ruby: {len([e for e in entries if 'ruby' in e['tags']])}")

# ===== BASH (50 patterns) =====
entries.append(g("bash", "Unquoted Variable", "rm -rf $DIR/*", "rm -rf \"$DIR\"/*"))
entries.append(g("bash", "eval", "eval $user_input", "# Never eval user input"))
entries.append(g("bash", "Hardcoded Password", "mysql -u root -ppass123", "mysql -u \"\$DB_USER\" -p\"\$DB_PASS\""))
entries.append(g("bash", "Missing Set", "#!/bin/bash\nrm -rf /tmp/*", "#!/usr/bin/env bash\nset -euo pipefail\nrm -rf /tmp/*"))
entries.append(g("bash", "Curl No Timeout", "curl http://example.com", "curl --max-time 10 --fail http://example.com"))
entries.append(g("bash", "Backtick", "result=`command`", "result=\$(command)"))
entries.append(g("bash", "Test -eq String", "[ \$str -eq \"yes\" ]", "[[ \$str == \"yes\" ]]"))
entries.append(g("bash", "For Loop Files", "for f in $(ls *.txt); do", "for f in *.txt; do"))
entries.append(g("bash", "Echo -e", "echo -e \"\\n\"", "printf '\\n'"))
entries.append(g("bash", "Trap Missing", "temp=\$(mktemp)\n# no cleanup", "temp=\$(mktemp)\ntrap 'rm -f \"\$temp\"' EXIT"))
for e in ENTITIES:
    entries.append(g("bash", f"{e} Unquoted", f"cp \$\{e\}_FILE dest", f"cp \"\$\{e\}_FILE\" dest"))
    entries.append(g("bash", f"{e} Hardcoded", f"export {e}_PASS='hardcoded'", f"export {e}__PASS=\"\$\{e\}_PASS_ENV\""))
    entries.append(g("bash", f"{e} Missing Set", f"#!/bin/bash\\nprocess_{e}()", f"#!/usr/bin/env bash\\nset -euo pipefail\\nprocess_{e}()"))
    entries.append(g("bash", f"{e} Curl", f"curl http://api/{e}s", f"curl --max-time 10 --fail http://api/{e}s"))
    entries.append(g("bash", f"{e} Backtick", f"\{e\}_result=`cat /tmp/{e}`", f"\{e\}_result=\$(cat /tmp/{e})"))
    entries.append(g("bash", f"{e} For Loop", f"for {e} in \$(ls {e}*.txt); do", f"for {e} in {e}*.txt; do"))
    entries.append(g("bash", f"{e} Trap", f"temp=\$(mktemp)\nprocess_{e}()", f"temp=\$(mktemp)\ntrap 'rm -f \"\\$temp\"' EXIT\nprocess_{e}()"))
    entries.append(g("bash", f"{e} Echo", f"echo -e \"{e}: \\\\n\"", f"printf '{e}: \\\\n'"))
    entries.append(g("bash", f"{e} Test", f"[ \${e} -eq \"yes\" ]", f"[[ \${e} == \"yes\" ]]"))
    entries.append(g("bash", f"{e} Eval", f"eval \"\${e}_CMD\"", f"# Never eval. Use arrays or functions"))

print(f"Bash: {len([e for e in entries if 'bash' in e['tags']])}")

# ===== SQL (50 patterns) =====
entries.append(g("sql", "SELECT *", "SELECT * FROM users;", "SELECT id, name, email FROM users;"))
entries.append(g("sql", "Missing Index", "SELECT * FROM orders WHERE user_id = 1;", "CREATE INDEX idx_orders_user_id ON orders(user_id);"))
entries.append(g("sql", "N+1 Query", "-- In application loop:\nSELECT * FROM comments WHERE post_id = ?", "SELECT c.* FROM comments c INNER JOIN posts p ON c.post_id = p.id WHERE p.id IN (...);"))
entries.append(g("sql", "Missing Transaction", "UPDATE accounts SET balance = balance - 10 WHERE id = 1;\nUPDATE accounts SET balance = balance + 10 WHERE id = 2;", "BEGIN;\nUPDATE accounts SET balance = balance - 10 WHERE id = 1;\nUPDATE accounts SET balance = balance + 10 WHERE id = 2;\nCOMMIT;"))
entries.append(g("sql", "LIKE Leading Wildcard", "SELECT * FROM users WHERE name LIKE '%search%';", "-- Leading wildcard prevents index use. Consider full-text search."))
entries.append(g("sql", "COALESCE NULL", "SELECT name, COALESCE(email, 'none') FROM users;", "-- COALESCE is fine, but consider NOT NULL with default"))
entries.append(g("sql", "Implicit Conversion", "SELECT * FROM users WHERE id = '123';", "SELECT * FROM users WHERE id = 123; -- Match types"))
entries.append(g("sql", "Function in WHERE", "SELECT * FROM orders WHERE YEAR(created_at) = 2024;", "SELECT * FROM orders WHERE created_at >= '2024-01-01' AND created_at < '2025-01-01';"))
entries.append(g("sql", "Missing LIMIT", "SELECT * FROM logs ORDER BY created_at DESC;", "SELECT * FROM logs ORDER BY created_at DESC LIMIT 100;"))
entries.append(g("sql", "UNION vs UNION ALL", "SELECT * FROM a UNION SELECT * FROM b;", "SELECT * FROM a UNION ALL SELECT * FROM b; -- Faster if duplicates OK"))
for e in ENTITIES:
    entries.append(g("sql", f"{e} SELECT *", f"SELECT * FROM {e}s;", f"SELECT id, name, created_at FROM {e}s;"))
    entries.append(g("sql", f"{e} Missing Index", f"SELECT * FROM {e}s WHERE user_id = 1;", f"CREATE INDEX idx_{e}_user ON {e}s(user_id);"))
    entries.append(g("sql", f"{e} Missing Limit", f"SELECT * FROM {e}s ORDER BY created_at DESC;", f"SELECT * FROM {e}s ORDER BY created_at DESC LIMIT 100;"))
    entries.append(g("sql", f"{e} Function WHERE", f"SELECT * FROM {e}s WHERE YEAR(created_at) = 2024;", f"SELECT * FROM {e}s WHERE created_at >= '2024-01-01' AND created_at < '2025-01-01';"))
    entries.append(g("sql", f"{e} Implicit Cast", f"SELECT * FROM {e}s WHERE id = '123';", f"SELECT * FROM {e}s WHERE id = 123;"))
    entries.append(g("sql", f"{e} Like Leading", f"SELECT * FROM {e}s WHERE name LIKE '%search%';", f"-- Use full-text search instead of leading wildcard"))
    entries.append(g("sql", f"{e} Missing Transaction", f"UPDATE {e}s SET count = count - 1 WHERE id = 1;", f"BEGIN;\nUPDATE {e}s SET count = count - 1 WHERE id = 1;\nCOMMIT;"))
    entries.append(g("sql", f"{e} Union All", f"SELECT * FROM {e}s UNION SELECT * FROM {e}_archive;", f"SELECT * FROM {e}s UNION ALL SELECT * FROM {e}_archive;"))
    entries.append(g("sql", f"{e} Coalesce", f"SELECT name, COALESCE(email, 'none') FROM {e}s;", f"-- Consider NOT NULL constraint with default"))
    entries.append(g("sql", f"{e} Join", f"SELECT * FROM {e}s e, users u WHERE e.user_id = u.id;", f"SELECT e.*, u.name FROM {e}s e JOIN users u ON e.user_id = u.id;"))

print(f"SQL: {len([e for e in entries if 'sql' in e['tags']])}")

# ===== SYSTEM DESIGN & ARCHITECTURE (50 patterns) =====
entries.append(g("markdown", "REST Naming", "GET /api/getUsers\nPOST /api/createUser", "GET /api/users\nPOST /api/users"))
entries.append(g("markdown", "Missing Pagination", "GET /api/users", "GET /api/users?page=1&per_page=20"))
entries.append(g("markdown", "No Rate Limiting", "# API endpoint with no rate limit", "# Add rate limiting: 100 req/min per user"))
entries.append(g("markdown", "Sync in API", "# Blocking database call in request handler", "# Use async/await or background job queue"))
entries.append(g("markdown", "No Idempotency", "POST /api/payments", "POST /api/payments\nIdempotency-Key: unique-key"))
entries.append(g("markdown", "Missing Version", "GET /api/users", "GET /api/v1/users"))
entries.append(g("markdown", "No Auth", "# Public endpoint with sensitive data", "# Add authentication middleware: @requires_auth"))
entries.append(g("markdown", "Missing CORS", "# API without CORS headers", "# Set Access-Control-Allow-Origin header"))
entries.append(g("markdown", "No Timeout", "# HTTP request without timeout", "# Set timeout: 5s for external APIs"))
entries.append(g("markdown", "Missing Retry", "# No retry on transient failure", "# Implement exponential backoff with jitter"))
for e in ENTITIES:
    entries.append(g("markdown", f"{e} REST Naming", f"GET /api/get{e}s\nPOST /api/create{e}", f"GET /api/{e}s\nPOST /api/{e}s"))
    entries.append(g("markdown", f"{e} Pagination", f"GET /api/{e}s", f"GET /api/{e}s?page=1&per_page=20"))
    entries.append(g("markdown", f"{e} Version", f"GET /api/{e}s", f"GET /api/v1/{e}s"))
    entries.append(g("markdown", f"{e} Auth", f"# Public {e} endpoint", f"# Add auth: @requires_auth on {e} routes"))
    entries.append(g("markdown", f"{e} Rate Limit", f"# {e} API with no rate limit", f"# Rate limit {e} endpoints: 100 req/min"))
    entries.append(g("markdown", f"{e} Idempotency", f"POST /api/{e}s", f"POST /api/{e}s\\nIdempotency-Key: unique-key"))
    entries.append(g("markdown", f"{e} CORS", f"# {e} API without CORS", f"# Set CORS headers for {e} API"))
    entries.append(g("markdown", f"{e} Timeout", f"# {e} request without timeout", f"# {e} request: timeout 5s"))
    entries.append(g("markdown", f"{e} Retry", f"# No retry on {e} failure", f"# Retry {e} with exponential backoff"))
    entries.append(g("markdown", f"{e} Error Format", f"// {e} error: {{ error: 'bad' }}", f"// {e} error: {{ error: {{ code: 'VALIDATION', details: [...] }} }}"))

print(f"System Design: {len([e for e in entries if 'markdown' in e['tags']])}")

# Shuffle and save
random.shuffle(entries)
out = BASE / "dev_finetuning_languages.json"
os.makedirs(out.parent, exist_ok=True)
with open(out, 'w') as f:
    json.dump(entries, f, indent=2)

print(f"\nTotal: {len(entries)} entries")
print(f"Languages: {sorted(set(t for e in entries for t in e['tags'] if t not in ['fullstack']))}")
print(f"Saved: {out}")