dependencies: [
    .package(url: "https://git@github.com:vincentjoy/WiPeerKit.git", from: "1.0.1")
]

import WiPeerKit

// Initialize with secure defaults
let peerKit = WiPeerKit()
let connectionManager = try SecureConnectionManager(authMethod: .pin("123456"))

// Set up handlers
peerKit.onDataReceived = { data in
    if let message = String(data: data, encoding: .utf8) {
        print("Received: \(message)")
    }
}

connectionManager.onConnectionRequest = { device in
    // Show UI for user approval
    print("Connection from: \(device.name)")
    print("Fingerprint: \(device.fingerprint)")
    return true // or false to reject
}

// Start advertising
peerKit.startAdvertising(serviceName: "My Device")

// Or browse for peers
peerKit.startBrowsing()

// 1. Discover peers
peerKit.$discoveredPeers
    .sink { peers in
        for peer in peers {
            print("Found: \(peer.name)")
        }
    }
    .store(in: &cancellables)

// 2. Connect with authentication
if let peer = peerKit.discoveredPeers.first {
    do {
        // This will trigger PIN verification
        try await peerKit.secureConnectWithAuth(
            to: peer,
            using: connectionManager
        )
        print("Secure connection established!")
    } catch {
        print("Connection failed: \(error)")
    }
}

// 3. Send encrypted messages
try await peerKit.send(message: "Hello, secure world!")

// Initialize with PIN
let connectionManager = try SecureConnectionManager(
    authMethod: .pin("425817")
)

// The connecting device must enter this PIN
connectionManager.onPinRequested = {
    // Show PIN entry UI
    return enteredPin
}

// Generate QR code for pairing
let qrData = try connectionManager.generateQRCode()
let qrImage = QRCodeGenerator.generate(from: qrData)

// Scan QR code on other device
let connectionManager = try SecureConnectionManager(
    authMethod: .qrCode(scannedData)
)

let connectionManager = try SecureConnectionManager(
    authMethod: .manualApproval
)

connectionManager.onConnectionRequest = { device in
    // Show approval dialog
    let alert = UIAlertController(
        title: "Connection Request",
        message: "\(device.name) wants to connect\nFingerprint: \(device.fingerprint)",
        preferredStyle: .alert
    )
    // ... handle user response
}

// First connection uses PIN
// Then save as trusted
if userApprovesDevice {
    try connectionManager.addTrustedDevice(device)
}

// Future connections are automatic
let connectionManager = try SecureConnectionManager(
    authMethod: .trustedDevices(savedDevices)
)

// Use app-specific service type for isolation
let customServiceType = "_myapp-v1._tcp"
peerKit.startAdvertising(
    serviceName: "Device Name",
    serviceType: customServiceType
)

let options = WiPeerKit.ConnectionOptions(
    requireEncryption: true,
    handshakeTimeout: 15.0,
    maxMessageSize: 1_048_576 // 1MB
)

try await peerKit.secureConnect(to: peer, options: options)

// Send structured data
struct GameState: Codable {
    let players: [Player]
    let score: Int
}

let gameState = GameState(...)
let data = try JSONEncoder().encode(gameState)
try await peerKit.send(data: data)

// Send file in chunks
let fileURL = URL(fileURLWithPath: "large-file.zip")
let fileHandle = try FileHandle(forReadingFrom: fileURL)

let chunkSize = 65536 // 64KB chunks
while let chunk = fileHandle.readData(ofLength: chunkSize), !chunk.isEmpty {
    try await peerKit.send(data: chunk)
}

// Implement custom authentication
class BiometricAuthenticationMethod: AuthenticationMethod {
    func authenticate(device: DeviceIdentity) async throws -> Bool {
        let context = LAContext()
        
        return try await withCheckedThrowingContinuation { continuation in
            context.evaluatePolicy(
                .deviceOwnerAuthenticationWithBiometrics,
                localizedReason: "Authenticate connection from \(device.name)"
            ) { success, error in
                continuation.resume(returning: success)
            }
        }
    }
}

actor ServiceDiscoveryActor    // Manages mDNS operations
actor TCPTransportActor       // Handles socket communication  
actor EncryptionActor         // Cryptographic operations
actor SecureConnectionManager // Authentication & authorization

@MainActor
public final class WiPeerKit {
    // Connection state
    @Published public private(set) var connectionState: ConnectionState
    @Published public private(set) var discoveredPeers: [DiscoveredPeer]
    
    // Callbacks
    public var onDataReceived: (@Sendable (Data) -> Void)?
    
    // Discovery
    public func startAdvertising(serviceName: String? = nil)
    public func stopAdvertising()
    public func startBrowsing()
    public func stopBrowsing()
    
    // Connection
    public func connect(to peer: DiscoveredPeer) async throws
    public func secureConnect(to peer: DiscoveredPeer, options: ConnectionOptions) async throws
    public func secureConnectWithAuth(to peer: DiscoveredPeer, using: SecureConnectionManager) async throws
    public func disconnect()
    
    // Communication
    public func send(data: Data) async throws
    public func send(message: String) async throws
}

actor SecureConnectionManager {
    // Authentication methods
    enum AuthenticationMethod {
        case pin(String)
        case qrCode(Data)
        case manualApproval
        case trustedDevices([DeviceIdentity])
    }
    
    // Callbacks
    var onConnectionRequest: (@Sendable (DeviceIdentity) async -> Bool)?
    var onPinRequested: (@Sendable () async -> String?)?
    
    // Trust management
    func addTrustedDevice(_ device: DeviceIdentity) async
    func removeTrustedDevice(_ device: DeviceIdentity) async
    func getTrustedDevices() async -> [DeviceIdentity]
}

// Discovered peer information
public struct DiscoveredPeer: Sendable {
    public let id: String
    public let name: String
    public let host: String?
    public let port: Int?
}

// Connection states
public enum ConnectionState: Sendable {
    case disconnected
    case connecting
    case connected
    case failed(Error)
}

// Device identity
public struct DeviceIdentity: Sendable {
    public let id: UUID
    public let name: String
    public let fingerprint: String
    public let modelIdentifier: String
}

@MainActor
final class MyWiPeerKitTests: XCTestCase {
    func testSecureConnection() async throws {
        // Given
        let alice = WiPeerKit()
        let bob = WiPeerKit()
        
        let aliceManager = try SecureConnectionManager(authMethod: .pin("123456"))
        let bobManager = try SecureConnectionManager(authMethod: .pin("123456"))
        
        // When
        alice.startAdvertising()
        bob.startBrowsing()
        
        // Allow discovery
        try await Task.sleep(nanoseconds: 1_000_000_000)
        
        // Then
        XCTAssertFalse(bob.discoveredPeers.isEmpty)
        
        // Connect securely
        let peer = bob.discoveredPeers.first!
        try await bob.secureConnectWithAuth(to: peer, using: bobManager)
        
        XCTAssertEqual(bob.connectionState, .connected)
    }
}

// Enable verbose logging
WiPeerKit.enableDebugLogging = true

// Custom log handler
WiPeerKit.logHandler = { level, message in
    print("[\(level)] \(message)")
}

// Get connection statistics
let stats = await peerKit.getConnectionStats()
print("Bytes sent: \(stats.bytesSent)")
print("Bytes received: \(stats.bytesReceived)")
print("Round trip time: \(stats.roundTripTime)ms")