{
  "test_generation": {
    "generated_tests": [
      {
        "name": "should_validate_password_length_successfully",
        "type": "happy_path",
        "priority": "P0",
        "framework": "jest",
        "code": "it('should validate password with sufficient length', () => {\n  const validator = new PasswordValidator();\n  const result = validator.validate('Test@123');\n  expect(result).toBe(true);\n});"
      },
      {
        "name": "should_handle_too_short_password",
        "type": "error_case",
        "priority": "P0",
        "framework": "jest",
        "code": "it('should reject password shorter than 8 characters', () => {\n  const validator = new PasswordValidator();\n  const result = validator.validate('Test@1');\n  expect(result).toBe(false);\n});"
      }
    ],
    "test_file": "password-validator.test.ts",
    "total_tests_generated": 8
  },
  "coverage_analysis": {
    "summary": {
      "line_coverage": 100.0,
      "branch_coverage": 100.0,
      "function_coverage": 100.0,
      "total_lines": 20,
      "covered_lines": 20,
      "total_branches": 12,
      "covered_branches": 12
    },
    "gaps": [],
    "assessment": "Excellent coverage - all paths tested"
  },
  "metrics": {
    "complexity": {
      "cyclomatic_complexity": 6,
      "cognitive_complexity": 8,
      "testability_score": 85.0,
      "assessment": "Medium complexity - moderately testable"
    },
    "test_quality": {
      "total_tests": 8,
      "total_assertions": 16,
      "avg_assertions_per_test": 2.0,
      "isolation_score": 95.0,
      "naming_quality": 87.5,
      "quality_score": 88.0,
      "test_smells": []
    }
  },
  "recommendations": [
    {
      "priority": "P1",
      "type": "edge_case_coverage",
      "message": "Consider adding boundary value tests",
      "action": "Add tests for exact boundary conditions (7 vs 8 characters)",
      "impact": "medium"
    },
    {
      "priority": "P2",
      "type": "test_organization",
      "message": "Group related tests using describe blocks",
      "action": "Organize tests by feature (length validation, complexity validation)",
      "impact": "low"
    }
  ],
  "tdd_workflow": {
    "current_phase": "GREEN",
    "status": "Tests passing, ready for refactoring",
    "next_steps": [
      "Review code for duplication",
      "Consider extracting validation rules",
      "Commit changes"
    ]
  }
}

{
  "language": "python",
  "framework": "pytest",
  "source_code": "def calculate_discount(price: float, discount_percent: float) -> float:\n    \"\"\"Calculate discounted price.\"\"\"\n    if price < 0:\n        raise ValueError(\"Price cannot be negative\")\n    if discount_percent < 0 or discount_percent > 100:\n        raise ValueError(\"Discount must be between 0 and 100\")\n    \n    discount_amount = price * (discount_percent / 100)\n    return round(price - discount_amount, 2)",
  "requirements": {
    "user_stories": [
      {
        "description": "Calculate discounted price for valid inputs",
        "action": "calculate_discount",
        "given": ["Price is 100", "Discount is 20%"],
        "when": "Discount is calculated",
        "then": "Return 80.00",
        "error_conditions": [
          {
            "condition": "negative_price",
            "description": "Price is negative",
            "error_type": "ValueError"
          },
          {
            "condition": "invalid_discount",
            "description": "Discount is out of range",
            "error_type": "ValueError"
          }
        ],
        "edge_cases": [
          {
            "scenario": "zero_discount",
            "description": "Discount is 0%"
          },
          {
            "scenario": "full_discount",
            "description": "Discount is 100%"
          }
        ]
      }
    ]
  },
  "coverage_threshold": 90
}

{
  "language": "typescript",
  "framework": "jest",
  "source_code": "export class PasswordValidator {\n  validate(password: string): boolean {\n    if (password.length < 8) return false;\n    if (!/[A-Z]/.test(password)) return false;\n    if (!/[a-z]/.test(password)) return false;\n    if (!/[0-9]/.test(password)) return false;\n    if (!/[!@#$%^&*]/.test(password)) return false;\n    return true;\n  }\n}",
  "requirements": {
    "user_stories": [
      {
        "description": "Password must be at least 8 characters long",
        "action": "validate_password_length",
        "given": ["User provides password"],
        "when": "Password is validated",
        "then": "Reject if less than 8 characters"
      },
      {
        "description": "Password must contain uppercase, lowercase, number, and special character",
        "action": "validate_password_complexity",
        "given": ["User provides password"],
        "when": "Password is validated",
        "then": "Reject if missing any character type"
      }
    ],
    "acceptance_criteria": [
      {
        "id": "AC1",
        "description": "Valid password: 'Test@123'",
        "verification_steps": ["Call validate with 'Test@123'", "Should return true"]
      },
      {
        "id": "AC2",
        "description": "Invalid password: 'test' (too short)",
        "verification_steps": ["Call validate with 'test'", "Should return false"]
      }
    ]
  },
  "coverage_threshold": 80
}

