🔗 MultipeerConnectivity

import MultipeerConnectivity
import SwiftUI

@Observable
class MultipeerManager: NSObject {
    private let serviceType = "hig-lab-chat" // 15자 이하, 소문자/숫자/하이픈만
    private var myPeerID: MCPeerID
    private var session: MCSession
    private var advertiser: MCNearbyServiceAdvertiser?
    private var browser: MCNearbyServiceBrowser?

    var connectedPeers: [MCPeerID] = []
    var availablePeers: [MCPeerID] = []
    var receivedMessages: [String] = []
    var isAdvertising = false
    var isBrowsing = false

    override init() {
        // Peer ID 생성 (기기 이름 사용)
        myPeerID = MCPeerID(displayName: UIDevice.current.name)

        // 세션 생성
        session = MCSession(
            peer: myPeerID,
            securityIdentity: nil,
            encryptionPreference: .required
        )

        super.init()

        session.delegate = self

        print("📱 Peer ID: \(myPeerID.displayName)")
    }

    // Advertiser 시작 (다른 기기가 나를 발견할 수 있게)
    func startAdvertising() {
        advertiser = MCNearbyServiceAdvertiser(
            peer: myPeerID,
            discoveryInfo: ["status": "available"],
            serviceType: serviceType
        )
        advertiser?.delegate = self
        advertiser?.startAdvertisingPeer()

        isAdvertising = true
        print("📢 Advertising 시작")
    }

    // Advertiser 중지
    func stopAdvertising() {
        advertiser?.stopAdvertisingPeer()
        advertiser = nil
        isAdvertising = false
        print("⏹️ Advertising 중지")
    }

    // Browser 시작 (다른 기기 검색)
    func startBrowsing() {
        browser = MCNearbyServiceBrowser(peer: myPeerID, serviceType: serviceType)
        browser?.delegate = self
        browser?.startBrowsingForPeers()

        isBrowsing = true
        print("🔍 Browsing 시작")
    }

    // Browser 중지
    func stopBrowsing() {
        browser?.stopBrowsingForPeers()
        browser = nil
        isBrowsing = false
        print("⏹️ Browsing 중지")
    }

    // Peer에게 초대 보내기
    func invitePeer(_ peerID: MCPeerID) {
        guard let browser = browser else { return }

        browser.invitePeer(
            peerID,
            to: session,
            withContext: nil,
            timeout: 30
        )

        print("✉️ 초대 전송: \(peerID.displayName)")
    }

    // 연결 해제
    func disconnect() {
        session.disconnect()
        connectedPeers.removeAll()
        print("❌ 연결 해제")
    }
}

import MultipeerConnectivity

extension MultipeerManager {
    // 텍스트 메시지 전송
    func sendMessage(_ message: String) {
        guard !connectedPeers.isEmpty else {
            print("⚠️ 연결된 Peer가 없습니다")
            return
        }

        guard let data = message.data(using: .utf8) else { return }

        do {
            // 모든 연결된 Peer에게 전송
            try session.send(
                data,
                toPeers: connectedPeers,
                with: .reliable
            )

            print("📤 메시지 전송: \(message)")
        } catch {
            print("❌ 전송 실패: \(error.localizedDescription)")
        }
    }

    // 특정 Peer에게만 전송
    func sendMessage(_ message: String, to peer: MCPeerID) {
        guard let data = message.data(using: .utf8) else { return }

        do {
            try session.send(data, toPeers: [peer], with: .reliable)
            print("📤 메시지 전송 (\(peer.displayName)): \(message)")
        } catch {
            print("❌ 전송 실패: \(error.localizedDescription)")
        }
    }

    // 파일 전송
    func sendFile(at url: URL, to peer: MCPeerID, withName name: String) {
        session.sendResource(
            at: url,
            withName: name,
            toPeer: peer,
            withCompletionHandler: { error in
                if let error = error {
                    print("❌ 파일 전송 실패: \(error.localizedDescription)")
                } else {
                    print("✅ 파일 전송 완료: \(name)")
                }
            }
        )

        print("📁 파일 전송 시작: \(name)")
    }

    // 이미지 전송
    func sendImage(_ image: UIImage) {
        guard !connectedPeers.isEmpty else { return }
        guard let imageData = image.jpegData(compressionQuality: 0.8) else { return }

        do {
            try session.send(imageData, toPeers: connectedPeers, with: .reliable)
            print("🖼️ 이미지 전송 완료")
        } catch {
            print("❌ 이미지 전송 실패: \(error.localizedDescription)")
        }
    }

