import UIKit
import ARKit

class ViewController: UIViewController, ARSCNViewDelegate {
    
    @IBOutlet var sceneView: ARSCNView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Scene view delegate 설정
        sceneView.delegate = self
        
        // 디버그 옵션 활성화 (개발 중에 유용해)
        sceneView.showsStatistics = true
        
        // 새로운 scene 생성
        let scene = SCNScene()
        sceneView.scene = scene
    }
    
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        
        // AR 세션 설정
        let configuration = ARWorldTrackingConfiguration()
        
        // 평면 감지 활성화
        configuration.planeDetection = [.horizontal, .vertical]
        
        // 세션 실행
        sceneView.session.run(configuration)
    }
    
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        
        // 세션 일시정지
        sceneView.session.pause()
    }
}

// 3D 박스 추가하는 함수
func addBox() {
    // 박스 geometry 생성 (한 변이 0.1m인 정육면체)
    let box = SCNBox(width: 0.1, height: 0.1, length: 0.1, chamferRadius: 0)
    
    // 재질 설정 (빨간색)
    let material = SCNMaterial()
    material.diffuse.contents = UIColor.red
    box.materials = [material]
    
    // 노드 생성
    let boxNode = SCNNode(geometry: box)
    
    // 카메라 앞 0.3m 위치에 배치
    boxNode.position = SCNVector3(0, 0, -0.3)
    
    // Scene에 추가
    sceneView.scene.rootNode.addChildNode(boxNode)
}

// 평면 감지 delegate 메서드
func renderer(_ renderer: SCNSceneRenderer, didAdd node: SCNNode, for anchor: ARAnchor) {
    // 평면 anchor인지 확인
    guard let planeAnchor = anchor as? ARPlaneAnchor else { return }
    
    // 평면 시각화를 위한 geometry 생성
    let plane = SCNPlane(width: CGFloat(planeAnchor.extent.x), 
                        height: CGFloat(planeAnchor.extent.z))
    
    // 반투명 파란색 재질
    let material = SCNMaterial()
    material.diffuse.contents = UIColor.blue.withAlphaComponent(0.3)
    plane.materials = [material]
    
    // 평면 노드 생성
    let planeNode = SCNNode(geometry: plane)
    planeNode.position = SCNVector3(planeAnchor.center.x, 0, planeAnchor.center.z)
    
    // 평면을 수평으로 회전 (기본적으로 수직이라서)
    planeNode.eulerAngles.x = -.pi / 2
    
    // 감지된 평면에 노드 추가
    node.addChildNode(planeNode)
}

// 평면 업데이트 (크기가 변경될 때)
func renderer(_ renderer: SCNSceneRenderer, didUpdate node: SCNNode, for anchor: ARAnchor) {
    guard let planeAnchor = anchor as? ARPlaneAnchor,
          let planeNode = node.childNodes.first,
          let plane = planeNode.geometry as? SCNPlane else { return }
    
    // 평면 크기 업데이트
    plane.width = CGFloat(planeAnchor.extent.x)
    plane.height = CGFloat(planeAnchor.extent.z)
    
    // 위치 업데이트
    planeNode.position = SCNVector3(planeAnchor.center.x, 0, planeAnchor.center.z)
}

dependencies {
    // ARCore 라이브러리
    implementation 'com.google.ar:core:1.38.0'
    
    // Sceneform (3D 렌더링 라이브러리)
    implementation 'com.google.ar.sceneform.ux:sceneform-ux:1.17.1'
    
    // 기타 필요한 라이브러리들
    implementation 'androidx.appcompat:appcompat:1.6.1'
    implementation 'com.google.android.material:material:1.9.0'
}

<uses-permission android:name="android.permission.CAMERA" />

<!-- ARCore 필수 설정 -->
<uses-feature android:name="android.hardware.camera.ar" android:required="true" />

<application>
    <!-- ARCore 지원 명시 -->
    <meta-data
        android:name="com.google.ar.core"
        android:value="required" />
</application>

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import com.google.ar.core.*
import com.google.ar.sceneform.AnchorNode
import com.google.ar.sceneform.rendering.ModelRenderable
import com.google.ar.sceneform.ux.ArFragment
import com.google.ar.sceneform.ux.TransformableNode

class MainActivity : AppCompatActivity() {
    
    private lateinit var arFragment: ArFragment
    private var modelRenderable: ModelRenderable? = null
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        // AR Fragment 초기화
        arFragment = supportFragmentManager.findFragmentById(R.id.arFragment) 
            as ArFragment
        
        // 3D 모델 로드
        loadModel()
        