"""
Coverage analysis module.

Parse and analyze test coverage reports in multiple formats (LCOV, JSON, XML).
Identify gaps, calculate metrics, and provide actionable recommendations.
"""

from typing import Dict, List, Any, Optional, Tuple
import json
import xml.etree.ElementTree as ET


class CoverageFormat:
    """Supported coverage report formats."""
    LCOV = "lcov"
    JSON = "json"
    XML = "xml"
    COBERTURA = "cobertura"


class CoverageAnalyzer:
    """Analyze test coverage reports and identify gaps."""

    def __init__(self):
        """Initialize coverage analyzer."""
        self.coverage_data = {}
        self.gaps = []
        self.summary = {}

    def parse_coverage_report(
        self,
        report_content: str,
        format_type: str
    ) -> Dict[str, Any]:
        """
        Parse coverage report in various formats.

        Args:
            report_content: Raw coverage report content
            format_type: Format (lcov, json, xml, cobertura)

        Returns:
            Parsed coverage data
        """
        if format_type == CoverageFormat.LCOV:
            return self._parse_lcov(report_content)
        elif format_type == CoverageFormat.JSON:
            return self._parse_json(report_content)
        elif format_type in [CoverageFormat.XML, CoverageFormat.COBERTURA]:
            return self._parse_xml(report_content)
        else:
            raise ValueError(f"Unsupported format: {format_type}")

    def _parse_lcov(self, content: str) -> Dict[str, Any]:
        """Parse LCOV format coverage report."""
        files = {}
        current_file = None
        file_data = {}

        for line in content.split('\n'):
            line = line.strip()

            if line.startswith('SF:'):
                # Source file
                current_file = line[3:]
                file_data = {
                    'lines': {},
                    'functions': {},
                    'branches': {}
                }

            elif line.startswith('DA:'):
                # Line coverage data (line_number,hit_count)
                parts = line[3:].split(',')
                line_num = int(parts[0])
                hit_count = int(parts[1])
                file_data['lines'][line_num] = hit_count

            elif line.startswith('FNDA:'):
                # Function coverage (hit_count,function_name)
                parts = line[5:].split(',', 1)
                hit_count = int(parts[0])
                func_name = parts[1] if len(parts) > 1 else 'unknown'
                file_data['functions'][func_name] = hit_count

            elif line.startswith('BRDA:'):
                # Branch coverage (line,block,branch,hit_count)
                parts = line[5:].split(',')
                branch_id = f"{parts[0]}:{parts[1]}:{parts[2]}"
                hit_count = 0 if parts[3] == '-' else int(parts[3])
                file_data['branches'][branch_id] = hit_count

            elif line == 'end_of_record':
                if current_file:
                    files[current_file] = file_data
                current_file = None
                file_data = {}

        self.coverage_data = files
        return files

    def _parse_json(self, content: str) -> Dict[str, Any]:
        """Parse JSON format coverage report (Istanbul/nyc)."""
        try:
            data = json.loads(content)
            files = {}

            for file_path, file_data in data.items():
                lines = {}
                functions = {}
                branches = {}

                # Line coverage
                if 's' in file_data:  # Statement map
                    statement_map = file_data['s']
                    for stmt_id, hit_count in statement_map.items():
                        # Map statement to line number
                        if 'statementMap' in file_data:
                            stmt_info = file_data['statementMap'].get(stmt_id, {})
                            line_num = stmt_info.get('start', {}).get('line')
                            if line_num:
                                lines[line_num] = hit_count

                # Function coverage
                if 'f' in file_data:
                    func_map = file_data['f']
                    func_names = file_data.get('fnMap', {})
                    for func_id, hit_count in func_map.items():
                        func_info = func_names.get(func_id, {})
                        func_name = func_info.get('name', f'func_{func_id}')
                        functions[func_name] = hit_count

                # Branch coverage
                if 'b' in file_data:
                    branch_map = file_data['b']
                    for branch_id, locations in branch_map.items():
                        for idx, hit_count in enumerate(locations):
                            branch_key = f"{branch_id}:{idx}"
                            branches[branch_key] = hit_count

                files[file_path] = {
                    'lines': lines,
                    'functions': functions,
                    'branches': branches
                }

            self.coverage_data = files
            return files

        except json.JSONDecodeError as e:
            raise ValueError(f"Invalid JSON coverage report: {e}")

    def _parse_xml(self, content: str) -> Dict[str, Any]:
        """Parse XML/Cobertura format coverage report."""
        try:
            root = ET.fromstring(content)
            files = {}

            # Handle Cobertura format
            for package in root.findall('.//package'):
                for cls in package.findall('classes/class'):
                    filename = cls.get('filename', cls.get('name', 'unknown'))

                    lines = {}
                    branches = {}

                    for line in cls.findall('lines/line'):
                        line_num = int(line.get('number', 0))
                        hit_count = int(line.get('hits', 0))
                        lines[line_num] = hit_count

                        # Branch info
                        branch = line.get('branch', 'false')
                        if branch == 'true':
                            condition_coverage = line.get('condition-coverage', '0% (0/0)')
                            # Parse "(covered/total)"
                            if '(' in condition_coverage:
                                branch_info = condition_coverage.split('(')[1].split(')')[0]
                                covered, total = map(int, branch_info.split('/'))
                                branches[f"{line_num}:branch"] = covered

                    files[filename] = {
                        'lines': lines,
                        'functions': {},
                        'branches': branches
                    }

            self.coverage_data = files
            return files

        except ET.ParseError as e:
            raise ValueError(f"Invalid XML coverage report: {e}")

    def calculate_summary(self) -> Dict[str, Any]:
        """
        Calculate overall coverage summary.

        Returns:
            Summary with line, branch, and function coverage percentages
        """
        total_lines = 0
        covered_lines = 0
        total_branches = 0
        covered_branches = 0
        total_functions = 0
        covered_functions = 0

        for file_path, file_data in self.coverage_data.items():
            # Lines
            for line_num, hit_count in file_data.get('lines', {}).items():
                total_lines += 1
                if hit_count > 0:
                    covered_lines += 1

            # Branches
            for branch_id, hit_count in file_data.get('branches', {}).items():
                total_branches += 1
                if hit_count > 0:
                    covered_branches += 1

            # Functions
            for func_name, hit_count in file_data.get('functions', {}).items():
                total_functions += 1
                if hit_count > 0:
                    covered_functions += 1

        summary = {
            'line_coverage': self._safe_percentage(covered_lines, total_lines),
            'branch_coverage': self._safe_percentage(covered_branches, total_branches),
            'function_coverage': self._safe_percentage(covered_functions, total_functions),
            'total_lines': total_lines,
            'covered_lines': covered_lines,
            'total_branches': total_branches,
            'covered_branches': covered_branches,
            'total_functions': total_functions,
            'covered_functions': covered_functions
        }

        self.summary = summary
        return summary

    def _safe_percentage(self, covered: int, total: int) -> float:
        """Safely calculate percentage."""
        if total == 0:
            return 0.0
        return round((covered / total) * 100, 2)

    def identify_gaps(self, threshold: float = 80.0) -> List[Dict[str, Any]]:
        """
        Identify coverage gaps below threshold.

        Args:
            threshold: Minimum acceptable coverage percentage

        Returns:
            List of files with coverage gaps
        """
        gaps = []

        for file_path, file_data in self.coverage_data.items():
            file_gaps = self._analyze_file_gaps(file_path, file_data, threshold)
            if file_gaps:
                gaps.append(file_gaps)

        self.gaps = gaps
        return gaps

    def _analyze_file_gaps(
        self,
        file_path: str,
        file_data: Dict[str, Any],
        threshold: float
    ) -> Optional[Dict[str, Any]]:
        """Analyze coverage gaps for a single file."""
        lines = file_data.get('lines', {})
        branches = file_data.get('branches', {})
        functions = file_data.get('functions', {})

        # Calculate file coverage
        total_lines = len(lines)
        covered_lines = sum(1 for hit in lines.values() if hit > 0)
        line_coverage = self._safe_percentage(covered_lines, total_lines)

        total_branches = len(branches)
        covered_branches = sum(1 for hit in branches.values() if hit > 0)
        branch_coverage = self._safe_percentage(covered_branches, total_branches)

        # Find uncovered lines
        uncovered_lines = [line_num for line_num, hit in lines.items() if hit == 0]
        uncovered_branches = [branch_id for branch_id, hit in branches.items() if hit == 0]

        # Only report if below threshold
        if line_coverage < threshold or branch_coverage < threshold:
            return {
                'file': file_path,
                'line_coverage': line_coverage,
                'branch_coverage': branch_coverage,
                'uncovered_lines': sorted(uncovered_lines),
                'uncovered_branches': uncovered_branches,
                'priority': self._calculate_priority(line_coverage, branch_coverage, threshold)
            }

        return None

    def _calculate_priority(
        self,
        line_coverage: float,
        branch_coverage: float,
        threshold: float
    ) -> str:
        """Calculate priority based on coverage gap severity."""
        gap = threshold - min(line_coverage, branch_coverage)

        if gap >= 40:
            return 'P0'  # Critical - less than 40% coverage
        elif gap >= 20:
            return 'P1'  # Important - 60-80% coverage
        else:
            return 'P2'  # Nice to have - 80%+ coverage

    def get_file_coverage(self, file_path: str) -> Dict[str, Any]:
        """
        Get detailed coverage information for a specific file.

        Args:
            file_path: Path to file

        Returns:
            Detailed coverage data for file
        """
        if file_path not in self.coverage_data:
            return {}

        file_data = self.coverage_data[file_path]
        lines = file_data.get('lines', {})
        branches = file_data.get('branches', {})
        functions = file_data.get('functions', {})

        total_lines = len(lines)
        covered_lines = sum(1 for hit in lines.values() if hit > 0)

        total_branches = len(branches)
        covered_branches = sum(1 for hit in branches.values() if hit > 0)

        total_functions = len(functions)
        covered_functions = sum(1 for hit in functions.values() if hit > 0)

        return {
            'file': file_path,
            'line_coverage': self._safe_percentage(covered_lines, total_lines),
            'branch_coverage': self._safe_percentage(covered_branches, total_branches),
            'function_coverage': self._safe_percentage(covered_functions, total_functions),
            'lines': lines,
            'branches': branches,
            'functions': functions
        }

    def generate_recommendations(self) -> List[Dict[str, Any]]:
        """
        Generate prioritized recommendations for improving coverage.

        Returns:
            List of recommendations with priority and actions
        """
        recommendations = []

        # Check overall coverage
        summary = self.summary or self.calculate_summary()

        if summary['line_coverage'] < 80:
            recommendations.append({
                'priority': 'P0',
                'type': 'overall_coverage',
                'message': f"Overall line coverage ({summary['line_coverage']}%) is below 80% threshold",
                'action': 'Focus on adding tests for critical paths and business logic',
                'impact': 'high'
            })

        if summary['branch_coverage'] < 70:
            recommendations.append({
                'priority': 'P0',
                'type': 'branch_coverage',
                'message': f"Branch coverage ({summary['branch_coverage']}%) is below 70% threshold",
                'action': 'Add tests for conditional logic and error handling paths',
                'impact': 'high'
            })

        # File-specific recommendations
        for gap in self.gaps:
            if gap['priority'] == 'P0':
                recommendations.append({
                    'priority': 'P0',
                    'type': 'file_coverage',
                    'file': gap['file'],
                    'message': f"Critical coverage gap in {gap['file']}",
                    'action': f"Add tests for lines: {gap['uncovered_lines'][:10]}",
                    'impact': 'high'
                })

        # Sort by priority
        priority_order = {'P0': 0, 'P1': 1, 'P2': 2}
        recommendations.sort(key=lambda x: priority_order.get(x['priority'], 3))

        return recommendations

    def detect_format(self, content: str) -> str:
        """
        Automatically detect coverage report format.

        Args:
            content: Raw coverage report content

        Returns:
            Detected format (lcov, json, xml)
        """
        content_stripped = content.strip()

        # Check for LCOV format
        if content_stripped.startswith('TN:') or 'SF:' in content_stripped[:100]:
            return CoverageFormat.LCOV

        # Check for JSON format
        if content_stripped.startswith('{') or content_stripped.startswith('['):
            try:
                json.loads(content_stripped)
                return CoverageFormat.JSON
            except:
                pass

        # Check for XML format
        if content_stripped.startswith('<?xml') or content_stripped.startswith('<coverage'):
            return CoverageFormat.XML

        raise ValueError("Unable to detect coverage report format")

