Ios Simulator Skill

#!/usr/bin/env python3
"""
iOS Simulator Accessibility Audit

Scans the current simulator screen for accessibility compliance issues.
Optimized for minimal token output while maintaining functionality.

Usage: python scripts/accessibility_audit.py [options]
"""

import argparse
import json
import subprocess
import sys
from dataclasses import asdict, dataclass
from typing import Any

from common import flatten_tree, get_accessibility_tree, resolve_udid
from common.env_config import env_int

A11Y_LABEL_MAX = env_int("IOS_SIM_A11Y_LABEL_MAX", 80)
A11Y_TOP_ISSUES = env_int("IOS_SIM_A11Y_TOP_ISSUES", 10)


@dataclass
class Issue:
    """Represents an accessibility issue."""

    severity: str  # critical, warning, info
    rule: str
    element_type: str
    issue: str
    fix: str

    def to_dict(self) -> dict:
        """Convert to dictionary for JSON serialization."""
        return asdict(self)


class AccessibilityAuditor:
    """Performs accessibility audits on iOS simulator screens."""

    # Critical rules that block users
    CRITICAL_RULES = {
        "missing_label": lambda e: e.get("type") in ["Button", "Link"] and not e.get("AXLabel"),
        "empty_button": lambda e: e.get("type") == "Button"
        and not (e.get("AXLabel") or e.get("AXValue")),
        "image_no_alt": lambda e: e.get("type") == "Image" and not e.get("AXLabel"),
    }

    # Warnings that degrade UX
    WARNING_RULES = {
        "missing_hint": lambda e: e.get("type") in ["Slider", "TextField"] and not e.get("help"),
        "missing_traits": lambda e: e.get("type") and not e.get("traits"),
    }

    # Info level suggestions
    INFO_RULES = {
        "no_identifier": lambda e: not e.get("AXUniqueId"),
        "deep_nesting": lambda e: e.get("depth", 0) > 5,
    }

    def __init__(self, udid: str | None = None):
        """Initialize auditor with optional device UDID."""
        self.udid = udid

    def get_accessibility_tree(self) -> dict:
        """Fetch accessibility tree from simulator using shared utility."""
        return get_accessibility_tree(self.udid, nested=True)

    @staticmethod
    def _is_small_target(element: dict) -> bool:
        """Check if touch target is too small (< 44x44 points)."""
        frame = element.get("frame", {})
        width = frame.get("width", 0)
        height = frame.get("height", 0)
        return width < 44 or height < 44

    def _flatten_tree(self, node: dict, depth: int = 0) -> list[dict]:
        """Flatten nested accessibility tree for easier processing using shared utility."""
        return flatten_tree(node, depth)

    def audit_element(self, element: dict) -> list[Issue]:
        """Audit a single element for accessibility issues."""
        issues = []

        # Check critical rules
        for rule_name, rule_func in self.CRITICAL_RULES.items():
            if rule_func(element):
                issues.append(
                    Issue(
                        severity="critical",
                        rule=rule_name,
                        element_type=element.get("type", "Unknown"),
                        issue=self._get_issue_description(rule_name),
                        fix=self._get_fix_suggestion(rule_name),
                    )
                )

        # Check warnings (skip if critical issues found)
        if not issues:
            for rule_name, rule_func in self.WARNING_RULES.items():
                if rule_func(element):
                    issues.append(
                        Issue(
                            severity="warning",
                            rule=rule_name,
                            element_type=element.get("type", "Unknown"),
                            issue=self._get_issue_description(rule_name),
                            fix=self._get_fix_suggestion(rule_name),
                        )
                    )

        # Check info level (only if verbose or no other issues)
        if not issues:
            for rule_name, rule_func in self.INFO_RULES.items():
                if rule_func(element):
                    issues.append(
                        Issue(
                            severity="info",
                            rule=rule_name,
                            element_type=element.get("type", "Unknown"),
                            issue=self._get_issue_description(rule_name),
                            fix=self._get_fix_suggestion(rule_name),
                        )
                    )

        return issues

    def _get_issue_description(self, rule: str) -> str:
        """Get human-readable issue description."""
        descriptions = {
            "missing_label": "Interactive element missing accessibility label",
            "empty_button": "Button has no text or label",
            "image_no_alt": "Image missing alternative text",
            "missing_hint": "Complex control missing hint",
            "small_touch_target": "Touch target smaller than 44x44pt",
            "missing_traits": "Element missing accessibility traits",
            "no_identifier": "Missing accessibility identifier",
            "deep_nesting": "Deeply nested (>5 levels)",
        }
        return descriptions.get(rule, "Accessibility issue")

    def _get_fix_suggestion(self, rule: str) -> str:
        """Get fix suggestion for issue."""
        fixes = {
            "missing_label": "Add accessibilityLabel",
            "empty_button": "Set button title or accessibilityLabel",
            "image_no_alt": "Add accessibilityLabel with description",
            "missing_hint": "Add accessibilityHint",
            "small_touch_target": "Increase to minimum 44x44pt",
            "missing_traits": "Set appropriate accessibilityTraits",
            "no_identifier": "Add accessibilityIdentifier for testing",
            "deep_nesting": "Simplify view hierarchy",
        }
        return fixes.get(rule, "Review accessibility")

    def audit(self, verbose: bool = False) -> dict[str, Any]:
        """Perform full accessibility audit."""
        # Get accessibility tree
        tree = self.get_accessibility_tree()

        # Flatten for processing
        elements = self._flatten_tree(tree)

        # Audit each element
        all_issues = []
        for element in elements:
            issues = self.audit_element(element)
            for issue in issues:
                issue_dict = issue.to_dict()
                # Add minimal element info for context
                issue_dict["element"] = {
                    "type": element.get("type", "Unknown"),
                    "label": (
                        element.get("AXLabel", "")[:A11Y_LABEL_MAX]
                        if element.get("AXLabel")
                        else None
                    ),
                }
                all_issues.append(issue_dict)

        # Count by severity
        critical = len([i for i in all_issues if i["severity"] == "critical"])
        warning = len([i for i in all_issues if i["severity"] == "warning"])
        info = len([i for i in all_issues if i["severity"] == "info"])

        # Build result (token-optimized)
        result = {
            "summary": {
                "total": len(elements),
                "issues": len(all_issues),
                "critical": critical,
                "warning": warning,
                "info": info,
            }
        }

        if verbose:
            # Full details only if requested
            result["issues"] = all_issues
        else:
            # Default: top issues only (token-efficient)
            result["top_issues"] = self._get_top_issues(all_issues)

        return result

    def _get_top_issues(self, issues: list[dict]) -> list[dict]:
        """Get top 3 issues grouped by type (token-efficient)."""
        if not issues:
            return []

        # Group by rule
        grouped = {}
        for issue in issues:
            rule = issue["rule"]
            if rule not in grouped:
                grouped[rule] = {
                    "severity": issue["severity"],
                    "rule": rule,
                    "count": 0,
                    "fix": issue["fix"],
                }
            grouped[rule]["count"] += 1

        # Sort by severity and count
        severity_order = {"critical": 0, "warning": 1, "info": 2}
        sorted_issues = sorted(
            grouped.values(), key=lambda x: (severity_order[x["severity"]], -x["count"])
        )

        return sorted_issues[:A11Y_TOP_ISSUES]


