# swagger_generator.py
import ast
import os
import anthropic
import yaml

def extract_express_routes(src_dir: str) -> str:
    """Extract route definitions from JS files via simple pattern matching."""
    import re
    routes = []
    pattern = re.compile(
        r'router\.(get|post|put|delete|patch)\s*\(\s*[\'"]([^\'"]+)[\'"]',
        re.MULTILINE
    )

    for root, _, files in os.walk(src_dir):
        for f in files:
            if f.endswith('.js') or f.endswith('.ts'):
                path = os.path.join(root, f)
                content = open(path).read()
                matches = pattern.findall(content)
                if matches:
                    routes.append(f"\n# File: {path}\n{content}")

    return '\n'.join(routes)


def generate_openapi_spec(source_code: str, api_title: str) -> str:
    client = anthropic.Anthropic()

    system = """You are an OpenAPI 3.1 specification generator. When given API route handlers,
    generate a complete, valid OpenAPI 3.1 YAML spec. Include:
    - All path parameters and query parameters
    - Request body schemas with validation rules from code comments or logic
    - Response schemas for all status codes (200, 201, 400, 401, 403, 404, 500)
    - Reusable components/schemas for request/response bodies
    - Security schemes based on middleware usage
    Return ONLY the YAML. No explanations."""

    message = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=8096,
        system=system,
        messages=[{
            "role": "user",
            "content": f"Generate OpenAPI 3.1 spec for this API (title: {api_title}):\n\n{source_code}"
        }]
    )

    return message.content[0].text


def validate_openapi_yaml(spec_yaml: str) -> bool:
    """Basic validation — check required top-level keys."""
    try:
        spec = yaml.safe_load(spec_yaml)
        required = {'openapi', 'info', 'paths'}
        return required.issubset(spec.keys())
    except yaml.YAMLError:
        return False


if __name__ == "__main__":
    import sys
    src_dir = sys.argv[1] if len(sys.argv) > 1 else "./src/routes"
    output_file = sys.argv[2] if len(sys.argv) > 2 else "openapi.yaml"

    print(f"Extracting routes from {src_dir}...")
    source = extract_express_routes(src_dir)

    print("Generating OpenAPI spec with Claude...")
    spec = generate_openapi_spec(source, "My API")

    if validate_openapi_yaml(spec):
        with open(output_file, 'w') as f:
            f.write(spec)
        print(f"Spec written to {output_file}")
    else:
        print("ERROR: Generated spec failed validation")
        print(spec[:500])
        sys.exit(1)

# enrich_fastapi_docs.py
import json
import anthropic


def enrich_openapi_descriptions(openapi_json: dict) -> dict:
    """Use Claude to add descriptions to all endpoints and schemas."""
    client = anthropic.Anthropic()

    spec_str = json.dumps(openapi_json, indent=2)

    message = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=8096,
        messages=[{
            "role": "user",
            "content": f"""Add clear, concise descriptions to all paths, operations, parameters,
and schema properties in this OpenAPI spec. Keep existing values.
Add 'description' fields where missing.
Return the complete JSON.

{spec_str}"""
        }]
    )

    return json.loads(message.content[0].text)


# Usage with FastAPI
from fastapi import FastAPI
import uvicorn

app = FastAPI()

@app.on_event("startup")
async def enrich_docs():
    openapi = app.openapi()
    enriched = enrich_openapi_descriptions(openapi)
    app.openapi_schema = enriched

# spring_swagger_generator.py
import os
import re
import anthropic

def extract_spring_controllers(src_dir: str) -> list[str]:
    """Find all @RestController classes and return their source."""
    controllers = []
    for root, _, files in os.walk(src_dir):
        for f in files:
            if not f.endswith('.java'):
                continue
            path = os.path.join(root, f)
            content = open(path).read()
            if '@RestController' in content or '@Controller' in content:
                controllers.append(f"// {path}\n{content}")
    return controllers

def generate_spec_from_spring(controllers: list[str]) -> str:
    client = anthropic.Anthropic()

    combined = "\n\n".join(controllers)

    message = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=8096,
        system="""You are an OpenAPI 3.1 spec generator for Spring Boot.
Given @RestController source code:
- Extract @RequestMapping, @GetMapping, @PostMapping etc. for paths
- Parse @PathVariable, @RequestParam, @RequestBody annotations for parameters
- Infer response schemas from return types and @ResponseStatus annotations
- Extract validation constraints from @Valid, @NotNull, @Size etc.
Return a complete OpenAPI 3.1 YAML spec only.""",
        messages=[{
            "role": "user",
            "content": f"Generate OpenAPI spec from these Spring Boot controllers:\n\n{combined}"
        }]
    )
    return message.content[0].text

if __name__ == "__main__":
    import sys
    src = sys.argv[1] if len(sys.argv) > 1 else "./src/main/java"
    controllers = extract_spring_controllers(src)
    print(f"Found {len(controllers)} controller(s)")
    spec = generate_spec_from_spring(controllers)
    with open("openapi.yaml", "w") as f:
        f.write(spec)
    print("openapi.yaml written")