        // 평면 탭 리스너 설정
        arFragment.setOnTapArPlaneListener { hitResult, plane, motionEvent ->
            if (modelRenderable == null) return@setOnTapArPlaneListener
            
            // Anchor 생성 (탭한 위치에)
            val anchor = hitResult.createAnchor()
            val anchorNode = AnchorNode(anchor)
            anchorNode.setParent(arFragment.arSceneView.scene)
            
            // 3D 모델 노드 생성
            val modelNode = TransformableNode(arFragment.transformationSystem)
            modelNode.setParent(anchorNode)
            modelNode.renderable = modelRenderable
            modelNode.select()
        }
    }
    
    private fun loadModel() {
        // 3D 모델 로드 (예: .glb 파일)
        ModelRenderable.builder()
            .setSource(this, R.raw.model)
            .build()
            .thenAccept { renderable ->
                modelRenderable = renderable
            }
            .exceptionally { throwable ->
                // 에러 처리
                null
            }
    }
}

// Depth API 활성화
val config = Config(session)
config.depthMode = Config.DepthMode.AUTOMATIC

// 세션에 설정 적용
session.configure(config)

// Depth 이미지 가져오기
fun getDepthImage(frame: Frame): Image? {
    try {
        val depthImage = frame.acquireDepthImage()
        // Depth 데이터 처리
        return depthImage
    } catch (e: NotYetAvailableException) {
        // Depth 데이터가 아직 준비되지 않음
        return null
    }
}

// USDZ 모델 로드 (애니메이션 포함)
func loadAnimatedModel() {
    guard let modelURL = Bundle.main.url(forResource: "character", 
                                         withExtension: "usdz") else {
        return
    }
    
    // 모델 로드
    let modelEntity = try? Entity.load(contentsOf: modelURL)
    
    // Anchor 생성
    let anchor = AnchorEntity(plane: .horizontal)
    
    if let model = modelEntity {
        anchor.addChild(model)
        
        // 애니메이션 재생
        if let animation = model.availableAnimations.first {
            model.playAnimation(animation.repeat())
        }
    }
    
    // Scene에 추가
    arView.scene.addAnchor(anchor)
}

// 커스텀 애니메이션 만들기
func createCustomAnimation(node: SCNNode) {
    // 회전 애니메이션
    let rotation = CABasicAnimation(keyPath: "rotation")
    rotation.toValue = NSValue(scnVector4: SCNVector4(0, 1, 0, Float.pi * 2))
    rotation.duration = 3
    rotation.repeatCount = .infinity
    
    // 위아래 움직임
    let moveUp = CABasicAnimation(keyPath: "position.y")
    moveUp.byValue = 0.1
    moveUp.duration = 1
    moveUp.autoreverses = true
    moveUp.repeatCount = .infinity
    
    // 애니메이션 적용
    node.addAnimation(rotation, forKey: "rotation")
    node.addAnimation(moveUp, forKey: "moveUp")
}

// GLB 모델 로드 및 애니메이션 재생
private fun loadAnimatedModel() {
    ModelRenderable.builder()
        .setSource(this, Uri.parse("model.glb"))
        .setIsFilamentGltf(true)
        .build()
        .thenAccept { renderable ->
            modelRenderable = renderable
            
            // 애니메이션 데이터 가져오기
            val animationData = renderable.getAnimationData(0)
            
            // 애니메이터 생성
            val animator = ModelAnimator(animationData, renderable)
            animator.start()
            
            // 반복 재생
            animator.repeatCount = ModelAnimator.INFINITE
        }
}

// 커스텀 애니메이션 (ObjectAnimator 사용)
private fun animateNode(node: TransformableNode) {
    // 회전 애니메이션
    val rotationAnimator = ObjectAnimator.ofFloat(node, "localRotation", 0f, 360f)
    rotationAnimator.duration = 3000
    rotationAnimator.repeatCount = ObjectAnimator.INFINITE
    rotationAnimator.interpolator = LinearInterpolator()
    
    // 스케일 애니메이션
    val scaleAnimator = ObjectAnimator.ofFloat(node, "localScale", 1f, 1.2f, 1f)
    scaleAnimator.duration = 2000
    scaleAnimator.repeatCount = ObjectAnimator.INFINITE
    
    // 애니메이션 시작
    rotationAnimator.start()
    scaleAnimator.start()
}

// 화면 터치 감지
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
    guard let touch = touches.first else { return }
    let location = touch.location(in: sceneView)
    
    // Hit test 수행 (AR 평면과의 교차점 찾기)
    let hitTestResults = sceneView.hitTest(location, types: .existingPlaneUsingExtent)
    
    if let hitResult = hitTestResults.first {
        // 터치한 위치에 객체 배치
        addObjectAt(hitResult)
    }
    
    // 기존 객체 선택 (Scene의 노드와 교차 검사)
    let sceneHitResults = sceneView.hitTest(location, options: nil)
    if let nodeHit = sceneHitResults.first {
        handleNodeSelection(nodeHit.node)
    }
}

// 객체 배치
func addObjectAt(_ hitResult: ARHitTestResult) {
    let anchor = ARAnchor(transform: hitResult.worldTransform)
    sceneView.session.add(anchor: anchor)
    
    // 앵커에 3D 모델 추가
    let node = createModelNode()
    let anchorNode = SCNNode()
    anchorNode.addChildNode(node)
    
    // Scene에 추가
    sceneView.scene.rootNode.addChildNode(anchorNode)
}

