import DicyaninMultiPeer
import RealityKit

// Create a manager instance
let manager = MultiDeviceManager(displayName: "YourAppName")

// Set up your RealityView
RealityView { content in
    // Create a sync root entity
    let syncRoot = Entity()
    syncRoot.name = "SyncRoot"
    syncRoot.components.set(SyncComponent(id: "SyncRoot"))
    
    // Add your content
    content.add(syncRoot)
    
    // Start observing
    manager.startObserving(rootEntity: syncRoot)
    
    // Set up entity observation
    if manager.entityObservation == nil {
        manager.entityObservation = EntityObservation(
            rootEntity: syncRoot,
            onDataReceived: { data in
                manager.entityObservation?.handleReceivedData(data)
            }
        )
    }
}

// Create an entity with sync components
let entity = Entity()
entity.name = "MyEntity"

// Add sync component
let syncId = "Entity_\(UUID().uuidString)"
entity.components.set(SyncComponent(id: syncId))

// Add model sync component if needed
if let modelData = try? Data(contentsOf: modelURL) {
    entity.components.set(SyncModelComponent(modelData: modelData))
}

// Add to your scene
rootEntity.addChild(entity)

// Broadcast updates
if let entityObservation = manager.entityObservation {
    let transform = SyncTransform(from: entity.transform)
    entityObservation.broadcastTransform(for: entity, transform: transform)
}

// Create an entity with a 3D model
let entity = Entity()

// Configure for sync with a model
if let modelURL = Bundle.main.url(forResource: "MyModel", withExtension: "usdz") {
    entity.configureModelForSync(modelURL: modelURL, manager: manager, rootEntity: rootEntity)
}

// For subsequent transform updates, use the helper method
entity.broadcastTransformUpdate(manager: manager)

struct ContentView: View {
    @StateObject private var manager = MultiDeviceManager(displayName: "MyApp")
    
    var body: some View {
        RealityView { content in
            // Create root entity for synchronization
            let rootEntity = Entity()
            rootEntity.name = "SyncRoot"
            content.add(rootEntity)
            
            // Start observing the root entity
            manager.startObserving(rootEntity: rootEntity)
            
            // Create and configure a draggable entity
            if let modelURL = Bundle.main.url(forResource: "MyModel", withExtension: "usdz") {
                let entity = Entity()
                entity.configureModelForSync(modelURL: modelURL, manager: manager, rootEntity: rootEntity)
            }
        } update: { content in
            // Update content if needed
        }
        .gesture(
            DragGesture()
                .targetedToAnyEntity()
                .onChanged { value in
                    if let entity = value.entity {
                        // Update entity position
                        entity.position = value.translation
                        
                        // Broadcast the update to other devices
                        entity.broadcastTransformUpdate(manager: manager)
                    }
                }
        )
        .overlay(alignment: .bottom) {
            MultiDeviceConnectionView(displayName: manager.displayName)
                .background(.ultraThinMaterial)
        }
    }
}

// Add the connection view to your SwiftUI view
MultiDeviceConnectionView(displayName: "YourAppName")
    .background(.ultraThinMaterial)

// Monitor connection state
.onChange(of: manager.isConnected) { newValue in
    print("Connection state: \(newValue)")
}
.onChange(of: manager.connectedPeers) { newPeers in
    print("Connected peers: \(newPeers.count)")
}

class MultiDeviceManager {
    var isConnected: Bool
    var connectedPeers: [MCPeerID]
    var entityObservation: EntityObservation?
    
    func startObserving(rootEntity: Entity)
    func stopObserving()
}

class EntityObservation {
    func broadcastTransform(for entity: Entity, transform: SyncTransform)
    func handleReceivedData(_ data: Data)
}

struct SyncComponent: Component {
    var id: String
    var timestamp: TimeInterval
    var sequenceNumber: Int
}

struct SyncModelComponent: Component {
    var modelURL: URL?
    var modelData: Data?
}