AppPilot

dependencies: [
    .package(url: "https://github.com/your-username/AppPilot.git", from: "1.2.0")
]

import AppPilot

let pilot = AppPilot()

// Find an application
let app = try await pilot.findApplication(name: "Calculator")
let window = try await pilot.findWindow(app: app, index: 0)

// Discover UI elements
let buttons = try await pilot.findElements(in: window, role: .button)
let numberFive = try await pilot.findButton(in: window, title: "5")

// Perform element-based actions
try await pilot.click(element: numberFive)
try await pilot.click(element: try await pilot.findButton(in: window, title: "+"))
try await pilot.click(element: try await pilot.findButton(in: window, title: "3"))
try await pilot.click(element: try await pilot.findButton(in: window, title: "="))

// ❌ Old approach: Hardcoded coordinates
try await pilot.click(window: window, at: Point(x: 200, y: 300))

// ✅ New approach: Smart element discovery
let submitButton = try await pilot.findButton(in: window, title: "Submit")
try await pilot.click(element: submitButton)

// Find by role and title
let saveButton = try await pilot.findElement(in: window, role: .button, title: "Save")

// Find by identifier
let searchField = try await pilot.findElements(in: window, identifier: "search_input")

// Find all buttons
let allButtons = try await pilot.findElements(in: window, role: .button)

// Find text fields
let textField = try await pilot.findTextField(in: window)

// Wait for element to appear
let loadingComplete = try await pilot.waitForElement(
    in: window,
    role: .staticText,
    title: "Loading complete",
    timeout: 10.0
)

// Wait for specific time
try await pilot.wait(.time(seconds: 2.0))

// Wait for element to disappear
try await pilot.wait(.elementDisappear(window: window, role: .button, title: "Loading..."))

@Test("Complete TestApp integration test")
func testTestAppIntegration() async throws {
    let pilot = AppPilot()
    
    // Stage 1: 見る (See/Observe) - Application & UI Discovery
    let testApp = try await pilot.findApplication(name: "TestApp")
    let window = try await pilot.findWindow(app: testApp, title: "Mouse Click")
    
    // Stage 2: 理解する (Understand) - Element Analysis
    let allElements = try await pilot.findElements(in: window)
    let clickTargets = allElements.filter { $0.role == .button }
    
    #expect(clickTargets.count >= 5, "Should find at least 5 click targets")
    
    // Stage 3: アクション (Action) - Element-based Automation
    let testSession = try await TestSession.create(pilot: pilot, testType: .mouseClick)
    await testSession.resetState()
    
    for target in clickTargets {
        let beforeState = await testSession.getClickTargets()
        let beforeCount = beforeState.filter { $0.clicked }.count
        
        // Perform element-based click
        let result = try await pilot.click(element: target)
        #expect(result.success, "Click should succeed for \(target.title ?? target.id)")
        
        try await pilot.wait(.time(seconds: 0.5))
        
        // Verify via TestApp API
        let afterState = await testSession.getClickTargets()
        let afterCount = afterState.filter { $0.clicked }.count
        
        #expect(afterCount > beforeCount, "TestApp should detect click on \(target.title ?? target.id)")
    }
}

@Test("Input source management test")
func testInputSourceManagement() async throws {
    let pilot = AppPilot()
    
    // Test current input source
    let currentSource = try await pilot.getCurrentInputSource()
    #expect(!currentSource.identifier.isEmpty)
    
    // Test available sources
    let sources = try await pilot.getAvailableInputSources()
    #expect(sources.count > 0)
    
    // Test text input with different sources
    let testApp = try await pilot.findApplication(name: "TestApp")
    let window = try await pilot.findWindow(app: testApp, title: "Keyboard")
    let textField = try await pilot.findTextField(in: window)
    
    // Type with English input
    try await pilot.type(text: "Hello", into: textField, inputSource: .english)
    
    // Type with Japanese input (if available)
    // Test Japanese composition input
    if sources.contains(where: { $0.identifier.contains("Japanese") }) {
        let result = try await pilot.input("konnichiwa", into: textField, with: .japaneseRomaji)
        #expect(result.success, "Japanese composition input should succeed")
        
        if result.needsUserDecision {
            // Test candidate selection
            let selection = try await pilot.selectCandidate(at: 0, for: textField)
            #expect(selection.success, "Candidate selection should succeed")
        }
    }
}