// 제스처 인식기 추가
func setupGestureRecognizers() {
    // 핀치 제스처 (크기 조절)
    let pinchGesture = UIPinchGestureRecognizer(target: self, 
                                                action: #selector(handlePinch(_:)))
    sceneView.addGestureRecognizer(pinchGesture)
    
    // 회전 제스처
    let rotationGesture = UIRotationGestureRecognizer(target: self, 
                                                      action: #selector(handleRotation(_:)))
    sceneView.addGestureRecognizer(rotationGesture)
    
    // 팬 제스처 (이동)
    let panGesture = UIPanGestureRecognizer(target: self, 
                                           action: #selector(handlePan(_:)))
    sceneView.addGestureRecognizer(panGesture)
}

@objc func handlePinch(_ gesture: UIPinchGestureRecognizer) {
    guard let selectedNode = currentSelectedNode else { return }
    
    if gesture.state == .changed {
        let scale = Float(gesture.scale)
        selectedNode.scale = SCNVector3(scale, scale, scale)
    }
}

@objc func handleRotation(_ gesture: UIRotationGestureRecognizer) {
    guard let selectedNode = currentSelectedNode else { return }
    
    if gesture.state == .changed {
        selectedNode.eulerAngles.y -= Float(gesture.rotation)
        gesture.rotation = 0
    }
}

// TransformableNode 사용 (자동 제스처 지원)
private fun createTransformableNode(anchor: Anchor): TransformableNode {
    val anchorNode = AnchorNode(anchor)
    anchorNode.setParent(arFragment.arSceneView.scene)
    
    val transformableNode = TransformableNode(arFragment.transformationSystem)
    transformableNode.setParent(anchorNode)
    transformableNode.renderable = modelRenderable
    
    // 제스처 설정 커스터마이징
    transformableNode.scaleController.apply {
        minScale = 0.5f
        maxScale = 3.0f
    }
    
    transformableNode.rotationController.isEnabled = true
    transformableNode.translationController.isEnabled = true
    
    return transformableNode
}

// 커스텀 터치 이벤트 처리
arFragment.setOnTapArPlaneListener { hitResult, plane, motionEvent ->
    if (modelRenderable == null) return@setOnTapArPlaneListener
    
    // 앵커 생성
    val anchor = hitResult.createAnchor()
    val node = createTransformableNode(anchor)
    
    // 선택 이벤트 리스너
    node.setOnTapListener { hitTestResult, motionEvent ->
        // 객체가 탭되었을 때의 동작
        onObjectTapped(node)
    }
    
    // 선택 상태 변경 리스너
    arFragment.transformationSystem.setSelectionVisualizer(
        CustomSelectionVisualizer()
    )
}

// 더블 탭으로 객체 삭제
private fun setupDoubleTapGesture() {
    val gestureDetector = GestureDetector(this, 
        object : GestureDetector.SimpleOnGestureListener() {
            override fun onDoubleTap(e: MotionEvent): Boolean {
                val hitTestResult = arFragment.arSceneView.scene
                    .hitTest(e.x, e.y)
                
                if (hitTestResult != null) {
                    val node = hitTestResult.node
                    if (node is TransformableNode) {
                        // 노드 제거
                        node.setParent(null)
                        return true
                    }
                }
                return false
            }
        })
    
    arFragment.arSceneView.scene.addOnPeekTouchListener { hitTestResult, motionEvent ->
        gestureDetector.onTouchEvent(motionEvent)
    }
}

import MultipeerConnectivity

class CollaborativeARManager: NSObject {
    var session: ARSession!
    var multipeerSession: MultipeerSession!
    
    func setupCollaborativeSession() {
        // Multipeer 세션 초기화
        multipeerSession = MultipeerSession(
            serviceName: "ar-collab",
            receivedDataHandler: handleReceivedData
        )
        
        // AR 세션 설정
        let configuration = ARWorldTrackingConfiguration()
        configuration.isCollaborationEnabled = true
        configuration.planeDetection = [.horizontal, .vertical]
        
        session.run(configuration)
    }
    
    // 다른 기기로 데이터 전송
    func sendARData() {
        guard let frame = session.currentFrame else { return }
        
        // Collaboration data 생성
        if let collaborationData = frame.collaborationData {
            multipeerSession.sendToAllPeers(collaborationData)
        }
    }
    
    // 다른 기기로부터 데이터 수신
    func handleReceivedData(_ data: Data, from peer: MCPeerID) {
        if let collaborationData = try? NSKeyedUnarchiver
            .unarchivedObject(ofClass: ARSession.CollaborationData.self, 
                            from: data) {
            session.update(with: collaborationData)
        }
    }
    
    // 앵커 공유
    func shareAnchor(_ anchor: ARAnchor) {
        // 앵커를 다른 기기로 전송
        guard let data = try? NSKeyedArchiver.archivedData(
            withRootObject: anchor, 
            requiringSecureCoding: true
        ) else { return }
        
        multipeerSession.sendToAllPeers(data)
    }
}

// Cloud Anchors 설정
private fun setupCloudAnchors() {
    val config = Config(session)
    config.cloudAnchorMode = Config.CloudAnchorMode.ENABLED
    session?.configure(config)
}

// Cloud Anchor 호스팅 (생성)
private fun hostCloudAnchor(anchor: Anchor) {
    val cloudAnchor = session?.hostCloudAnchorWithTtl(
        anchor,
        /* ttlDays= */ 1  // 1일 동안 유효
    )
    
    // 호스팅 상태 모니터링
    cloudAnchor?.let { monitorCloudAnchorState(it) }
}

private fun monitorCloudAnchorState(anchor: Anchor) {
    when (anchor.cloudAnchorState) {
        Anchor.CloudAnchorState.SUCCESS -> {
            // 성공! Cloud Anchor ID 저장
            val cloudAnchorId = anchor.cloudAnchorId
            saveCloudAnchorId(cloudAnchorId)
            
            // 다른 사용자와 공유
            shareCloudAnchorId(cloudAnchorId)
        }
        Anchor.CloudAnchorState.ERROR_INTERNAL -> {
            // 에러 처리
            showError("Cloud Anchor 생성 실패")
        }
        else -> {
            // 진행 중...
        }
    }
}

// Cloud Anchor 해결 (불러오기)
private fun resolveCloudAnchor(cloudAnchorId: String) {
    val resolvedAnchor = session?.resolveCloudAnchor(cloudAnchorId)
    
    resolvedAnchor?.let { anchor ->
        when (anchor.cloudAnchorState) {
            Anchor.CloudAnchorState.SUCCESS -> {
                // 성공! 앵커 위치에 객체 배치
                placeObjectAt(anchor)
            }
            Anchor.CloudAnchorState.ERROR_NOT_AUTHORIZED -> {
                showError("권한 없음")
            }
            else -> {
                // 해결 중...
            }
        }
    }
}

// Firebase를 사용한 Cloud Anchor ID 공유
private fun shareCloudAnchorId(cloudAnchorId: String) {
    val database = FirebaseDatabase.getInstance().reference
    val roomId = getCurrentRoomId()
    
    database.child("rooms").child(roomId).child("anchors")
        .push()
        .setValue(cloudAnchorId)
        .addOnSuccessListener {
            Log.d("CloudAnchor", "ID 공유 성공: $cloudAnchorId")
        }
}

// 다른 사용자의 Cloud Anchor 가져오기
private fun listenForSharedAnchors() {
    val database = FirebaseDatabase.getInstance().reference
    val roomId = getCurrentRoomId()
    
    database.child("rooms").child(roomId).child("anchors")
        .addChildEventListener(object : ChildEventListener {
            override fun onChildAdded(snapshot: DataSnapshot, previousChildName: String?) {
                val cloudAnchorId = snapshot.getValue(String::class.java)
                cloudAnchorId?.let { resolveCloudAnchor(it) }
            }
            
            // 다른 메서드들...
        })
}

import UIKit
import ARKit
import RealityKit

class FurniturePlacementViewController: UIViewController {
    
    @IBOutlet var arView: ARView!
    @IBOutlet var catalogCollectionView: UICollectionView!
    @IBOutlet var measurementLabel: UILabel!
    
    var furnitureModels: [FurnitureModel] = []
    var selectedFurniture: FurnitureModel?
    var placedFurniture: [ModelEntity] = []
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupAR()
        loadFurnitureCatalog()
        setupGestures()
    }
    
    func setupAR() {
        // AR 세션 설정
        let configuration = ARWorldTrackingConfiguration()
        configuration.planeDetection = [.horizontal, .vertical]
        configuration.environmentTexturing = .automatic
        
        // 사람 occlusion (LiDAR 기기에서)
        if ARWorldTrackingConfiguration.supportsFrameSemantics(.personSegmentationWithDepth) {
            configuration.frameSemantics.insert(.personSegmentationWithDepth)
        }
        
        arView.session.run(configuration)
        
        // 평면 시각화
        arView.debugOptions = [.showFeaturePoints]
    }
    
    func loadFurnitureCatalog() {
        // 가구 모델 목록 로드
        furnitureModels = [
            FurnitureModel(name: "소파", modelName: "sofa", category: .livingRoom),
            FurnitureModel(name: "테이블", modelName: "table", category: .diningRoom),
            FurnitureModel(name: "침대", modelName: "bed", category: .bedroom),
            // ... 더 많은 가구들
        ]
        
        catalogCollectionView.reloadData()
    }
    
    // 가구 배치
    func placeFurniture(at location: CGPoint) {
        guard let selectedFurniture = selectedFurniture else { return }
        
        // Hit test로 평면 찾기
        let results = arView.raycast(from: location, 
                                     allowing: .estimatedPlane, 
                                     alignment: .horizontal)
        
        guard let firstResult = results.first else { return }
        
        // 앵커 생성
        let anchor = AnchorEntity(world: firstResult.worldTransform)
        
        // 모델 로드 및 추가
        loadModel(selectedFurniture.modelName) { modelEntity in
            // 크기 조정 (실제 가구 크기로)
            let scale = selectedFurniture.realWorldScale
            modelEntity.scale = [scale, scale, scale]
            
            anchor.addChild(modelEntity)
            self.arView.scene.addAnchor(anchor)
            self.placedFurniture.append(modelEntity)
            
            // 측정 정보 표시
            self.showMeasurements(for: modelEntity)
        }
    }
    
    func loadModel(_ name: String, completion: @escaping (ModelEntity) -> Void) {
        // USDZ 모델 비동기 로드
        ModelEntity.loadModelAsync(named: name)
            .sink(receiveCompletion: { loadCompletion in
                if case .failure(let error) = loadCompletion {
                    print("모델 로드 실패: \(error)")
                }
            }, receiveValue: { modelEntity in
                completion(modelEntity)
            })
            .store(in: &cancellables)
    }
    
    // 측정 도구
    func showMeasurements(for entity: ModelEntity) {
        let bounds = entity.visualBounds(relativeTo: nil)
        let width = bounds.extents.x * 100  // 미터를 센티미터로
        let height = bounds.extents.y * 100
        let depth = bounds.extents.z * 100
        
        measurementLabel.text = String(format: "크기: %.0f x %.0f x %.0f cm", 
                                       width, depth, height)
    }
    
    // 스크린샷 캡처
    @IBAction func captureScreenshot() {
        arView.snapshot(saveToHDR: false) { image in
            guard let image = image else { return }
            
            // 사진 앨범에 저장
            UIImageWriteToSavedPhotosAlbum(image, self, 
                #selector(self.image(_:didFinishSavingWithError:contextInfo:)), 
                nil)
            
            // 공유 시트 표시
            self.shareImage(image)
        }
    }
    
    func shareImage(_ image: UIImage) {
        let activityVC = UIActivityViewController(
            activityItems: [image, "재능넷에서 만든 나만의 AR 인테리어!"], 
            applicationActivities: nil
        )
        present(activityVC, animated: true)
    }
    
    // 배치 저장
    func savePlacement() {
        var savedData: [[String: Any]] = []
        
        for entity in placedFurniture {
            let data: [String: Any] = [
                "modelName": entity.name,
                "position": [entity.position.x, entity.position.y, entity.position.z],
                "rotation": [entity.orientation.angle],
                "scale": [entity.scale.x, entity.scale.y, entity.scale.z]
            ]
            savedData.append(data)
        }
        
        // UserDefaults나 Core Data에 저장
        UserDefaults.standard.set(savedData, forKey: "savedFurniturePlacement")
    }
    
    // 저장된 배치 불러오기
    func loadSavedPlacement() {
        guard let savedData = UserDefaults.standard
            .array(forKey: "savedFurniturePlacement") as? [[String: Any]] else {
            return
        }
        
        for data in savedData {
            // 저장된 데이터로 가구 복원
            // ... 구현
        }
    }
}

// 가구 모델 데이터 구조
struct FurnitureModel {
    let name: String
    let modelName: String
    let category: FurnitureCategory
    let realWorldScale: Float
    let price: Int?
    
    enum FurnitureCategory {
        case livingRoom, diningRoom, bedroom, office
    }
}

class FurniturePlacementActivity : AppCompatActivity() {
    
    private lateinit var arFragment: ArFragment
    private lateinit var catalogRecyclerView: RecyclerView
    private var furnitureModels = mutableListOf<FurnitureModel>()
    private var selectedFurniture: FurnitureModel? = null
    private val placedNodes = mutableListOf<AnchorNode>()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_furniture_placement)
        
        setupAR()
        loadFurnitureCatalog()
        setupUI()
    }
    
    private fun setupAR() {
        arFragment = supportFragmentManager
            .findFragmentById(R.id.arFragment) as ArFragment
        
        // 평면 탭 리스너
        arFragment.setOnTapArPlaneListener { hitResult, plane, motionEvent ->
            selectedFurniture?.let { furniture ->
                placeFurniture(hitResult, furniture)
            }
        }
        
        // AR 세션 설정
        arFragment.arSceneView.scene.addOnUpdateListener {
            updateMeasurements()
        }
    }
    
    private fun loadFurnitureCatalog() {
        furnitureModels = mutableListOf(
            FurnitureModel("소파", "sofa.glb", FurnitureCategory.LIVING_ROOM, 2.0f),
            FurnitureModel("테이블", "table.glb", FurnitureCategory.DINING_ROOM, 1.5f),
            FurnitureModel("침대", "bed.glb", FurnitureCategory.BEDROOM, 2.0f)
        )
        
        // RecyclerView 설정
        catalogRecyclerView.adapter = FurnitureCatalogAdapter(furnitureModels) { furniture ->
            selectedFurniture = furniture
            Toast.makeText(this, "${furniture.name} 선택됨", Toast.LENGTH_SHORT).show()
        }
    }
    
    private fun placeFurniture(hitResult: HitResult, furniture: FurnitureModel) {
        // 모델 로드
        ModelRenderable.builder()
            .setSource(this, Uri.parse(furniture.modelPath))
            .setIsFilamentGltf(true)
            .build()
            .thenAccept { renderable ->
                addModelToScene(hitResult, renderable, furniture)
            }
            .exceptionally { throwable ->
                Toast.makeText(this, "모델 로드 실패: ${throwable.message}", 
                              Toast.LENGTH_SHORT).show()
                null
            }
    }
    
    private fun addModelToScene(
        hitResult: HitResult, 
        renderable: ModelRenderable,
        furniture: FurnitureModel
    ) {
        // 앵커 생성
        val anchor = hitResult.createAnchor()
        val anchorNode = AnchorNode(anchor)
        anchorNode.setParent(arFragment.arSceneView.scene)
        
        // Transformable 노드 생성
        val furnitureNode = TransformableNode(arFragment.transformationSystem)
        furnitureNode.setParent(anchorNode)
        furnitureNode.renderable = renderable
        
        // 실제 크기로 스케일 조정
        furnitureNode.localScale = Vector3(
            furniture.scale, 
            furniture.scale, 
            furniture.scale
        )
        
        // 제스처 설정
        furnitureNode.scaleController.apply {
            minScale = 0.5f
            maxScale = 2.0f
        }
        
        // 노드 선택
        furnitureNode.select()
        
        // 저장
        placedNodes.add(anchorNode)
        
        // 측정 정보 표시
        showMeasurements(furnitureNode, furniture)
        
        // 삭제 버튼 추가
        addDeleteButton(furnitureNode)
    }
    
    private fun showMeasurements(node: TransformableNode, furniture: FurnitureModel) {
        val renderable = node.renderable ?: return
        val size = renderable.collisionShape?.size ?: return
        
        val width = size.x * node.localScale.x * 100  // cm로 변환
        val height = size.y * node.localScale.y * 100
        val depth = size.z * node.localScale.z * 100
        
        measurementTextView.text = String.format(
            "%s\n크기: %.0f x %.0f x %.0f cm",
            furniture.name, width, depth, height
        )
    }
    
    private fun addDeleteButton(node: TransformableNode) {
        // ViewRenderable로 삭제 버튼 생성
        ViewRenderable.builder()
            .setView(this, R.layout.delete_button)
            .build()
            .thenAccept { renderable ->
                val buttonNode = Node()
                buttonNode.setParent(node)
                buttonNode.renderable = renderable
                buttonNode.localPosition = Vector3(0f, 0.5f, 0f)
                
                // 버튼 클릭 리스너
                renderable.view.setOnClickListener {
                    removeNode(node)
                }
            }
    }
    
    private fun removeNode(node: TransformableNode) {
        node.setParent(null)
        placedNodes.remove(node.parent as? AnchorNode)
        Toast.makeText(this, "가구 제거됨", Toast.LENGTH_SHORT).show()
    }
    
    // 스크린샷 캡처
    private fun captureScreenshot() {
        val view = arFragment.arSceneView
        
        // Pixel Copy API 사용
        val bitmap = Bitmap.createBitmap(view.width, view.height, Bitmap.Config.ARGB_8888)
        
        PixelCopy.request(view, bitmap, { copyResult ->
            if (copyResult == PixelCopy.SUCCESS) {
                saveBitmap(bitmap)
                shareImage(bitmap)
            }
        }, Handler(Looper.getMainLooper()))
    }
    
    private fun saveBitmap(bitmap: Bitmap) {
        val filename = "AR_Furniture_${System.currentTimeMillis()}.jpg"
        val contentValues = ContentValues().apply {
            put(MediaStore.Images.Media.DISPLAY_NAME, filename)
            put(MediaStore.Images.Media.MIME_TYPE, "image/jpeg")
            put(MediaStore.Images.Media.RELATIVE_PATH, Environment.DIRECTORY_PICTURES)
        }
        
        val uri = contentResolver.insert(
            MediaStore.Images.Media.EXTERNAL_CONTENT_URI, 
            contentValues
        )
        
        uri?.let {
            contentResolver.openOutputStream(it)?.use { outputStream ->
                bitmap.compress(Bitmap.CompressFormat.JPEG, 95, outputStream)
            }
            Toast.makeText(this, "사진이 저장되었습니다", Toast.LENGTH_SHORT).show()
        }
    }
    
    private fun shareImage(bitmap: Bitmap) {
        // 임시 파일로 저장
        val cachePath = File(cacheDir, "images")
        cachePath.mkdirs()
        val file = File(cachePath, "shared_image.jpg")
        
        FileOutputStream(file).use { outputStream ->
            bitmap.compress(Bitmap.CompressFormat.JPEG, 95, outputStream)
        }
        
        // URI 생성
        val imageUri = FileProvider.getUriForFile(
            this,
            "${packageName}.fileprovider",
            file
        )
        
        // 공유 인텐트
        val shareIntent = Intent(Intent.ACTION_SEND).apply {
            type = "image/jpeg"
            putExtra(Intent.EXTRA_STREAM, imageUri)
            putExtra(Intent.EXTRA_TEXT, "재능넷에서 만든 나만의 AR 인테리어!")
            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
        }
        
        startActivity(Intent.createChooser(shareIntent, "공유하기"))
    }
    
    // 배치 저장 (JSON)
    private fun savePlacement() {
        val placementData = placedNodes.map { anchorNode ->
            val node = anchorNode.children.firstOrNull() as? TransformableNode
            node?.let {
                PlacementData(
                    modelName = it.name ?: "",
                    position = it.worldPosition.toList(),
                    rotation = it.worldRotation.toList(),
                    scale = it.localScale.toList()
                )
            }
        }.filterNotNull()
        
        val json = Gson().toJson(placementData)
        
        // SharedPreferences에 저장
        getSharedPreferences("ARFurniture", MODE_PRIVATE)
            .edit()
            .putString("placement", json)
            .apply()
        
        Toast.makeText(this, "배치가 저장되었습니다", Toast.LENGTH_SHORT).show()
    }
    
    // Cloud Anchor로 공유
    private fun shareWithCloudAnchor(anchorNode: AnchorNode) {
        val anchor = anchorNode.anchor ?: return
        val session = arFragment.arSceneView.session ?: return
        
        // Cloud Anchor 호스팅
        val cloudAnchor = session.hostCloudAnchorWithTtl(anchor, 1)
        
        // 상태 모니터링
        arFragment.arSceneView.scene.addOnUpdateListener {
            if (cloudAnchor.cloudAnchorState == Anchor.CloudAnchorState.SUCCESS) {
                val cloudAnchorId = cloudAnchor.cloudAnchorId
                
                // Firebase에 저장
                saveCloudAnchorToFirebase(cloudAnchorId)
                
                Toast.makeText(this, "공유 링크가 생성되었습니다", 
                              Toast.LENGTH_SHORT).show()
            }
        }
    }
    
    private fun saveCloudAnchorToFirebase(cloudAnchorId: String) {
        val database = FirebaseDatabase.getInstance().reference
        val roomId = generateRoomId()
        
        database.child("rooms").child(roomId).child("cloudAnchorId")
            .setValue(cloudAnchorId)
            .addOnSuccessListener {
                // 룸 ID를 다른 사용자와 공유
                shareRoomId(roomId)
            }
    }
}