def main():
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Audit iOS simulator screen for accessibility issues"
    )
    parser.add_argument(
        "--udid",
        help="Device UDID (auto-detects booted simulator if not provided)",
    )
    parser.add_argument("--output", help="Save JSON report to file")
    parser.add_argument(
        "--verbose", action="store_true", help="Include all issue details (increases output)"
    )

    args = parser.parse_args()

    # Resolve UDID with auto-detection
    try:
        udid = resolve_udid(args.udid)
    except RuntimeError as e:
        print(f"Error: {e}")
        sys.exit(1)

    # Perform audit
    auditor = AccessibilityAuditor(udid=udid)

    try:
        result = auditor.audit(verbose=args.verbose)
    except Exception as e:
        print(f"Error: {e}")
        sys.exit(1)

    # Output results
    if args.output:
        # Save to file
        with open(args.output, "w") as f:
            json.dump(result, f, indent=2)
        # Print minimal summary
        summary = result["summary"]
        print(f"Audit complete: {summary['issues']} issues ({summary['critical']} critical)")
        print(f"Report saved to: {args.output}")
    # Print to stdout (token-optimized by default)
    elif args.verbose:
        print(json.dumps(result, indent=2))
    else:
        # Ultra-compact output
        summary = result["summary"]
        print(f"Elements: {summary['total']}, Issues: {summary['issues']}")
        print(
            f"Critical: {summary['critical']}, Warning: {summary['warning']}, Info: {summary['info']}"
        )

        if result.get("top_issues"):
            print("\nTop issues:")
            for issue in result["top_issues"]:
                print(
                    f"  [{issue['severity']}] {issue['rule']} ({issue['count']}x) - {issue['fix']}"
                )

    # Exit with error if critical issues found
    if result["summary"]["critical"] > 0:
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
iOS App Launcher - App Lifecycle Control

Launches, terminates, and manages iOS apps in the simulator.
Handles deep links and app switching.

Usage: python scripts/app_launcher.py --launch com.example.app

Launch arguments and environment variables can be passed to the app:
    python scripts/app_launcher.py --launch com.example.app \
        --env DEBUG=1 --args -uiTestingMode 1