// List all applications
let apps = try await pilot.listApplications()

// Find application by bundle ID
let safari = try await pilot.findApplication(bundleId: "com.apple.Safari")

// Find application by name
let finder = try await pilot.findApplication(name: "Finder")

// Get windows for an application
let windows = try await pilot.listWindows(app: safari)

// Find specific window
let mainWindow = try await pilot.findWindow(app: safari, title: "Safari")

// Find elements with flexible criteria
let elements = try await pilot.findElements(
    in: window,
    role: .button,           // Optional: filter by role
    title: "Save",           // Optional: filter by title
    identifier: "save_btn"   // Optional: filter by identifier
)

// Specialized finders
let button = try await pilot.findButton(in: window, title: "OK")
let textField = try await pilot.findTextField(in: window, placeholder: "Enter text")

// Click discovered elements
let result = try await pilot.click(element: button)

// Type into text fields
try await pilot.type(text: "Hello World", into: textField)

// Get element values
let value = try await pilot.getValue(from: textField)

// Check element existence
let exists = try await pilot.elementExists(button)

// Get current input source
let currentSource = try await pilot.getCurrentInputSource()
print("Current: \(currentSource.displayName)")

// List available input sources
let sources = try await pilot.getAvailableInputSources()
for source in sources {
    print("\(source.displayName): \(source.identifier)")
}

// Switch input source and type
try await pilot.switchInputSource(to: .japanese)
try await pilot.type(text: "こんにちは", into: textField)

// Capture window screenshot
let image = try await pilot.capture(window: window)

// Convert to PNG data and save
if let pngData = ScreenCaptureUtility.convertToPNG(image) {
    let url = URL(fileURLWithPath: "/tmp/screenshot.png")
    try pngData.write(to: url)
}

import AppPilot

let pilot = AppPilot()

// Find TestApp
let testApp = try await pilot.findApplication(name: "TestApp")
let window = try await pilot.findWindow(app: testApp, title: "Mouse Click")

// Discover all clickable targets automatically
let buttons = try await pilot.findElements(in: window, role: .button)
print("Found \(buttons.count) clickable targets")

// Click each target using element-based automation
for button in buttons where button.isEnabled {
    print("Clicking: \(button.title ?? button.id)")
    try await pilot.click(element: button)
    
    // Verify via TestApp API
    let response = try await testAppAPI.getClickTargets()
    let clickedCount = response.filter { $0.clicked }.count
    print("Targets clicked: \(clickedCount)")
    
    try await pilot.wait(.time(seconds: 0.5))
}

let pilot = AppPilot()

// Find Weather app
let weatherApp = try await pilot.findApplication(bundleId: "com.apple.weather")
let window = try await pilot.findWindow(app: weatherApp, index: 0)

// Find and interact with search field
let searchField = try await pilot.findTextField(in: window)
try await pilot.click(element: searchField)
try await pilot.type(text: "Tokyo", into: searchField)

// Wait for and click search result
let tokyoResult = try await pilot.waitForElement(
    in: window,
    role: .button,
    title: "Tokyo",
    timeout: 5.0
)
try await pilot.click(element: tokyoResult)

let pilot = AppPilot()

// Find text editing app
let textEdit = try await pilot.findApplication(name: "TextEdit")
let window = try await pilot.findWindow(app: textEdit, index: 0)
let textArea = try await pilot.findTextField(in: window)

// Simple English input
try await pilot.input(text: "Hello World", into: textArea)

// Japanese composition input with automatic candidate handling
let result = try await pilot.input("konnichiwa", into: textArea, with: .japaneseRomaji)