// 데이터 클래스
data class FurnitureModel(
    val name: String,
    val modelPath: String,
    val category: FurnitureCategory,
    val scale: Float,
    val price: Int? = null
)

data class PlacementData(
    val modelName: String,
    val position: List<Float>,
    val rotation: List<Float>,
    val scale: List<Float>
)

enum class FurnitureCategory {
    LIVING_ROOM, DINING_ROOM, BEDROOM, OFFICE
}

// LOD (Level of Detail) 구현 예제 - ARKit
func setupLOD(for node: SCNNode, camera: SCNNode) {
    let distance = node.position.distance(to: camera.position)
    
    switch distance {
    case 0..<2:
        // 가까울 때 - 고품질 모델
        node.geometry = highDetailGeometry
    case 2..<5:
        // 중간 거리 - 중간 품질
        node.geometry = mediumDetailGeometry
    default:
        // 멀 때 - 저품질 모델
        node.geometry = lowDetailGeometry
    }
}

// 텍스처 압축 설정
func optimizeTexture(_ material: SCNMaterial) {
    if let texture = material.diffuse.contents as? UIImage {
        // 크기 조정
        let resizedImage = texture.resized(to: CGSize(width: 1024, height: 1024))
        
        // 압축 적용
        material.diffuse.contents = resizedImage
        material.diffuse.wrapS = .repeat
        material.diffuse.wrapT = .repeat
        material.diffuse.mipFilter = .linear
    }
}

