"""Integration tests for CLI commands."""

import pytest
import tempfile
import os
from pathlib import Path
from typer.testing import CliRunner
from docgen.cli import app


class TestCLIDetect:
    """Tests for detect command."""

    def test_detect_no_files(self):
        """Test detect with empty directory."""
        runner = CliRunner()
        
        with tempfile.TemporaryDirectory() as tmpdir:
            result = runner.invoke(app, ["detect", tmpdir])
            assert result.exit_code == 0
            assert "No endpoints found" in result.output

    def test_detect_python_fastapi(self):
        """Test detect with FastAPI code."""
        runner = CliRunner()
        
        code = '''
from fastapi import FastAPI
app = FastAPI()

@app.get("/users")
def get_users():
    return {"users": []}

@app.post("/users")
def create_user():
    return {"id": 1}
'''
        with tempfile.TemporaryDirectory() as tmpdir:
            py_file = Path(tmpdir) / "main.py"
            py_file.write_text(code)
            
            result = runner.invoke(app, ["detect", tmpdir])
            assert result.exit_code == 0
            assert "Found" in result.output or "endpoints" in result.output.lower()

    def test_detect_with_framework_filter(self):
        """Test detect with specific framework."""
        runner = CliRunner()
        
        code = '''
from flask import Flask
app = Flask(__name__)

@app.route("/items")
def get_items():
    return {"items": []}
'''
        with tempfile.TemporaryDirectory() as tmpdir:
            py_file = Path(tmpdir) / "app.py"
            py_file.write_text(code)
            
            result = runner.invoke(app, ["detect", tmpdir, "--framework", "python"])
            assert result.exit_code == 0


class TestCLIGenerate:
    """Tests for generate command."""

    def test_generate_html(self):
        """Test HTML generation."""
        runner = CliRunner()
        
        code = '''
from fastapi import FastAPI
app = FastAPI()

@app.get("/users")
def get_users():
    return {"users": []}
'''
        with tempfile.TemporaryDirectory() as tmpdir:
            py_file = Path(tmpdir) / "main.py"
            py_file.write_text(code)
            
            output_dir = Path(tmpdir) / "docs"
            result = runner.invoke(app, [
                "generate",
                tmpdir,
                "--output", str(output_dir),
                "--format", "html",
            ])
            
            assert result.exit_code == 0
            assert output_dir.exists()
            assert (output_dir / "index.html").exists()

    def test_generate_markdown(self):
        """Test Markdown generation."""
        runner = CliRunner()
        
        code = '''
from fastapi import FastAPI
app = FastAPI()

@app.get("/items")
def get_items():
    return {"items": []}
'''
        with tempfile.TemporaryDirectory() as tmpdir:
            py_file = Path(tmpdir) / "main.py"
            py_file.write_text(code)
            
            output_dir = Path(tmpdir) / "docs"
            result = runner.invoke(app, [
                "generate",
                tmpdir,
                "--output", str(output_dir),
                "--format", "markdown",
            ])
            
            assert result.exit_code == 0
            assert (output_dir / "README.md").exists()

    def test_generate_openapi(self):
        """Test OpenAPI generation."""
        runner = CliRunner()
        
        code = '''
from fastapi import FastAPI
app = FastAPI()

@app.get("/products")
def get_products():
    return {"products": []}
'''
        with tempfile.TemporaryDirectory() as tmpdir:
            py_file = Path(tmpdir) / "main.py"
            py_file.write_text(code)
            
            output_dir = Path(tmpdir) / "api"
            result = runner.invoke(app, [
                "generate",
                tmpdir,
                "--output", str(output_dir),
                "--format", "openapi",
            ])
            
            assert result.exit_code == 0
            assert (output_dir / "openapi.json").exists()

    def test_generate_with_custom_title(self):
        """Test generation with custom title."""
        runner = CliRunner()
        
        code = '''
from fastapi import FastAPI
app = FastAPI()

@app.get("/test")
def get_test():
    return {}
'''
        with tempfile.TemporaryDirectory() as tmpdir:
            py_file = Path(tmpdir) / "main.py"
            py_file.write_text(code)
            
            output_dir = Path(tmpdir) / "docs"
            result = runner.invoke(app, [
                "generate",
                tmpdir,
                "--output", str(output_dir),
                "--title", "My Custom API",
                "--description", "A custom API description",
                "--version", "2.0.0",
            ])
            
            assert result.exit_code == 0
            content = (output_dir / "index.html").read_text()
            assert "My Custom API" in content
            assert "A custom API description" in content
            assert "2.0.0" in content


class TestCLIInit:
    """Tests for init command."""

    def test_init_creates_config(self):
        """Test init command creates configuration file."""
        runner = CliRunner()
        
        with tempfile.TemporaryDirectory() as tmpdir:
            result = runner.invoke(app, ["init", "--output", tmpdir])
            
            assert result.exit_code == 0
            config_file = Path(tmpdir) / "docgen.toml"
            assert config_file.exists()


class TestCLIVersion:
    """Tests for version command."""

    def test_version_shows_version(self):
        """Test version command displays version."""
        runner = CliRunner()
        result = runner.invoke(app, ["version"])
        
        assert result.exit_code == 0
        assert "DocGen-CLI" in result.output