    // JSON 데이터 전송
    func sendJSON<T: Encodable>(_ object: T) {
        guard !connectedPeers.isEmpty else { return }

        do {
            let encoder = JSONEncoder()
            let data = try encoder.encode(object)

            try session.send(data, toPeers: connectedPeers, with: .reliable)
            print("📦 JSON 전송 완료")
        } catch {
            print("❌ JSON 전송 실패: \(error.localizedDescription)")
        }
    }
}

import MultipeerConnectivity

extension MultipeerManager: MCSessionDelegate {
    // Peer 상태 변경
    func session(_ session: MCSession, peer peerID: MCPeerID, didChange state: MCSessionState) {
        switch state {
        case .connected:
            print("✅ 연결됨: \(peerID.displayName)")
            if !connectedPeers.contains(peerID) {
                connectedPeers.append(peerID)
            }

        case .connecting:
            print("🔗 연결 중: \(peerID.displayName)")

        case .notConnected:
            print("❌ 연결 해제: \(peerID.displayName)")
            connectedPeers.removeAll { $0 == peerID }

        @unknown default:
            break
        }
    }

    // 데이터 수신
    func session(_ session: MCSession, didReceive data: Data, fromPeer peerID: MCPeerID) {
        print("📥 데이터 수신 from \(peerID.displayName): \(data.count) bytes")

        // 텍스트 메시지 시도
        if let message = String(data: data, encoding: .utf8) {
            let formattedMessage = "\(peerID.displayName): \(message)"
            receivedMessages.append(formattedMessage)
            print("  💬 메시지: \(message)")
        }
        // 이미지 시도
        else if let image = UIImage(data: data) {
            print("  🖼️ 이미지 수신: \(image.size)")
            receivedMessages.append("\(peerID.displayName): [이미지]")
        }
        // 기타 바이너리 데이터
        else {
            print("  📦 바이너리 데이터")
            receivedMessages.append("\(peerID.displayName): [데이터]")
        }
    }

    // 파일 수신 시작
    func session(
        _ session: MCSession,
        didStartReceivingResourceWithName resourceName: String,
        fromPeer peerID: MCPeerID,
        with progress: Progress
    ) {
        print("📥 파일 수신 시작: \(resourceName) from \(peerID.displayName)")
        print("  진행률: \(progress.fractionCompleted * 100)%")
    }

    // 파일 수신 완료
    func session(
        _ session: MCSession,
        didFinishReceivingResourceWithName resourceName: String,
        fromPeer peerID: MCPeerID,
        at localURL: URL?,
        withError error: Error?
    ) {
        if let error = error {
            print("❌ 파일 수신 실패: \(error.localizedDescription)")
            return
        }

        guard let localURL = localURL else { return }

        print("✅ 파일 수신 완료: \(resourceName)")
        print("  경로: \(localURL.path)")

        receivedMessages.append("\(peerID.displayName): [파일] \(resourceName)")

        // 파일을 Documents 폴더로 복사
        do {
            let documentsURL = FileManager.default
                .urls(for: .documentDirectory, in: .userDomainMask)[0]
            let destinationURL = documentsURL.appendingPathComponent(resourceName)

            // 기존 파일 삭제
            if FileManager.default.fileExists(atPath: destinationURL.path) {
                try FileManager.default.removeItem(at: destinationURL)
            }

            try FileManager.default.copyItem(at: localURL, to: destinationURL)
            print("  📁 파일 저장: \(destinationURL.path)")
        } catch {
            print("❌ 파일 저장 실패: \(error.localizedDescription)")
        }
    }

    // 스트림 수신
    func session(
        _ session: MCSession,
        didReceive stream: InputStream,
        withName streamName: String,
        fromPeer peerID: MCPeerID
    ) {
        print("📡 스트림 수신: \(streamName) from \(peerID.displayName)")
        // 스트림 처리 로직 구현
    }
}

import MultipeerConnectivity

// Browser Delegate
extension MultipeerManager: MCNearbyServiceBrowserDelegate {
    // Peer 발견
    func browser(
        _ browser: MCNearbyServiceBrowser,
        foundPeer peerID: MCPeerID,
        withDiscoveryInfo info: [String: String]?
    ) {
        print("🔍 Peer 발견: \(peerID.displayName)")

        if let info = info {
            print("  Discovery Info: \(info)")
        }

        if !availablePeers.contains(peerID) {
            availablePeers.append(peerID)
        }
    }

    // Peer 사라짐
    func browser(_ browser: MCNearbyServiceBrowser, lostPeer peerID: MCPeerID) {
        print("❌ Peer 사라짐: \(peerID.displayName)")
        availablePeers.removeAll { $0 == peerID }
    }

    // Browser 에러
    func browser(_ browser: MCNearbyServiceBrowser, didNotStartBrowsingForPeers error: Error) {
        print("❌ Browsing 시작 실패: \(error.localizedDescription)")
    }
}