// ARKit 렌더링 최적화
func optimizeRendering() {
    // 안티앨리어싱 설정
    sceneView.antialiasingMode = .multisampling2X  // 4X는 너무 무거울 수 있어
    
    // 그림자 최적화
    sceneView.automaticallyUpdatesLighting = false  // 수동으로 조명 업데이트
    
    // 불필요한 렌더링 옵션 끄기
    sceneView.showsStatistics = false  // 릴리즈 빌드에서는 끄기
    sceneView.debugOptions = []
    
    // 프레임 레이트 제한 (필요한 경우)
    sceneView.preferredFramesPerSecond = 60
}

// ARCore 렌더링 최적화
private fun optimizeRendering() {
    val config = arFragment.arSceneView.session?.config
    
    // Depth mode 조정 (필요한 경우에만 사용)
    config?.depthMode = Config.DepthMode.DISABLED
    
    // 조명 추정 레벨 조정
    config?.lightEstimationMode = Config.LightEstimationMode.AMBIENT_INTENSITY
    
    // 업데이트 모드 설정
    config?.updateMode = Config.UpdateMode.LATEST_CAMERA_IMAGE
    
    arFragment.arSceneView.session?.configure(config)
}

// 오클루전 최적화
fun setupOcclusion() {
    // 사람 세그멘테이션은 성능 영향이 크므로 필요할 때만
    if needsPersonOcclusion && ARWorldTrackingConfiguration
        .supportsFrameSemantics(.personSegmentationWithDepth) {
        configuration.frameSemantics.insert(.personSegmentationWithDepth)
    }
}