--args consumes everything after it (argparse REMAINDER), so it must be the
last flag on the command line. --env is repeatable and each KEY=VALUE pair is
injected into the app process as SIMCTL_CHILD_KEY=VALUE.
"""

import argparse
import contextlib
import os
import subprocess
import sys
import time

from common import build_simctl_command, resolve_udid
from common.env_config import env_float, env_int

RELAUNCH_DELAY_SECONDS = env_float("IOS_SIM_RELAUNCH_DELAY_MS", 1000.0) / 1000.0
APPS_PREVIEW = env_int("IOS_SIM_APPS_PREVIEW", 30)


class AppLauncher:
    """Controls app lifecycle on iOS simulator."""

    def __init__(self, udid: str | None = None):
        """Initialize app launcher."""
        self.udid = udid

    def launch(
        self,
        bundle_id: str,
        wait_for_debugger: bool = False,
        launch_args: list[str] | None = None,
        env_vars: dict[str, str] | None = None,
    ) -> tuple[bool, int | None]:
        """
        Launch an app.

        Args:
            bundle_id: App bundle identifier
            wait_for_debugger: Wait for debugger attachment
            launch_args: Arguments passed to the app as trailing simctl args
            env_vars: Variables injected into the app process as SIMCTL_CHILD_*

        Returns:
            (success, pid) tuple
        """
        cmd = build_simctl_command("launch", self.udid, bundle_id, *(launch_args or []))

        if wait_for_debugger:
            cmd.insert(3, "--wait-for-debugger")  # Insert after "launch" operation

        # Inherit the parent env unless caller supplied app env vars (SIMCTL_CHILD_*).
        run_env = None
        if env_vars:
            run_env = {**os.environ, **{f"SIMCTL_CHILD_{k}": v for k, v in env_vars.items()}}

        try:
            result = subprocess.run(cmd, capture_output=True, text=True, check=True, env=run_env)
            # Parse PID from output if available
            pid = None
            if result.stdout:
                # Output format: "com.example.app: <PID>"
                parts = result.stdout.strip().split(":")
                if len(parts) > 1:
                    with contextlib.suppress(ValueError):
                        pid = int(parts[1].strip())
            return (True, pid)
        except subprocess.CalledProcessError:
            return (False, None)

    def terminate(self, bundle_id: str) -> bool:
        """
        Terminate an app.

        Args:
            bundle_id: App bundle identifier

        Returns:
            Success status
        """
        cmd = build_simctl_command("terminate", self.udid, bundle_id)

        try:
            subprocess.run(cmd, capture_output=True, check=True)
            return True
        except subprocess.CalledProcessError:
            return False

    def install(self, app_path: str) -> bool:
        """
        Install an app.

        Args:
            app_path: Path to .app bundle

        Returns:
            Success status
        """
        cmd = build_simctl_command("install", self.udid, app_path)

        try:
            subprocess.run(cmd, capture_output=True, check=True)
            return True
        except subprocess.CalledProcessError:
            return False

    def uninstall(self, bundle_id: str) -> bool:
        """
        Uninstall an app.

        Args:
            bundle_id: App bundle identifier

        Returns:
            Success status
        """
        cmd = build_simctl_command("uninstall", self.udid, bundle_id)

        try:
            subprocess.run(cmd, capture_output=True, check=True)
            return True
        except subprocess.CalledProcessError:
            return False

    def open_url(self, url: str) -> bool:
        """
        Open URL (for deep linking).

        Args:
            url: URL to open (http://, myapp://, etc.)

        Returns:
            Success status
        """
        cmd = build_simctl_command("openurl", self.udid, url)

        try:
            subprocess.run(cmd, capture_output=True, check=True)
            return True
        except subprocess.CalledProcessError:
            return False

    def list_apps(self) -> list[dict[str, str]]:
        """
        List installed apps.

        Returns:
            List of app info dictionaries
        """
        cmd = build_simctl_command("listapps", self.udid)

        try:
            result = subprocess.run(cmd, capture_output=True, text=True, check=True)

            # Parse plist output using plutil to convert to JSON
            plist_data = result.stdout

            # Use plutil to convert plist to JSON
            convert_cmd = ["plutil", "-convert", "json", "-o", "-", "-"]
            convert_result = subprocess.run(
                convert_cmd, check=False, input=plist_data, capture_output=True, text=True
            )

            apps = []
            if convert_result.returncode == 0:
                import json

                try:
                    data = json.loads(convert_result.stdout)
                    for bundle_id, app_info in data.items():
                        # Skip system internal apps that are hidden
                        if app_info.get("ApplicationType") == "Hidden":
                            continue

                        apps.append(
                            {
                                "bundle_id": bundle_id,
                                "name": app_info.get(
                                    "CFBundleDisplayName", app_info.get("CFBundleName", bundle_id)
                                ),
                                "path": app_info.get("Path", ""),
                                "version": app_info.get("CFBundleVersion", "Unknown"),
                                "type": app_info.get("ApplicationType", "User"),
                            }
                        )
                except json.JSONDecodeError:
                    pass

            return apps
        except subprocess.CalledProcessError:
            return []

    def get_app_state(self, bundle_id: str) -> str:
        """
        Get app state (running, suspended, etc.).

        Args:
            bundle_id: App bundle identifier

        Returns:
            State string or 'unknown'
        """
        # Check if app is running by trying to get its PID
        cmd = build_simctl_command("spawn", self.udid, "launchctl", "list")

        try:
            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
            if bundle_id in result.stdout:
                return "running"
            return "not running"
        except subprocess.CalledProcessError:
            return "unknown"

    def restart_app(
        self,
        bundle_id: str,
        delay: float = RELAUNCH_DELAY_SECONDS,
        launch_args: list[str] | None = None,
        env_vars: dict[str, str] | None = None,
    ) -> bool:
        """
        Restart an app (terminate then launch).

        Args:
            bundle_id: App bundle identifier
            delay: Delay between terminate and launch
            launch_args: Arguments forwarded to the relaunch
            env_vars: Variables forwarded to the relaunch as SIMCTL_CHILD_*

        Returns:
            Success status
        """
        # Terminate
        self.terminate(bundle_id)
        time.sleep(delay)

        # Launch
        success, _ = self.launch(bundle_id, launch_args=launch_args, env_vars=env_vars)
        return success


def main():
    """Main entry point."""
    parser = argparse.ArgumentParser(description="Control iOS app lifecycle")

    # Actions
    parser.add_argument("--launch", help="Launch app by bundle ID")
    parser.add_argument("--terminate", help="Terminate app by bundle ID")
    parser.add_argument("--restart", help="Restart app by bundle ID")
    parser.add_argument("--install", help="Install app from .app path")
    parser.add_argument("--uninstall", help="Uninstall app by bundle ID")
    parser.add_argument("--open-url", help="Open URL (deep link)")
    parser.add_argument("--list", action="store_true", help="List installed apps")
    parser.add_argument("--state", help="Get app state by bundle ID")

    # Options
    parser.add_argument(
        "--wait-for-debugger", action="store_true", help="Wait for debugger when launching"
    )
    parser.add_argument(
        "--udid",
        help="Device UDID (auto-detects booted simulator if not provided)",
    )
    parser.add_argument(
        "--env",
        action="append",
        metavar="KEY=VALUE",
        help="App environment variable (repeatable); injected as SIMCTL_CHILD_KEY",
    )
    # REMAINDER must be the last flag on the command line.
    parser.add_argument(
        "--args",
        nargs=argparse.REMAINDER,
        help="Launch arguments for the app (everything after this flag)",
    )

    args = parser.parse_args()

    # Parse --env KEY=VALUE pairs, failing fast on malformed input.
    env_vars: dict[str, str] = {}
    for pair in args.env or []:
        key, separator, value = pair.partition("=")
        if not separator or not key:
            print(f"Error: invalid --env '{pair}', expected KEY=VALUE", file=sys.stderr)
            sys.exit(1)
        env_vars[key] = value
    launch_args = args.args or None

    # Resolve UDID with auto-detection
    try:
        udid = resolve_udid(args.udid)
    except RuntimeError as e:
        print(f"Error: {e}")
        sys.exit(1)

    launcher = AppLauncher(udid=udid)

    # Execute requested action
    if args.launch:
        success, pid = launcher.launch(
            args.launch,
            args.wait_for_debugger,
            launch_args=launch_args,
            env_vars=env_vars or None,
        )
        if success:
            if pid:
                print(f"Launched {args.launch} (PID: {pid})")
            else:
                print(f"Launched {args.launch}")
        else:
            print(f"Failed to launch {args.launch}")
            sys.exit(1)

    elif args.terminate:
        if launcher.terminate(args.terminate):
            print(f"Terminated {args.terminate}")
        else:
            print(f"Failed to terminate {args.terminate}")
            sys.exit(1)

    elif args.restart:
        if launcher.restart_app(args.restart, launch_args=launch_args, env_vars=env_vars or None):
            print(f"Restarted {args.restart}")
        else:
            print(f"Failed to restart {args.restart}")
            sys.exit(1)

    elif args.install:
        if launcher.install(args.install):
            print(f"Installed {args.install}")
        else:
            print(f"Failed to install {args.install}")
            sys.exit(1)

    elif args.uninstall:
        if launcher.uninstall(args.uninstall):
            print(f"Uninstalled {args.uninstall}")
        else:
            print(f"Failed to uninstall {args.uninstall}")
            sys.exit(1)

    elif args.open_url:
        if launcher.open_url(args.open_url):
            print(f"Opened URL: {args.open_url}")
        else:
            print(f"Failed to open URL: {args.open_url}")
            sys.exit(1)

    elif args.list:
        apps = launcher.list_apps()
        if apps:
            print(f"Installed apps ({len(apps)}):")
            for app in apps[:APPS_PREVIEW]:
                print(f"  {app['bundle_id']}: {app['name']} (v{app['version']})")
            if len(apps) > APPS_PREVIEW:
                print(f"  ... and {len(apps) - APPS_PREVIEW} more")
        else:
            print("No apps found or failed to list")

    elif args.state:
        state = launcher.get_app_state(args.state)
        print(f"{args.state}: {state}")

    else:
        parser.print_help()
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
App State Capture for iOS Simulator

Captures complete app state including screenshot, accessibility tree, and logs.
Optimized for minimal token output.

Usage: python scripts/app_state_capture.py [options]
"""

import argparse
import json
import subprocess
import sys
from datetime import datetime
from pathlib import Path

from common import (
    capture_screenshot,
    count_elements,
    get_accessibility_tree,
    resolve_udid,
)
from common.env_config import env_int

STATE_SUBPROCESS_TIMEOUT = env_int("IOS_SIM_STATE_SUBPROCESS_TIMEOUT", 15)


class AppStateCapture:
    """Captures comprehensive app state for debugging."""

    def __init__(
        self,
        app_bundle_id: str | None = None,
        udid: str | None = None,
        inline: bool = False,
        screenshot_size: str = "half",
    ):
        """
        Initialize state capture.

        Args:
            app_bundle_id: Optional app bundle ID for log filtering
            udid: Optional device UDID (uses booted if not specified)
            inline: If True, return screenshots as base64 (for vision-based automation)
            screenshot_size: 'full', 'half', 'quarter', 'thumb' (default: 'half')
        """
        self.app_bundle_id = app_bundle_id
        self.udid = udid
        self.inline = inline
        self.screenshot_size = screenshot_size

    def capture_screenshot(self, output_path: Path) -> bool:
        """Capture screenshot of current screen."""
        cmd = ["xcrun", "simctl", "io"]

        if self.udid:
            cmd.append(self.udid)
        else:
            cmd.append("booted")

        cmd.extend(["screenshot", str(output_path)])

        try:
            subprocess.run(cmd, capture_output=True, check=True)
            return True
        except subprocess.CalledProcessError:
            return False

    def capture_accessibility_tree(self, output_path: Path) -> dict:
        """Capture accessibility tree using shared utility."""
        try:
            # Use shared utility to fetch tree
            tree = get_accessibility_tree(self.udid, nested=True)

            # Save tree
            with open(output_path, "w") as f:
                json.dump(tree, f, indent=2)

            # Return summary using shared utility
            return {"captured": True, "element_count": count_elements(tree)}
        except Exception as e:
            return {"captured": False, "error": str(e)}

    def capture_logs(self, output_path: Path, line_limit: int = 100) -> dict:
        """Capture recent app logs."""
        if not self.app_bundle_id:
            # Can't capture logs without app ID
            return {"captured": False, "reason": "No app bundle ID specified"}

        # Get app name from bundle ID (simplified)
        app_name = self.app_bundle_id.split(".")[-1]

        cmd = ["xcrun", "simctl", "spawn"]

        if self.udid:
            cmd.append(self.udid)
        else:
            cmd.append("booted")

        cmd.extend(
            [
                "log",
                "show",
                "--predicate",
                f'process == "{app_name}"',
                "--last",
                "1m",  # Last 1 minute
                "--style",
                "compact",
            ]
        )

        try:
            result = subprocess.run(
                cmd,
                check=False,
                capture_output=True,
                text=True,
                timeout=STATE_SUBPROCESS_TIMEOUT,
            )
            logs = result.stdout

            # Limit lines for token efficiency
            lines = logs.split("\n")
            if len(lines) > line_limit:
                lines = lines[-line_limit:]

            # Save logs
            with open(output_path, "w") as f:
                f.write("\n".join(lines))

            # Analyze for issues
            warning_count = sum(1 for line in lines if "warning" in line.lower())
            error_count = sum(1 for line in lines if "error" in line.lower())

            return {
                "captured": True,
                "lines": len(lines),
                "warnings": warning_count,
                "errors": error_count,
            }
        except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as e:
            return {"captured": False, "error": str(e)}

    def capture_device_info(self) -> dict:
        """Get device information."""
        cmd = ["xcrun", "simctl", "list", "devices", "booted"]

        if self.udid:
            # Specific device info
            cmd = ["xcrun", "simctl", "list", "devices"]

        try:
            result = subprocess.run(cmd, capture_output=True, text=True, check=True)

            # Parse output for device info (simplified)
            lines = result.stdout.split("\n")
            device_info = {}

            for line in lines:
                if "iPhone" in line or "iPad" in line:
                    # Extract device name and state
                    parts = line.strip().split("(")
                    if parts:
                        device_info["name"] = parts[0].strip()
                        if len(parts) > 2:
                            device_info["udid"] = parts[1].replace(")", "").strip()
                            device_info["state"] = parts[2].replace(")", "").strip()
                    break

            return device_info
        except subprocess.CalledProcessError:
            return {}

    def capture_all(
        self, output_dir: str, log_lines: int = 100, app_name: str | None = None
    ) -> dict:
        """
        Capture complete app state.

        Args:
            output_dir: Directory to save artifacts
            log_lines: Number of log lines to capture
            app_name: App name for semantic naming (for inline mode)

        Returns:
            Summary of captured state
        """
        # Create output directory (only if not in inline mode)
        output_path = Path(output_dir)
        timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
        if not self.inline:
            capture_dir = output_path / f"app-state-{timestamp}"
            capture_dir.mkdir(parents=True, exist_ok=True)
        else:
            capture_dir = None

        summary = {
            "timestamp": datetime.now().isoformat(),
            "screenshot_mode": "inline" if self.inline else "file",
        }

        if capture_dir:
            summary["output_dir"] = str(capture_dir)

        # Capture screenshot using new unified utility
        screenshot_result = capture_screenshot(
            self.udid,
            size=self.screenshot_size,
            inline=self.inline,
            app_name=app_name,
        )

        if self.inline:
            # Inline mode: store base64
            summary["screenshot"] = {
                "mode": "inline",
                "base64": screenshot_result["base64_data"],
                "width": screenshot_result["width"],
                "height": screenshot_result["height"],
                "size_preset": self.screenshot_size,
            }
        else:
            # File mode: save to disk
            screenshot_path = capture_dir / "screenshot.png"
            # Move temp file to target location
            import shutil

            shutil.move(screenshot_result["file_path"], screenshot_path)
            summary["screenshot"] = {
                "mode": "file",
                "file": "screenshot.png",
                "size_bytes": screenshot_result["size_bytes"],
            }

        # Capture accessibility tree
        if not self.inline or capture_dir:
            accessibility_path = (capture_dir or output_path) / "accessibility-tree.json"
        else:
            accessibility_path = None

        if accessibility_path:
            tree_info = self.capture_accessibility_tree(accessibility_path)
            summary["accessibility"] = tree_info

        # Capture logs (if app ID provided)
        if self.app_bundle_id:
            if not self.inline or capture_dir:
                logs_path = (capture_dir or output_path) / "app-logs.txt"
            else:
                logs_path = None

            if logs_path:
                log_info = self.capture_logs(logs_path, log_lines)
                summary["logs"] = log_info

        # Get device info
        device_info = self.capture_device_info()
        if device_info:
            summary["device"] = device_info
            # Save device info (file mode only)
            if capture_dir:
                with open(capture_dir / "device-info.json", "w") as f:
                    json.dump(device_info, f, indent=2)

        # Save summary (file mode only)
        if capture_dir:
            with open(capture_dir / "summary.json", "w") as f:
                json.dump(summary, f, indent=2)

            # Create markdown summary
            self._create_summary_md(capture_dir, summary)

        return summary

    def _create_summary_md(self, capture_dir: Path, summary: dict) -> None:
        """Create markdown summary file."""
        md_path = capture_dir / "summary.md"

        with open(md_path, "w") as f:
            f.write("# App State Capture\n\n")
            f.write(f"**Timestamp:** {summary['timestamp']}\n\n")

            if "device" in summary:
                f.write("## Device\n")
                device = summary["device"]
                f.write(f"- Name: {device.get('name', 'Unknown')}\n")
                f.write(f"- UDID: {device.get('udid', 'N/A')}\n")
                f.write(f"- State: {device.get('state', 'Unknown')}\n\n")

            f.write("## Screenshot\n")
            f.write("![Current Screen](screenshot.png)\n\n")

            if "accessibility" in summary:
                acc = summary["accessibility"]
                f.write("## Accessibility\n")
                if acc.get("captured"):
                    f.write(f"- Elements: {acc.get('element_count', 0)}\n")
                else:
                    f.write(f"- Error: {acc.get('error', 'Unknown')}\n")
                f.write("\n")

            if "logs" in summary:
                logs = summary["logs"]
                f.write("## Logs\n")
                if logs.get("captured"):
                    f.write(f"- Lines: {logs.get('lines', 0)}\n")
                    f.write(f"- Warnings: {logs.get('warnings', 0)}\n")
                    f.write(f"- Errors: {logs.get('errors', 0)}\n")
                else:
                    f.write(f"- {logs.get('reason', logs.get('error', 'Not captured'))}\n")
                f.write("\n")

            f.write("## Files\n")
            f.write("- `screenshot.png` - Current screen\n")
            f.write("- `accessibility-tree.json` - Full UI hierarchy\n")
            if self.app_bundle_id:
                f.write("- `app-logs.txt` - Recent app logs\n")
            f.write("- `device-info.json` - Device details\n")
            f.write("- `summary.json` - Complete capture metadata\n")


def main():
    """Main entry point."""
    parser = argparse.ArgumentParser(description="Capture complete app state for debugging")
    parser.add_argument(
        "--app-bundle-id", help="App bundle ID for log filtering (e.g., com.example.app)"
    )
    parser.add_argument(
        "--output", default=".", help="Output directory (default: current directory)"
    )
    parser.add_argument(
        "--log-lines", type=int, default=100, help="Number of log lines to capture (default: 100)"
    )
    parser.add_argument(
        "--udid",
        help="Device UDID (auto-detects booted simulator if not provided)",
    )
    parser.add_argument(
        "--inline",
        action="store_true",
        help="Return screenshots as base64 (inline mode for vision-based automation)",
    )
    parser.add_argument(
        "--size",
        choices=["full", "half", "quarter", "thumb"],
        default="half",
        help="Screenshot size for token optimization (default: half)",
    )
    parser.add_argument("--app-name", help="App name for semantic screenshot naming")

    args = parser.parse_args()

    # Resolve UDID with auto-detection
    try:
        udid = resolve_udid(args.udid)
    except RuntimeError as e:
        print(f"Error: {e}")
        sys.exit(1)

    # Create capturer
    capturer = AppStateCapture(
        app_bundle_id=args.app_bundle_id,
        udid=udid,
        inline=args.inline,
        screenshot_size=args.size,
    )

    # Capture state
    try:
        summary = capturer.capture_all(
            output_dir=args.output, log_lines=args.log_lines, app_name=args.app_name
        )

        # Token-efficient output
        if "output_dir" in summary:
            print(f"State captured: {summary['output_dir']}/")
        else:
            # Inline mode
            print(
                f"State captured (inline mode): {summary['screenshot']['width']}x{summary['screenshot']['height']}"
            )

        # Report any issues found
        if "logs" in summary and summary["logs"].get("captured"):
            logs = summary["logs"]
            if logs["errors"] > 0 or logs["warnings"] > 0:
                print(f"Issues found: {logs['errors']} errors, {logs['warnings']} warnings")

        if "accessibility" in summary and summary["accessibility"].get("captured"):
            print(f"Elements: {summary['accessibility']['element_count']}")

    except Exception as e:
        print(f"Error: {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
iOS Simulator Appearance Manager

Control dark mode, dynamic type size, locale, and region.
Wraps xcrun simctl ui and defaults write for appearance testing.

Usage:
  python scripts/appearance.py --theme dark
  python scripts/appearance.py --text-size AX3
  python scripts/appearance.py --locale ar --region SA --bundle-id com.myapp
  python scripts/appearance.py --reset

RTL locales: ar, he, fa, ur, yi (app must restart to reflow layout).
"""

import argparse
import json
import subprocess
import sys

from common import resolve_udid

# === CONSTANTS ===

# Map friendly size aliases to xcrun simctl content_size tokens
TEXT_SIZE_MAP: dict[str, str] = {
    "XS": "extra-small",
    "S": "small",
    "M": "medium",
    "L": "large",
    "XL": "extra-large",
    "XXL": "extra-extra-large",
    "XXXL": "extra-extra-extra-large",
    "AX1": "accessibility-medium",
    "AX2": "accessibility-large",
    "AX3": "accessibility-extra-large",
    "AX4": "accessibility-extra-extra-large",
    "AX5": "accessibility-extra-extra-extra-large",
}

# Locales that require RTL layout direction
RTL_LOCALES: frozenset[str] = frozenset({"ar", "he", "fa", "ur", "yi"})

# Default appearance values used by --reset
DEFAULT_THEME = "light"
DEFAULT_TEXT_SIZE = "M"
DEFAULT_LOCALE = "en"
DEFAULT_REGION = "US"


# === APPEARANCE MANAGER ===


class AppearanceManager:
    """Manages iOS simulator appearance: theme, dynamic type, and locale."""

    def __init__(self, udid: str | None = None):
        """Initialize appearance manager.

        Args:
            udid: Optional device UDID (auto-detects booted simulator if None)
        """
        self.udid = udid

    # === PUBLIC API ===

    def set_theme(self, theme: str) -> tuple[bool, str]:
        """Switch simulator between light and dark appearance.

        Args:
            theme: 'light' or 'dark'

        Returns:
            (success, message)
        """
        cmd = ["xcrun", "simctl", "ui", self.udid, "appearance", theme]
        return self._run(cmd, f"Theme set: {theme}")

    def set_text_size(self, alias: str) -> tuple[bool, str]:
        """Set dynamic type content size.

        Args:
            alias: Friendly alias (XS, S, M, L, XL, XXL, XXXL, AX1-AX5)

        Returns:
            (success, message)
        """
        token = TEXT_SIZE_MAP.get(alias.upper())
        if not token:
            valid = ", ".join(TEXT_SIZE_MAP.keys())
            return False, f"Unknown text size '{alias}'. Valid: {valid}"

        cmd = ["xcrun", "simctl", "ui", self.udid, "content_size", token]
        return self._run(cmd, f"Text size set: {alias} ({token})")

    def set_locale(
        self,
        locale: str,
        region: str | None = None,
        bundle_id: str | None = None,
    ) -> tuple[bool, str]:
        """Write AppleLanguages and AppleLocale to simulator global defaults.

        Optionally restarts a specific app via bundle ID so the locale takes
        effect immediately. Without --bundle-id the change applies on next
        cold app launch.

        Args:
            locale: BCP-47 language code (e.g. 'en', 'ar', 'de')
            region: ISO 3166-1 alpha-2 region code (e.g. 'US', 'SA', 'IE')
            bundle_id: Optional app bundle ID — triggers terminate + launch

        Returns:
            (success, message)
        """
        apple_locale = f"{locale}_{region}" if region else locale

        # Write AppleLanguages array
        lang_cmd = [
            "xcrun",
            "simctl",
            "spawn",
            self.udid,
            "defaults",
            "write",
            "-g",
            "AppleLanguages",
            "-array",
            locale,
        ]
        ok, msg = self._run(lang_cmd, "")
        if not ok:
            return False, f"Failed to write AppleLanguages: {msg}"

        # Write AppleLocale string
        locale_cmd = [
            "xcrun",
            "simctl",
            "spawn",
            self.udid,
            "defaults",
            "write",
            "-g",
            "AppleLocale",
            "-string",
            apple_locale,
        ]
        ok, msg = self._run(locale_cmd, "")
        if not ok:
            return False, f"Failed to write AppleLocale: {msg}"

        is_rtl = locale in RTL_LOCALES
        rtl_note = " [RTL layout]" if is_rtl else ""
        summary = f"Locale set: {apple_locale}{rtl_note}"

        if bundle_id:
            restart_ok, restart_msg = self._restart_app(bundle_id)
            if restart_ok:
                summary += f" — app restarted: {bundle_id}"
            else:
                summary += f" — locale written but app restart failed: {restart_msg}"
        else:
            summary += " — restart app to apply"

        return True, summary

    def reset(self) -> tuple[bool, str]:
        """Reset theme, text size, and locale to system defaults.

        Returns:
            (success, message)
        """
        results: list[str] = []
        errors: list[str] = []

        ok, msg = self.set_theme(DEFAULT_THEME)
        (results if ok else errors).append(msg)

        ok, msg = self.set_text_size(DEFAULT_TEXT_SIZE)
        (results if ok else errors).append(msg)

        ok, msg = self.set_locale(DEFAULT_LOCALE, DEFAULT_REGION)
        (results if ok else errors).append(msg)

        if errors:
            return False, f"Reset partial — errors: {'; '.join(errors)}"

        return True, "Appearance reset to defaults (light / M / en_US)"

    # === PRIVATE HELPERS ===

    def _run(self, cmd: list[str], success_message: str) -> tuple[bool, str]:
        """Run subprocess command and return (success, message).

        Args:
            cmd: Command list (never shell=True)
            success_message: Human-readable success summary

        Returns:
            (success, message)
        """
        try:
            subprocess.run(
                cmd,
                capture_output=True,
                text=True,
                check=True,
            )
            return True, success_message
        except subprocess.CalledProcessError as error:
            stderr = error.stderr.strip() if error.stderr else "unknown error"
            return False, stderr

    def _restart_app(self, bundle_id: str) -> tuple[bool, str]:
        """Terminate then launch an app by bundle ID.

        Args:
            bundle_id: App bundle ID

        Returns:
            (success, message)
        """
        terminate_cmd = ["xcrun", "simctl", "terminate", self.udid, bundle_id]
        # Terminate may fail if app is not running — that is acceptable
        subprocess.run(terminate_cmd, capture_output=True, check=False)

        launch_cmd = ["xcrun", "simctl", "launch", self.udid, bundle_id]
        try:
            subprocess.run(launch_cmd, capture_output=True, text=True, check=True)
            return True, f"Launched {bundle_id}"
        except subprocess.CalledProcessError as error:
            stderr = error.stderr.strip() if error.stderr else "launch failed"
            return False, stderr


# === CLI ===


def main() -> None:
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description=(
            "iOS Simulator Appearance Manager — control dark mode, "
            "dynamic type, locale, and region."
        ),
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  python scripts/appearance.py --theme dark
  python scripts/appearance.py --text-size AX3
  python scripts/appearance.py --locale ar --region SA
  python scripts/appearance.py --locale de --region DE --bundle-id com.myapp
  python scripts/appearance.py --reset

RTL locales (ar, he, fa, ur, yi): app must restart to reflow layout.
Text sizes: XS S M L XL XXL XXXL AX1 AX2 AX3 AX4 AX5
        """,
    )

    parser.add_argument(
        "--theme",
        choices=["light", "dark"],
        help="Set light or dark appearance",
    )
    parser.add_argument(
        "--text-size",
        choices=list(TEXT_SIZE_MAP.keys()),
        metavar="{" + ",".join(TEXT_SIZE_MAP.keys()) + "}",
        help="Set dynamic type size (XS smallest, AX5 largest)",
    )
    parser.add_argument(
        "--locale",
        metavar="CODE",
        help="Set locale language code (e.g. en, de, ar, ja)",
    )
    parser.add_argument(
        "--region",
        metavar="CODE",
        help="Set region code (e.g. US, IE, SA). Used with --locale.",
    )
    parser.add_argument(
        "--bundle-id",
        metavar="BUNDLE_ID",
        help="App bundle ID to terminate+relaunch after locale change",
    )
    parser.add_argument(
        "--reset",
        action="store_true",
        help="Reset theme, text size, and locale to system defaults",
    )
    parser.add_argument(
        "--udid",
        help="Device UDID (auto-detects booted simulator if not provided)",
    )
    parser.add_argument(
        "--json",
        action="store_true",
        help="Output results as JSON",
    )
    parser.add_argument(
        "--verbose",
        action="store_true",
        help="Show detailed output",
    )

    args = parser.parse_args()

    # Guard: require at least one action
    if not any([args.theme, args.text_size, args.locale, args.reset]):
        parser.print_help()
        sys.exit(1)

    # Guard: --reset is incompatible with explicit appearance flags
    if args.reset and any([args.theme, args.text_size, args.locale]):
        print(
            "Error: --reset cannot be combined with --theme, --text-size, or --locale",
            file=sys.stderr,
        )
        sys.exit(1)

    # Guard: --region without --locale is a no-op
    if args.region and not args.locale:
        print("Error: --region requires --locale", file=sys.stderr)
        sys.exit(1)

    # Guard: --bundle-id without --locale is ambiguous
    if args.bundle_id and not args.locale:
        print("Error: --bundle-id requires --locale", file=sys.stderr)
        sys.exit(1)

    try:
        udid = resolve_udid(args.udid)
    except RuntimeError as error:
        print(f"Error: {error}", file=sys.stderr)
        sys.exit(1)

    manager = AppearanceManager(udid=udid)
    device_label = udid if udid else "booted"

    # Collect all requested operations
    operations: list[tuple[str, tuple[bool, str]]] = []

    if args.reset:
        operations.append(("reset", manager.reset()))
    else:
        if args.theme:
            operations.append(("theme", manager.set_theme(args.theme)))

        if args.text_size:
            operations.append(("text_size", manager.set_text_size(args.text_size)))

        if args.locale:
            operations.append(
                (
                    "locale",
                    manager.set_locale(args.locale, args.region, args.bundle_id),
                )
            )

    overall_success = all(ok for _, (ok, _) in operations)

    if args.json:
        results = {action: {"success": ok, "message": msg} for action, (ok, msg) in operations}
        payload = {
            "success": overall_success,
            "udid": device_label,
            "results": results,
        }
        print(json.dumps(payload))
    elif args.verbose:
        print(f"Device: {device_label}")
        for action, (ok, msg) in operations:
            status = "OK" if ok else "FAIL"
            print(f"  [{status}] {action}: {msg}")
    else:
        for _, (_ok, msg) in operations:
            if msg:
                print(msg)

    sys.exit(0 if overall_success else 1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Build and Test Automation for Xcode Projects

Ultra token-efficient build automation with progressive disclosure via xcresult bundles.

Features:
- Minimal default output (5-10 tokens)
- Progressive disclosure for error/warning/log details
- Native xcresult bundle support
- Clean modular architecture

Usage Examples:
    # Build (minimal output)
    python scripts/build_and_test.py --project MyApp.xcodeproj
    # Output: Build: SUCCESS (0 errors, 3 warnings) [xcresult-20251018-143052]

    # Get error details
    python scripts/build_and_test.py --get-errors xcresult-20251018-143052

    # Get warnings
    python scripts/build_and_test.py --get-warnings xcresult-20251018-143052

    # Get build log
    python scripts/build_and_test.py --get-log xcresult-20251018-143052

    # Get everything as JSON
    python scripts/build_and_test.py --get-all xcresult-20251018-143052 --json

    # List recent builds
    python scripts/build_and_test.py --list-xcresults

    # Verbose mode (for debugging)
    python scripts/build_and_test.py --project MyApp.xcodeproj --verbose
"""

import argparse
import sys
from pathlib import Path

# Import our modular components
from common.env_config import env_int

from xcode import BuildRunner, OutputFormatter, XCResultCache, XCResultParser

BUILD_LOG_PREVIEW_CHARS = env_int("IOS_SIM_BUILD_LOG_PREVIEW", 4000)
BUILD_JSON_CAP = env_int("IOS_SIM_BUILD_JSON_CAP", 50)


def main():
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Build and test Xcode projects with progressive disclosure",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  # Build project (minimal output)
  python scripts/build_and_test.py --project MyApp.xcodeproj

  # Run tests
  python scripts/build_and_test.py --project MyApp.xcodeproj --test

  # Get error details from previous build
  python scripts/build_and_test.py --get-errors xcresult-20251018-143052

  # Get all details as JSON
  python scripts/build_and_test.py --get-all xcresult-20251018-143052 --json

  # List recent builds
  python scripts/build_and_test.py --list-xcresults
        """,
    )

    # Build/test mode arguments
    build_group = parser.add_argument_group("Build/Test Options")
    project_group = build_group.add_mutually_exclusive_group()
    project_group.add_argument("--project", help="Path to .xcodeproj file")
    project_group.add_argument("--workspace", help="Path to .xcworkspace file")

    build_group.add_argument("--scheme", help="Build scheme (auto-detected if not specified)")
    build_group.add_argument(
        "--configuration",
        default="Debug",
        help="Build configuration (default: Debug). Accepts any valid Xcode configuration.",
    )
    build_group.add_argument("--simulator", help="Simulator name (default: iPhone 15)")
    build_group.add_argument("--clean", action="store_true", help="Clean before building")
    build_group.add_argument("--test", action="store_true", help="Run tests")
    build_group.add_argument("--suite", help="Specific test suite to run")

    # Progressive disclosure arguments
    disclosure_group = parser.add_argument_group("Progressive Disclosure Options")
    disclosure_group.add_argument(
        "--get-errors", metavar="XCRESULT_ID", help="Get error details from xcresult"
    )
    disclosure_group.add_argument(
        "--get-warnings", metavar="XCRESULT_ID", help="Get warning details from xcresult"
    )
    disclosure_group.add_argument(
        "--get-log", metavar="XCRESULT_ID", help="Get build log from xcresult"
    )
    disclosure_group.add_argument(
        "--get-all", metavar="XCRESULT_ID", help="Get all details from xcresult"
    )
    disclosure_group.add_argument(
        "--list-xcresults", action="store_true", help="List recent xcresult bundles"
    )

    # Output options
    output_group = parser.add_argument_group("Output Options")
    output_group.add_argument("--verbose", action="store_true", help="Show detailed output")
    output_group.add_argument("--json", action="store_true", help="Output as JSON")

    args = parser.parse_args()

    # Initialize cache
    cache = XCResultCache()

    # Handle list mode
    if args.list_xcresults:
        xcresults = cache.list()
        if args.json:
            import json

            print(json.dumps(xcresults, indent=2))
        elif not xcresults:
            print("No xcresult bundles found")
        else:
            print(f"Recent XCResult bundles ({len(xcresults)}):")
            print()
            for xc in xcresults:
                print(f"  {xc['id']}")
                print(f"    Created: {xc['created']}")
                print(f"    Size: {xc['size_mb']} MB")
                print()
        return 0

    # Handle retrieval modes
    xcresult_id = args.get_errors or args.get_warnings or args.get_log or args.get_all

    if xcresult_id:
        xcresult_path = cache.get_path(xcresult_id)

        if not xcresult_path or not xcresult_path.exists():
            print(f"Error: XCResult bundle not found: {xcresult_id}", file=sys.stderr)
            print("Use --list-xcresults to see available bundles", file=sys.stderr)
            return 1

        # Load cached stderr for progressive disclosure
        cached_stderr = cache.get_stderr(xcresult_id)
        parser = XCResultParser(xcresult_path, stderr=cached_stderr)

        # Get errors
        if args.get_errors:
            errors = parser.get_errors()
            if args.json:
                import json

                print(json.dumps(errors, indent=2))
            else:
                print(OutputFormatter.format_errors(errors))
            return 0

        # Get warnings
        if args.get_warnings:
            warnings = parser.get_warnings()
            if args.json:
                import json

                print(json.dumps(warnings, indent=2))
            else:
                print(OutputFormatter.format_warnings(warnings))
            return 0

        # Get log
        if args.get_log:
            log = parser.get_build_log()
            if log:
                print(OutputFormatter.format_log(log))
            else:
                print("No build log available", file=sys.stderr)
                return 1
            return 0

        # Get all
        if args.get_all:
            error_count, warning_count = parser.count_issues()
            errors = parser.get_errors()
            warnings = parser.get_warnings()
            build_log = parser.get_build_log()

            if args.json:
                import json

                data = {
                    "xcresult_id": xcresult_id,
                    "error_count": error_count,
                    "warning_count": warning_count,
                    "errors": errors,
                    "warnings": warnings,
                    "log_preview": build_log[:BUILD_LOG_PREVIEW_CHARS] if build_log else None,
                }
                print(json.dumps(data, indent=2))
            else:
                print(f"XCResult: {xcresult_id}")
                print(f"Errors: {error_count}, Warnings: {warning_count}")
                print()
                if errors:
                    print(OutputFormatter.format_errors(errors, limit=10))
                    print()
                if warnings:
                    print(OutputFormatter.format_warnings(warnings, limit=10))
                    print()
                if build_log:
                    print("Build Log (last 30 lines):")
                    print(OutputFormatter.format_log(build_log, lines=30))
            return 0

    # Build/test mode
    if not args.project and not args.workspace:
        # Try to auto-detect in current directory
        cwd = Path.cwd()
        projects = list(cwd.glob("*.xcodeproj"))
        workspaces = list(cwd.glob("*.xcworkspace"))

        if workspaces:
            args.workspace = str(workspaces[0])
        elif projects:
            args.project = str(projects[0])
        else:
            parser.error("No project or workspace specified and none found in current directory")

    # Initialize builder
    builder = BuildRunner(
        project_path=args.project,
        workspace_path=args.workspace,
        scheme=args.scheme,
        configuration=args.configuration,
        simulator=args.simulator,
        cache=cache,
    )

    # Execute build or test
    if args.test:
        success, xcresult_id, stderr = builder.test(test_suite=args.suite)
    else:
        success, xcresult_id, stderr = builder.build(clean=args.clean)

    if not xcresult_id and not stderr:
        print("Error: Build/test failed without creating xcresult or error output", file=sys.stderr)
        return 1

    # Save stderr to cache for progressive disclosure
    if xcresult_id and stderr:
        cache.save_stderr(xcresult_id, stderr)

    # Parse results
    xcresult_path = cache.get_path(xcresult_id) if xcresult_id else None
    parser = XCResultParser(xcresult_path, stderr=stderr)
    error_count, warning_count = parser.count_issues()

    # Format output
    status = "SUCCESS" if success else "FAILED"

    # Collect errors on failure (used by all output modes)
    errors = parser.get_errors() if not success else None
    hints = OutputFormatter.generate_hints(errors) if errors else None

    # Collect test info and failed tests when testing
    test_info = None
    failed_tests = None
    if args.test and xcresult_path:
        test_results = parser.get_test_results()
        if test_results:
            # Xcode 16 `xcresulttool get test-results summary` keys are
            # totalTestCount / passedTests / failedTests (fall back to the
            # legacy total/passed/failed names for older Xcode).
            start = test_results.get("startTime")
            finish = test_results.get("finishTime")
            duration = (
                round(finish - start, 1)
                if isinstance(start, (int, float)) and isinstance(finish, (int, float))
                else test_results.get("duration", 0.0)
            )
            test_info = {
                "total": test_results.get("totalTestCount", test_results.get("total", 0)),
                "passed": test_results.get("passedTests", test_results.get("passed", 0)),
                "failed": test_results.get("failedTests", test_results.get("failed", 0)),
                "duration": duration,
            }
        if not success:
            failed_tests = parser.get_failed_tests()

    if args.verbose:
        # Verbose mode with error/warning details
        verbose_errors = errors if error_count > 0 else None
        warnings = parser.get_warnings() if warning_count > 0 else None

        output = OutputFormatter.format_verbose(
            status=status,
            error_count=error_count,
            warning_count=warning_count,
            xcresult_id=xcresult_id or "N/A",
            errors=verbose_errors,
            warnings=warnings,
            test_info=test_info,
        )
        print(output)
    elif args.json:
        # JSON mode
        data = {
            "success": success,
            "xcresult_id": xcresult_id or None,
            "error_count": error_count,
            "warning_count": warning_count,
        }
        if test_info:
            data["test_info"] = test_info
        if not success:
            if errors:
                data["errors"] = errors[:BUILD_JSON_CAP]
            if failed_tests:
                data["failed_tests"] = failed_tests[:BUILD_JSON_CAP]
        if hints:
            data["hints"] = hints
        import json

        print(json.dumps(data, indent=2))
    else:
        # Minimal mode (default)
        output = OutputFormatter.format_minimal(
            status=status,
            error_count=error_count,
            warning_count=warning_count,
            xcresult_id=xcresult_id or "N/A",
            test_info=test_info,
            hints=hints,
            errors=errors,
            failed_tests=failed_tests,
        )
        print(output)

    # Exit with appropriate code
    return 0 if success else 1


if __name__ == "__main__":
    sys.exit(main())