// Advertiser Delegate
extension MultipeerManager: MCNearbyServiceAdvertiserDelegate {
    // 초대 수신
    func advertiser(
        _ advertiser: MCNearbyServiceAdvertiser,
        didReceiveInvitationFromPeer peerID: MCPeerID,
        withContext context: Data?,
        invitationHandler: @escaping (Bool, MCSession?) -> Void
    ) {
        print("✉️ 초대 수신: \(peerID.displayName)")

        // 자동 수락
        invitationHandler(true, session)

        // 또는 사용자에게 확인 (실제 앱에서는 UI로 처리)
        // invitationHandler(false, nil) // 거절
    }

    // Advertiser 에러
    func advertiser(_ advertiser: MCNearbyServiceAdvertiser, didNotStartAdvertisingPeer error: Error) {
        print("❌ Advertising 시작 실패: \(error.localizedDescription)")
    }
}

import SwiftUI

struct MultipeerChatView: View {
    @State private var multipeerManager = MultipeerManager()
    @State private var messageText = ""
    @State private var showingPeerList = false

    var body: some View {
        NavigationStack {
            VStack(spacing: 0) {
                // 연결 상태
                connectionStatus

                // 메시지 목록
                messageList

                // 입력 창
                messageInput
            }
            .navigationTitle("P2P 채팅")
            .toolbar {
                ToolbarItem(placement: .topBarTrailing) {
                    Button {
                        showingPeerList = true
                    } label: {
                        Image(systemName: "person.2")
                    }
                }
            }
            .sheet(isPresented: $showingPeerList) {
                peerListSheet
            }
            .onAppear {
                multipeerManager.startAdvertising()
                multipeerManager.startBrowsing()
            }
            .onDisappear {
                multipeerManager.stopAdvertising()
                multipeerManager.stopBrowsing()
            }
        }
    }

    // 연결 상태 헤더
    private var connectionStatus: some View {
        HStack {
            Circle()
                .fill(multipeerManager.connectedPeers.isEmpty ? Color.red : Color.green)
                .frame(width: 12, height: 12)

            if multipeerManager.connectedPeers.isEmpty {
                Text("연결된 기기 없음")
                    .font(.subheadline)
                    .foregroundStyle(.secondary)
            } else {
                Text("\(multipeerManager.connectedPeers.count)개 기기 연결됨")
                    .font(.subheadline)
                    .foregroundStyle(.secondary)
            }

            Spacer()
        }
        .padding()
        .background(Color(.systemGroupedBackground))
    }

    // 메시지 목록
    private var messageList: some View {
        ScrollView {
            LazyVStack(alignment: .leading, spacing: 12) {
                ForEach(multipeerManager.receivedMessages, id: \.self) { message in
                    Text(message)
                        .padding(12)
                        .background(Color(.systemGray6))
                        .cornerRadius(12)
                }
            }
            .padding()
        }
    }

    // 메시지 입력
    private var messageInput: some View {
        HStack {
            TextField("메시지 입력...", text: $messageText)
                .textFieldStyle(.roundedBorder)
                .onSubmit {
                    sendMessage()
                }

            Button {
                sendMessage()
            } label: {
                Image(systemName: "paperplane.fill")
                    .font(.title3)
            }
            .disabled(messageText.isEmpty || multipeerManager.connectedPeers.isEmpty)
        }
        .padding()
        .background(Color(.systemBackground))
    }

    // Peer 목록 시트
    private var peerListSheet: some View {
        NavigationStack {
            List {
                Section("연결된 기기") {
                    if multipeerManager.connectedPeers.isEmpty {
                        Text("연결된 기기 없음")
                            .foregroundStyle(.secondary)
                    } else {
                        ForEach(multipeerManager.connectedPeers, id: \.self) { peer in
                            HStack {
                                Image(systemName: "checkmark.circle.fill")
                                    .foregroundStyle(.green)
                                Text(peer.displayName)
                            }
                        }
                    }
                }

                Section("근처 기기") {
                    if multipeerManager.availablePeers.isEmpty {
                        Text("검색된 기기 없음")
                            .foregroundStyle(.secondary)
                    } else {
                        ForEach(multipeerManager.availablePeers, id: \.self) { peer in
                            Button {
                                multipeerManager.invitePeer(peer)
                            } label: {
                                HStack {
                                    Image(systemName: "iphone")
                                    Text(peer.displayName)
                                    Spacer()
                                    Image(systemName: "plus.circle")
                                }
                            }
                        }
                    }
                }
            }
            .navigationTitle("기기 목록")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .topBarTrailing) {
                    Button("닫기") {
                        showingPeerList = false
                    }
                }
            }
        }
    }

    private func sendMessage() {
        multipeerManager.sendMessage(messageText)
        multipeerManager.receivedMessages.append("나: \(messageText)")
        messageText = ""
    }
}