// 메모리 관리 - 사용하지 않는 모델 해제
class ModelCache {
    private var cache: [String: ModelEntity] = [:]
    private let maxCacheSize = 10
    
    func getModel(named name: String) -> ModelEntity? {
        // 캐시에서 확인
        if let cached = cache[name] {
            return cached
        }
        
        // 캐시 크기 체크
        if cache.count >= maxCacheSize {
            // 가장 오래된 항목 제거 (LRU)
            let oldestKey = cache.keys.first!
            cache.removeValue(forKey: oldestKey)
        }
        
        // 새로 로드
        let model = loadModel(named: name)
        cache[name] = model
        return model
    }
    
    func clearCache() {
        cache.removeAll()
    }
}

// 메모리 경고 처리
override func didReceiveMemoryWarning() {
    super.didReceiveMemoryWarning()
    
    // 캐시 정리
    modelCache.clearCache()
    
    // 보이지 않는 노드 제거
    removeOffscreenNodes()
    
    // 텍스처 압축
    compressTextures()
}

// Android - 메모리 관리
override fun onTrimMemory(level: Int) {
    super.onTrimMemory(level)
    
    when (level) {
        ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW -> {
            // 메모리가 부족해지기 시작
            clearUnusedResources()
        }
        ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL -> {
            // 메모리가 심각하게 부족
            clearAllCaches()
            System.gc()
        }
    }
}

