# Check for configuration files
config_files = glob("pyproject.toml") + glob("pytest.ini") + glob("setup.cfg")

# Find existing tests
test_files = glob("tests/**/*.py", recursive=True)
conftest = glob("tests/conftest.py")

# Test quality indicators
test_patterns = {
    'uses_fixtures': has_conftest_and_fixtures(),
    'has_coverage': has_coverage_setup(),
    'uses_markers': has_test_markers(),
    'async_tests': count_async_tests(),
    'integration_tests': count_integration_tests(),
    'test_naming_quality': analyze_test_naming()
}

# Analyze existing pytest configuration
if has_pyproject_toml():
    analyze_pyproject_pytest_config()
elif has_pytest_ini():
    analyze_pytest_ini_config()
elif has_setup_cfg():
    analyze_setup_cfg_config()

# Evidence-based triggers for recommendations
if test_patterns['no_async_tests'] and project_has_async_code():
    # Found async code but no async tests
    suggest_async_testing_setup()

if test_patterns['coverage_low'] and project_is_mature():
    # Mature project with low coverage
    suggest_coverage_improvements()

if test_patterns['no_integration_tests'] and project_has_external_dependencies():
    # External dependencies but no integration tests
    suggest_integration_testing()

# I'll analyze your actual test names
current_names = [
    "test1", "test2", "test_data",  # Non-descriptive names
    "test_user_creation", "test_email_validation"  # Good names
]

if non_descriptive_ratio > 0.3:
    print(f"Found {len(non_descriptive)} non-descriptive test names")
    print("Consider renaming for better clarity:")
    for name in non_descriptive:
        print(f"  - '{name}' → '{suggest_better_name(name)}'")

# I'll analyze your current setup and suggest specific, actionable improvements

# Example: Coverage Analysis
coverage_report = analyze_current_coverage()
if coverage_report.uncovered_critical_functions:
    print("Found critical functions without test coverage:")
    for func in coverage_report.uncovered_critical_functions:
        print(f"  - {func.name} in {func.file}:{func.line}")
        print(f"    Suggest: test_{func.name}_with_valid_input()")
        print(f"    Suggest: test_{func.name}_with_edge_cases()")

# I'll always show you what changes I'm suggesting
def suggest_config_enhancement(current_config, suggested_changes):
    print("Current configuration:")
    print(format_config(current_config))

    print("\nSuggested enhancements:")
    print(format_config(suggested_changes))

    print("\nChanges summary:")
    for change in diff_configs(current_config, suggested_changes):
        print(f"  - {change}")

    print(f"\nBackup your current config before applying changes.")

# I'll only suggest packages you actually need
dependencies = analyze_project_dependencies()

if dependencies.uses_async_database:
    suggest_package("pytest-asyncio", reason="async database testing found")
elif dependencies.uses_http_clients:
    suggest_package("pytest-httpx", reason="HTTP client testing needed")

if not dependencies.has_coverage_tools and project_size > "medium":
    suggest_package("pytest-cov", reason="project size indicates coverage needs")

# Try to get latest documentation, but fallback to local knowledge
try:
    latest_docs = fetch_latest_docs("pytest")
except (ToolNotAvailable, NetworkError):
    latest_docs = use_local_knowledge("pytest")

# Check your current versions before suggesting updates
current_version = get_installed_version("pytest")
latest_version = get_latest_available_version("pytest")

if latest_version > current_version:
    print(f"pytest update available: {current_version} → {latest_version}")
    print("Check release notes before updating")
else:
    print("pytest is up to date")

def analyze_refactoring_needs(test_files):
    issues = []

    for test_file in test_files:
        issues.extend(analyze_single_file(test_file))

    if not issues:
        print("✅ Your tests are well-structured. No refactoring needed.")
        return False

    print(f"Found {len(issues)} improvement opportunities:")
    for issue in issues:
        print(f"  📝 {issue.file}:{issue.line} - {issue.description}")
        print(f"     Current: {issue.current_code}")
        print(f"     Suggested: {issue.suggested_code}")

    return issues

# Example of concrete evidence
sample_analysis = analyze_refactoring_needs(["tests/test_user.py"])
# Output:
# Found 3 improvement opportunities:
#   📝 tests/test_user.py:15 - Non-descriptive test name
#      Current: def test1():
#      Suggested: def test_user_creation_with_valid_data():
#   📝 tests/test_user.py:25 - Missing assertion message
#      Current: assert result == user
#      Suggested: assert result == user, "User objects should be equal"

def analyze_test_coverage_gaps(coverage_report):
    """Identify specific areas needing test coverage"""

    critical_files = coverage_report.uncovered_critical_files()
    if not critical_files:
        return "Coverage is adequate for critical paths"

    recommendations = []
    for file in critical_files:
        functions = file.uncovered_functions
        for func in functions:
            recommendations.append({
                'file': file.path,
                'function': func.name,
                'reason': f"Critical function {func.name} in {file.path}",
                'suggested_test': f"test_{func.name}_with_typical_scenarios"
            })

    return recommendations

def suggest_pytest_enhancements(existing_config):
    """Suggest pytest enhancements based on current setup"""

    enhancements = {}

    # Only suggest additions, don't remove existing settings
    if '--cov' not in existing_config.get('addopts', []):
        enhancements['addopts'] = existing_config.get('addopts', [])
        enhancements['addopts'].append('--cov=src')
        enhancements['coverage_note'] = "Adding coverage reporting (removable with --no-cov)"

    if 'markers' not in existing_config:
        enhancements['markers'] = {
            'unit': 'marks tests as unit tests',
            'integration': 'marks tests as integration tests'
        }

    return enhancements

def analyze_test_patterns(test_files):
    """Analyze and document your current test patterns"""

    patterns = {
        'test_count': len(test_files),
        'uses_fixtures': any('def test_' in f for f in test_files if 'conftest' in f),
        'has_async_tests': any('async def test_' in f for f in test_files),
        'parametrized_tests': sum(f.count('@pytest.mark.parametrize') for f in test_files),
        'exception_tests': sum(f.count('pytest.raises') for f in test_files)
    }

    return patterns

def calculate_test_quality_score(test_files):
    """Calculate objective quality metrics for existing tests"""

    metrics = {
        'naming_clarity': analyze_naming_quality(test_files),
        'assertion_quality': analyze_assertion_quality(test_files),
        'coverage_adequacy': analyze_coverage_adequacy(test_files),
        'documentation_quality': analyze_docstring_quality(test_files)
    }

    overall_score = sum(metrics.values()) / len(metrics)
    return overall_score, metrics