// Handle IME candidates if user decision is needed
if result.needsUserDecision {
    if let candidates = result.compositionCandidates {
        print("Available candidates: \(candidates)")
        // Example: ["こんにちは", "こんにちわ", "今日は"]
        
        // Select the first candidate (こんにちは)
        let selection = try await pilot.selectCandidate(at: 0, for: textArea)
        
        // Commit the composition
        if !selection.isCompositionCompleted {
            try await pilot.commitComposition(for: textArea)
        }
    }
}

// Chinese input with Pinyin
let chineseResult = try await pilot.input("ni hao", into: textArea, with: .chinesePinyin)
// Handles: "ni hao" → "你好" with candidate selection if needed

// Korean input
let koreanResult = try await pilot.input("annyeong", into: textArea, with: .korean)
// Handles: "annyeong" → "안녕" with automatic composition

// Direct input (bypasses IME for final text)
try await pilot.input("こんにちは", into: textArea) // Direct hiragana input

let pilot = AppPilot()

// Setup
let app = try await pilot.findApplication(name: "TextEdit")
let window = try await pilot.findWindow(app: app, index: 0)
let textField = try await pilot.findTextField(in: window)

// Complex Japanese input workflow
let inputResult = try await pilot.input("arigatougozaimasu", into: textField, with: .japaneseRomaji)

// Check if the IME presents multiple conversion candidates
if case .candidateSelection(_, let candidates, let selectedIndex) = inputResult.compositionData?.state {
    print("Candidates available:")
    for (index, candidate) in candidates.enumerated() {
        let marker = index == selectedIndex ? "👉" : "  "
        print("\(marker) \(index): \(candidate)")
    }
    
    // Select different candidate if needed
    if selectedIndex != 0 {
        try await pilot.selectCandidate(at: 0, for: textField)
    }
    
    // Commit the final selection
    try await pilot.commitComposition(for: textField)
} else if case .committed(let finalText) = inputResult.compositionData?.state {
    print("Automatically committed: \(finalText)")
}

// Cancel composition if needed
if inputResult.needsUserDecision {
    // User decides to cancel
    try await pilot.cancelComposition(for: textField)
}

public enum PilotError: Error {
    case permissionDenied(String)
    case applicationNotFound(String)
    case windowNotFound(WindowHandle)
    case elementNotFound(role: ElementRole, title: String?)
    case elementNotAccessible(String)
    case multipleElementsFound(role: ElementRole, title: String?, count: Int)
    case timeout(TimeInterval)
    case osFailure(api: String, code: Int32)
}

do {
    let button = try await pilot.findButton(in: window, title: "Submit")
    try await pilot.click(element: button)
} catch PilotError.elementNotFound(let role, let title) {
    print("Button '\(title ?? "unknown")' not found")
    // Fallback to coordinate-based clicking
    try await pilot.click(window: window, at: Point(x: 200, y: 300))
} catch PilotError.permissionDenied(let message) {
    print("Permission required: \(message)")
}

// Old: Hardcoded coordinate clicking
try await pilot.click(window: window, at: Point(x: 534, y: 228))

// New: Smart element discovery and clicking
let button = try await pilot.findButton(in: window, title: "Submit")
try await pilot.click(element: button)

// Old: Focus app and type blindly
try await pilot.type(text: "Hello World")

// New: Find text field and type into it
let textField = try await pilot.findTextField(in: window)
try await pilot.type(text: "Hello World", into: textField)

// Old: No element discovery, manual coordinate calculation
let buttonCenter = Point(x: 200, y: 150)
try await pilot.click(window: window, at: buttonCenter)

// New: Automatic element discovery and interaction
let allButtons = try await pilot.findElements(in: window, role: .button)
for button in allButtons where button.isEnabled {
    try await pilot.click(element: button)  // Automatically uses element.centerPoint
}

// Old: Fixed time waits
try await Task.sleep(nanoseconds: 2_000_000_000)

// New: Semantic wait conditions
try await pilot.waitForElement(in: window, role: .button, title: "Continue", timeout: 10.0)
try await pilot.wait(.elementDisappear(window: window, role: .dialog, title: "Loading"))