private fun clearUnusedResources() {
    // 화면에 보이지 않는 노드 제거
    placedNodes.removeAll { node ->
        !isNodeVisible(node)
    }
    
    // 텍스처 캐시 정리
    textureCache.clear()
}

// 배터리 최적화 설정
func optimizeForBattery() {
    // 프레임 레이트 낮추기
    sceneView.preferredFramesPerSecond = 30
    
    // 평면 감지 중단 (충분히 찾은 후)
    if detectedPlanesCount >= 3 {
        let configuration = ARWorldTrackingConfiguration()
        configuration.planeDetection = []  // 평면 감지 끄기
        sceneView.session.run(configuration)
    }
    
    // 조명 추정 단순화
    configuration.lightEstimationMode = .ambientIntensity  // HDR 대신
}

// 백그라운드 처리
func applicationWillResignActive(_ application: UIApplication) {
    // AR 세션 일시정지
    sceneView.session.pause()
}

func applicationDidBecomeActive(_ application: UIApplication) {
    // AR 세션 재개
    let configuration = ARWorldTrackingConfiguration()
    sceneView.session.run(configuration, options: [.resetTracking, .removeExistingAnchors])
}

// ARKit 디버그 옵션
func enableDebugOptions() {
    // Feature points 표시
    sceneView.debugOptions.insert(.showFeaturePoints)
    
    // 월드 원점 표시
    sceneView.debugOptions.insert(.showWorldOrigin)
    
    // 통계 정보 표시
    sceneView.showsStatistics = true
    
    // 물리 바운딩 박스 표시
    sceneView.debugOptions.insert(.showPhysicsShapes)
    
    // 와이어프레임 표시
    sceneView.debugOptions.insert(.renderAsWireframe)
}