"""
Fixture and test data generation module.

Generates realistic test data, mock objects, and fixtures for various scenarios.
"""

from typing import Dict, List, Any, Optional
import json
import random


class FixtureGenerator:
    """Generate test fixtures and mock data."""

    def __init__(self, seed: Optional[int] = None):
        """
        Initialize fixture generator.

        Args:
            seed: Random seed for reproducible fixtures
        """
        if seed is not None:
            random.seed(seed)

    def generate_boundary_values(
        self,
        data_type: str,
        constraints: Optional[Dict[str, Any]] = None
    ) -> List[Any]:
        """
        Generate boundary values for testing.

        Args:
            data_type: Type of data (int, string, array, date, etc.)
            constraints: Constraints like min, max, length

        Returns:
            List of boundary values
        """
        constraints = constraints or {}

        if data_type == "int":
            return self._integer_boundaries(constraints)
        elif data_type == "string":
            return self._string_boundaries(constraints)
        elif data_type == "array":
            return self._array_boundaries(constraints)
        elif data_type == "date":
            return self._date_boundaries(constraints)
        elif data_type == "email":
            return self._email_boundaries()
        elif data_type == "url":
            return self._url_boundaries()
        else:
            return []

    def _integer_boundaries(self, constraints: Dict[str, Any]) -> List[int]:
        """Generate integer boundary values."""
        min_val = constraints.get('min', 0)
        max_val = constraints.get('max', 100)

        boundaries = [
            min_val,  # Minimum
            min_val + 1,  # Just above minimum
            max_val - 1,  # Just below maximum
            max_val,  # Maximum
        ]

        # Add special values
        if min_val <= 0 <= max_val:
            boundaries.append(0)  # Zero
        if min_val < 0:
            boundaries.append(-1)  # Negative

        return sorted(set(boundaries))

    def _string_boundaries(self, constraints: Dict[str, Any]) -> List[str]:
        """Generate string boundary values."""
        min_len = constraints.get('min_length', 0)
        max_len = constraints.get('max_length', 100)

        boundaries = [
            "",  # Empty string
            "a" * min_len,  # Minimum length
            "a" * (min_len + 1) if min_len < max_len else "",  # Just above minimum
            "a" * (max_len - 1) if max_len > 1 else "a",  # Just below maximum
            "a" * max_len,  # Maximum length
            "a" * (max_len + 1),  # Exceeds maximum (invalid)
        ]

        # Add special characters
        if max_len >= 10:
            boundaries.append("test@#$%^&*()")  # Special characters
            boundaries.append("unicode: 你好")  # Unicode

        return [b for b in boundaries if b is not None]

    def _array_boundaries(self, constraints: Dict[str, Any]) -> List[List[Any]]:
        """Generate array boundary values."""
        min_size = constraints.get('min_size', 0)
        max_size = constraints.get('max_size', 10)

        boundaries = [
            [],  # Empty array
            [1] * min_size,  # Minimum size
            [1] * max_size,  # Maximum size
            [1] * (max_size + 1),  # Exceeds maximum (invalid)
        ]

        return boundaries

    def _date_boundaries(self, constraints: Dict[str, Any]) -> List[str]:
        """Generate date boundary values."""
        return [
            "1900-01-01",  # Very old date
            "1970-01-01",  # Unix epoch
            "2000-01-01",  # Y2K
            "2025-11-05",  # Today (example)
            "2099-12-31",  # Far future
            "invalid-date",  # Invalid format
        ]

    def _email_boundaries(self) -> List[str]:
        """Generate email boundary values."""
        return [
            "[email protected]",  # Valid
            "[email protected]",  # Valid with special chars
            "invalid",  # Missing @
            "@example.com",  # Missing local part
            "user@",  # Missing domain
            "[email protected]",  # Invalid domain
            "",  # Empty
        ]

    def _url_boundaries(self) -> List[str]:
        """Generate URL boundary values."""
        return [
            "https://example.com",  # Valid HTTPS
            "http://example.com",  # Valid HTTP
            "ftp://example.com",  # Different protocol
            "//example.com",  # Protocol-relative
            "example.com",  # Missing protocol
            "",  # Empty
            "not a url",  # Invalid
        ]

    def generate_edge_cases(
        self,
        scenario: str,
        context: Optional[Dict[str, Any]] = None
    ) -> List[Dict[str, Any]]:
        """
        Generate edge case test scenarios.

        Args:
            scenario: Type of scenario (auth, payment, form, api, etc.)
            context: Additional context for scenario

        Returns:
            List of edge case test scenarios
        """
        if scenario == "auth":
            return self._auth_edge_cases()
        elif scenario == "payment":
            return self._payment_edge_cases()
        elif scenario == "form":
            return self._form_edge_cases(context or {})
        elif scenario == "api":
            return self._api_edge_cases()
        elif scenario == "file_upload":
            return self._file_upload_edge_cases()
        else:
            return []

    def _auth_edge_cases(self) -> List[Dict[str, Any]]:
        """Generate authentication edge cases."""
        return [
            {
                'name': 'empty_credentials',
                'input': {'username': '', 'password': ''},
                'expected': 'validation_error'
            },
            {
                'name': 'sql_injection_attempt',
                'input': {'username': "admin' OR '1'='1", 'password': 'password'},
                'expected': 'authentication_failed'
            },
            {
                'name': 'very_long_password',
                'input': {'username': 'user', 'password': 'a' * 1000},
                'expected': 'validation_error_or_success'
            },
            {
                'name': 'special_chars_username',
                'input': {'username': 'user@#$%', 'password': 'password'},
                'expected': 'depends_on_validation'
            },
            {
                'name': 'unicode_credentials',
                'input': {'username': '用户', 'password': 'пароль'},
                'expected': 'should_handle_unicode'
            }
        ]

    def _payment_edge_cases(self) -> List[Dict[str, Any]]:
        """Generate payment processing edge cases."""
        return [
            {
                'name': 'zero_amount',
                'input': {'amount': 0, 'currency': 'USD'},
                'expected': 'validation_error'
            },
            {
                'name': 'negative_amount',
                'input': {'amount': -10, 'currency': 'USD'},
                'expected': 'validation_error'
            },
            {
                'name': 'very_large_amount',
                'input': {'amount': 999999999.99, 'currency': 'USD'},
                'expected': 'should_handle_or_reject'
            },
            {
                'name': 'precision_test',
                'input': {'amount': 10.999, 'currency': 'USD'},
                'expected': 'should_round_to_10.99'
            },
            {
                'name': 'invalid_currency',
                'input': {'amount': 10, 'currency': 'XXX'},
                'expected': 'validation_error'
            }
        ]

    def _form_edge_cases(self, context: Dict[str, Any]) -> List[Dict[str, Any]]:
        """Generate form validation edge cases."""
        fields = context.get('fields', [])
        edge_cases = []

        for field in fields:
            field_name = field.get('name', 'field')
            field_type = field.get('type', 'text')

            edge_cases.append({
                'name': f'{field_name}_empty',
                'input': {field_name: ''},
                'expected': 'validation_error_if_required'
            })

            if field_type in ['text', 'email', 'password']:
                edge_cases.append({
                    'name': f'{field_name}_very_long',
                    'input': {field_name: 'a' * 1000},
                    'expected': 'validation_error_or_truncate'
                })

        return edge_cases

    def _api_edge_cases(self) -> List[Dict[str, Any]]:
        """Generate API edge cases."""
        return [
            {
                'name': 'missing_required_field',
                'request': {'optional_field': 'value'},
                'expected': 400
            },
            {
                'name': 'invalid_json',
                'request': 'not valid json{',
                'expected': 400
            },
            {
                'name': 'empty_body',
                'request': {},
                'expected': 400
            },
            {
                'name': 'very_large_payload',
                'request': {'data': 'x' * 1000000},
                'expected': '413_or_400'
            },
            {
                'name': 'invalid_method',
                'method': 'INVALID',
                'expected': 405
            }
        ]

    def _file_upload_edge_cases(self) -> List[Dict[str, Any]]:
        """Generate file upload edge cases."""
        return [
            {
                'name': 'empty_file',
                'file': {'name': 'test.txt', 'size': 0},
                'expected': 'validation_error'
            },
            {
                'name': 'very_large_file',
                'file': {'name': 'test.txt', 'size': 1000000000},
                'expected': 'size_limit_error'
            },
            {
                'name': 'invalid_extension',
                'file': {'name': 'test.exe', 'size': 1000},
                'expected': 'validation_error'
            },
            {
                'name': 'no_extension',
                'file': {'name': 'testfile', 'size': 1000},
                'expected': 'depends_on_validation'
            },
            {
                'name': 'special_chars_filename',
                'file': {'name': 'test@#$%.txt', 'size': 1000},
                'expected': 'should_sanitize'
            }
        ]

    def generate_mock_data(
        self,
        schema: Dict[str, Any],
        count: int = 1
    ) -> List[Dict[str, Any]]:
        """
        Generate mock data based on schema.

        Args:
            schema: Schema definition with field types
            count: Number of mock objects to generate

        Returns:
            List of mock data objects
        """
        mock_objects = []

        for _ in range(count):
            mock_obj = {}

            for field_name, field_def in schema.items():
                field_type = field_def.get('type', 'string')
                mock_obj[field_name] = self._generate_field_value(field_type, field_def)

            mock_objects.append(mock_obj)

        return mock_objects

    def _generate_field_value(self, field_type: str, field_def: Dict[str, Any]) -> Any:
        """Generate value for a single field."""
        if field_type == "string":
            options = field_def.get('options')
            if options:
                return random.choice(options)
            return f"test_string_{random.randint(1, 1000)}"

        elif field_type == "int":
            min_val = field_def.get('min', 0)
            max_val = field_def.get('max', 100)
            return random.randint(min_val, max_val)

        elif field_type == "float":
            min_val = field_def.get('min', 0.0)
            max_val = field_def.get('max', 100.0)
            return round(random.uniform(min_val, max_val), 2)

        elif field_type == "bool":
            return random.choice([True, False])

        elif field_type == "email":
            return f"user{random.randint(1, 1000)}@example.com"

        elif field_type == "date":
            return f"2025-{random.randint(1, 12):02d}-{random.randint(1, 28):02d}"

        elif field_type == "array":
            item_type = field_def.get('items', {}).get('type', 'string')
            size = random.randint(1, 5)
            return [self._generate_field_value(item_type, field_def.get('items', {}))
                   for _ in range(size)]

        else:
            return None

    def generate_fixture_file(
        self,
        fixture_name: str,
        data: Any,
        format: str = "json"
    ) -> str:
        """
        Generate fixture file content.

        Args:
            fixture_name: Name of fixture
            data: Fixture data
            format: Output format (json, yaml, python)

        Returns:
            Fixture file content as string
        """
        if format == "json":
            return json.dumps(data, indent=2)

        elif format == "python":
            return f"""# {fixture_name} fixture

{fixture_name.upper()} = {repr(data)}
"""

        elif format == "yaml":
            # Simple YAML generation (for basic structures)
            return self._dict_to_yaml(data)

        else:
            return str(data)

    def _dict_to_yaml(self, data: Any, indent: int = 0) -> str:
        """Simple YAML generator."""
        lines = []
        indent_str = "  " * indent

        if isinstance(data, dict):
            for key, value in data.items():
                if isinstance(value, (dict, list)):
                    lines.append(f"{indent_str}{key}:")
                    lines.append(self._dict_to_yaml(value, indent + 1))
                else:
                    lines.append(f"{indent_str}{key}: {value}")

        elif isinstance(data, list):
            for item in data:
                if isinstance(item, dict):
                    lines.append(f"{indent_str}-")
                    lines.append(self._dict_to_yaml(item, indent + 1))
                else:
                    lines.append(f"{indent_str}- {item}")

        else:
            return str(data)

        return "\n".join(lines)