// 트래킹 상태 모니터링
func session(_ session: ARSession, cameraDidChangeTrackingState camera: ARCamera) {
    var status = "트래킹 상태: "
    
    switch camera.trackingState {
    case .normal:
        status += "정상 ✅"
    case .notAvailable:
        status += "사용 불가 ❌"
    case .limited(let reason):
        switch reason {
        case .excessiveMotion:
            status += "과도한 움직임 ⚠️"
        case .insufficientFeatures:
            status += "특징점 부족 ⚠️"
        case .initializing:
            status += "초기화 중 ⏳"
        case .relocalizing:
            status += "재위치 파악 중 🔄"
        @unknown default:
            status += "알 수 없음"
        }
    }
    
    print(status)
    statusLabel.text = status
}

// ARCore 디버그 정보
private fun showDebugInfo(frame: Frame) {
    val trackingState = frame.camera.trackingState
    val trackingFailureReason = frame.camera.trackingFailureReason
    
    val debugInfo = buildString {
        appendLine("트래킹 상태: ${trackingState.name}")
        
        if (trackingState == TrackingState.PAUSED) {
            appendLine("실패 이유: ${trackingFailureReason?.name}")
        }
        
        appendLine("감지된 평면: ${frame.getUpdatedTrackables(Plane::class.java).size}")
        appendLine("Feature points: ${frame.acquirePointCloud().points.remaining() / 4}")
        
        // 조명 추정
        val lightEstimate = frame.lightEstimate
        appendLine("조명 강도: ${lightEstimate.pixelIntensity}")
    }
    
    debugTextView.text = debugInfo
}