"""
Format detection module.

Automatically detects programming language, testing framework, and file formats.
"""

from typing import Dict, List, Any, Optional, Tuple
import re


class FormatDetector:
    """Detect language, framework, and file formats automatically."""

    def __init__(self):
        """Initialize format detector."""
        self.detected_language = None
        self.detected_framework = None

    def detect_language(self, code: str) -> str:
        """
        Detect programming language from code.

        Args:
            code: Source code

        Returns:
            Detected language (typescript, javascript, python, java, unknown)
        """
        # TypeScript patterns
        if self._is_typescript(code):
            self.detected_language = "typescript"
            return "typescript"

        # JavaScript patterns
        if self._is_javascript(code):
            self.detected_language = "javascript"
            return "javascript"

        # Python patterns
        if self._is_python(code):
            self.detected_language = "python"
            return "python"

        # Java patterns
        if self._is_java(code):
            self.detected_language = "java"
            return "java"

        self.detected_language = "unknown"
        return "unknown"

    def _is_typescript(self, code: str) -> bool:
        """Check if code is TypeScript."""
        ts_patterns = [
            r'\binterface\s+\w+',  # interface definitions
            r':\s*\w+\s*[=;]',  # type annotations
            r'\btype\s+\w+\s*=',  # type aliases
            r'<\w+>',  # generic types
            r'import.*from.*[\'"]',  # ES6 imports with types
        ]

        # Must have multiple TypeScript-specific patterns
        matches = sum(1 for pattern in ts_patterns if re.search(pattern, code))
        return matches >= 2

    def _is_javascript(self, code: str) -> bool:
        """Check if code is JavaScript."""
        js_patterns = [
            r'\bconst\s+\w+',  # const declarations
            r'\blet\s+\w+',  # let declarations
            r'=>',  # arrow functions
            r'function\s+\w+',  # function declarations
            r'require\([\'"]',  # CommonJS require
        ]

        matches = sum(1 for pattern in js_patterns if re.search(pattern, code))
        return matches >= 2

    def _is_python(self, code: str) -> bool:
        """Check if code is Python."""
        py_patterns = [
            r'\bdef\s+\w+',  # function definitions
            r'\bclass\s+\w+',  # class definitions
            r'import\s+\w+',  # import statements
            r'from\s+\w+\s+import',  # from imports
            r'^\s*#.*$',  # Python comments
            r':\s*$',  # Python colons
        ]

        matches = sum(1 for pattern in py_patterns if re.search(pattern, code, re.MULTILINE))
        return matches >= 3

    def _is_java(self, code: str) -> bool:
        """Check if code is Java."""
        java_patterns = [
            r'\bpublic\s+class',  # public class
            r'\bprivate\s+\w+',  # private members
            r'\bpublic\s+\w+\s+\w+\s*\(',  # public methods
            r'import\s+java\.',  # Java imports
            r'\bvoid\s+\w+\s*\(',  # void methods
        ]

        matches = sum(1 for pattern in java_patterns if re.search(pattern, code))
        return matches >= 2

    def detect_test_framework(self, code: str) -> str:
        """
        Detect testing framework from test code.

        Args:
            code: Test code

        Returns:
            Detected framework (jest, vitest, pytest, junit, mocha, unknown)
        """
        # Jest patterns
        if 'from \'@jest/globals\'' in code or '@jest/' in code:
            self.detected_framework = "jest"
            return "jest"

        # Vitest patterns
        if 'from \'vitest\'' in code or 'import { vi }' in code:
            self.detected_framework = "vitest"
            return "vitest"

        # Pytest patterns
        if 'import pytest' in code or 'def test_' in code:
            self.detected_framework = "pytest"
            return "pytest"

        # Unittest patterns
        if 'import unittest' in code and 'unittest.TestCase' in code:
            self.detected_framework = "unittest"
            return "unittest"

        # JUnit patterns
        if '@Test' in code and 'import org.junit' in code:
            self.detected_framework = "junit"
            return "junit"

        # Mocha patterns
        if 'describe(' in code and 'it(' in code:
            self.detected_framework = "mocha"
            return "mocha"

        self.detected_framework = "unknown"
        return "unknown"

    def detect_coverage_format(self, content: str) -> str:
        """
        Detect coverage report format.

        Args:
            content: Coverage report content

        Returns:
            Format type (lcov, json, xml, unknown)
        """
        content_stripped = content.strip()

        # LCOV format
        if content_stripped.startswith('TN:') or 'SF:' in content_stripped[:200]:
            return "lcov"

        # JSON format
        if content_stripped.startswith('{'):
            try:
                import json
                json.loads(content_stripped)
                return "json"
            except:
                pass

        # XML format
        if content_stripped.startswith('<?xml') or content_stripped.startswith('<coverage'):
            return "xml"

        return "unknown"

    def detect_input_format(self, input_data: str) -> Dict[str, Any]:
        """
        Detect input format and extract relevant information.

        Args:
            input_data: Input data (could be code, coverage report, etc.)

        Returns:
            Detection results with format, language, framework
        """
        result = {
            'format': 'unknown',
            'language': 'unknown',
            'framework': 'unknown',
            'content_type': 'unknown'
        }

        # Detect if it's a coverage report
        coverage_format = self.detect_coverage_format(input_data)
        if coverage_format != "unknown":
            result['format'] = coverage_format
            result['content_type'] = 'coverage_report'
            return result

        # Detect if it's source code
        language = self.detect_language(input_data)
        if language != "unknown":
            result['language'] = language
            result['content_type'] = 'source_code'

        # Detect if it's test code
        framework = self.detect_test_framework(input_data)
        if framework != "unknown":
            result['framework'] = framework
            result['content_type'] = 'test_code'

        return result

    def extract_file_info(self, file_path: str) -> Dict[str, str]:
        """
        Extract information from file path.

        Args:
            file_path: Path to file

        Returns:
            File information (extension, likely language, likely purpose)
        """
        import os

        file_name = os.path.basename(file_path)
        file_ext = os.path.splitext(file_name)[1].lower()

        # Extension to language mapping
        ext_to_lang = {
            '.ts': 'typescript',
            '.tsx': 'typescript',
            '.js': 'javascript',
            '.jsx': 'javascript',
            '.py': 'python',
            '.java': 'java',
            '.kt': 'kotlin',
            '.go': 'go',
            '.rs': 'rust',
        }

        # Test file patterns
        is_test = any(pattern in file_name.lower()
                     for pattern in ['test', 'spec', '_test.', '.test.'])

        return {
            'file_name': file_name,
            'extension': file_ext,
            'language': ext_to_lang.get(file_ext, 'unknown'),
            'is_test': is_test,
            'purpose': 'test' if is_test else 'source'
        }

    def suggest_test_file_name(self, source_file: str, framework: str) -> str:
        """
        Suggest test file name for source file.

        Args:
            source_file: Source file path
            framework: Testing framework

        Returns:
            Suggested test file name
        """
        import os

        base_name = os.path.splitext(os.path.basename(source_file))[0]
        ext = os.path.splitext(source_file)[1]

        if framework in ['jest', 'vitest', 'mocha']:
            return f"{base_name}.test{ext}"
        elif framework in ['pytest', 'unittest']:
            return f"test_{base_name}.py"
        elif framework in ['junit', 'testng']:
            return f"{base_name.capitalize()}Test.java"
        else:
            return f"{base_name}_test{ext}"

    def identify_test_patterns(self, code: str) -> List[str]:
        """
        Identify test patterns in code.

        Args:
            code: Test code

        Returns:
            List of identified patterns (AAA, Given-When-Then, etc.)
        """
        patterns = []

        # Arrange-Act-Assert pattern
        if any(comment in code.lower() for comment in ['// arrange', '# arrange', '// act', '# act']):
            patterns.append('AAA (Arrange-Act-Assert)')

        # Given-When-Then pattern
        if any(comment in code.lower() for comment in ['given', 'when', 'then']):
            patterns.append('Given-When-Then')

        # Setup/Teardown pattern
        if any(keyword in code for keyword in ['beforeEach', 'afterEach', 'setUp', 'tearDown']):
            patterns.append('Setup-Teardown')

        # Mocking pattern
        if any(keyword in code.lower() for keyword in ['mock', 'stub', 'spy']):
            patterns.append('Mocking/Stubbing')

        # Parameterized tests
        if any(keyword in code for keyword in ['@pytest.mark.parametrize', 'test.each', '@ParameterizedTest']):
            patterns.append('Parameterized Tests')

        return patterns if patterns else ['No specific pattern detected']

    def analyze_project_structure(self, file_paths: List[str]) -> Dict[str, Any]:
        """
        Analyze project structure from file paths.

        Args:
            file_paths: List of file paths in project

        Returns:
            Project structure analysis
        """
        languages = {}
        test_frameworks = []
        source_files = []
        test_files = []

        for file_path in file_paths:
            file_info = self.extract_file_info(file_path)

            # Count languages
            lang = file_info['language']
            if lang != 'unknown':
                languages[lang] = languages.get(lang, 0) + 1

            # Categorize files
            if file_info['is_test']:
                test_files.append(file_path)
            else:
                source_files.append(file_path)

        # Determine primary language
        primary_language = max(languages.items(), key=lambda x: x[1])[0] if languages else 'unknown'

        return {
            'primary_language': primary_language,
            'languages': languages,
            'source_file_count': len(source_files),
            'test_file_count': len(test_files),
            'test_ratio': len(test_files) / len(source_files) if source_files else 0,
            'suggested_framework': self._suggest_framework(primary_language)
        }

    def _suggest_framework(self, language: str) -> str:
        """Suggest testing framework based on language."""
        framework_map = {
            'typescript': 'jest or vitest',
            'javascript': 'jest or mocha',
            'python': 'pytest',
            'java': 'junit',
            'kotlin': 'junit',
            'go': 'testing package',
            'rust': 'cargo test',
        }

        return framework_map.get(language, 'unknown')

    def detect_environment(self) -> Dict[str, str]:
        """
        Detect execution environment (CLI, Desktop, API).

        Returns:
            Environment information
        """
        # This is a placeholder - actual detection would use environment variables
        # or other runtime checks
        return {
            'environment': 'cli',  # Could be 'desktop', 'api'
            'output_preference': 'terminal-friendly'  # Could be 'rich-markdown', 'json'
        }