📶 Wi-Fi Aware

// Info.plist에 추가
NSLocalNetworkUsageDescription
"근처 기기와 Wi-Fi를 통해 연결하고 데이터를 공유합니다"

// Bonjour 서비스 추가 (옵션)
NSBonjourServices
_wifiaware._tcp

import NearbyInteraction
import Network

@Observable
class WiFiAwareManager: NSObject {
    var session: NIWiFiAwareSession?
    var discoveryToken: NIWiFiAwareDiscoveryToken?
    var discoveredPeers: [NIWiFiAwarePeerToken] = []
    var isRunning = false

    // 세션 시작
    func startSession() {
        // Wi-Fi Aware 세션 생성
        session = NIWiFiAwareSession()
        session?.delegate = self

        // 세션 시작 및 Discovery Token 생성
        do {
            discoveryToken = try session?.createDiscoveryToken()
            isRunning = true
            print("Wi-Fi Aware 세션 시작됨")
        } catch {
            print("세션 시작 실패: \(error)")
        }
    }

    // 세션 중지
    func stopSession() {
        session?.invalidate()
        session = nil
        discoveryToken = nil
        discoveredPeers.removeAll()
        isRunning = false
        print("Wi-Fi Aware 세션 종료됨")
    }

    // Discovery Token을 Data로 변환 (공유용)
    func getDiscoveryTokenData() -> Data? {
        guard let token = discoveryToken else { return nil }
        return try? NSKeyedArchiver.archivedData(
            withRootObject: token,
            requiringSecureCoding: true
        )
    }

    // 상대방의 Discovery Token으로 피어 추가
    func addPeer(tokenData: Data) {
        do {
            let peerToken = try NSKeyedUnarchiver.unarchivedObject(
                ofClass: NIWiFiAwarePeerToken.self,
                from: tokenData
            )

            if let peerToken = peerToken {
                // 피어 추가
                session?.add(peerToken)
                print("피어 추가됨")
            }
        } catch {
            print("피어 추가 실패: \(error)")
        }
    }

    // 피어 제거
    func removePeer(_ peerToken: NIWiFiAwarePeerToken) {
        session?.remove(peerToken)
        discoveredPeers.removeAll { $0 == peerToken }
        print("피어 제거됨")
    }
}

// Delegate 구현
extension WiFiAwareManager: NIWiFiAwareSessionDelegate {
    // 세션이 시작되었을 때
    func wifiAwareSession(_ session: NIWiFiAwareSession, didStartWith configuration: NIWiFiAwareConfiguration) {
        print("Wi-Fi Aware 세션 활성화됨")
    }

    // 세션이 중지되었을 때
    func wifiAwareSession(_ session: NIWiFiAwareSession, didInvalidateWith error: Error) {
        print("세션 무효화: \(error)")
        isRunning = false
    }

    // 피어가 발견되었을 때
    func wifiAwareSession(_ session: NIWiFiAwareSession, didDiscover peerToken: NIWiFiAwarePeerToken) {
        if !discoveredPeers.contains(peerToken) {
            discoveredPeers.append(peerToken)
            print("새 피어 발견: \(peerToken)")
        }
    }

    // 피어 연결이 끊어졌을 때
    func wifiAwareSession(_ session: NIWiFiAwareSession, didLose peerToken: NIWiFiAwarePeerToken) {
        discoveredPeers.removeAll { $0 == peerToken }
        print("피어 연결 끊김: \(peerToken)")
    }
}

import Network
import NearbyInteraction

@Observable
class WiFiAwareDataChannel {
    var connection: NWConnection?
    var listener: NWListener?
    var receivedMessages: [String] = []
    var isConnected = false

    // 데이터 리스너 시작 (서버 역할)
    func startListener(peerToken: NIWiFiAwarePeerToken) {
        let parameters = NWParameters.tcp
        parameters.requiredInterfaceType = .wifi

        do {
            listener = try NWListener(using: parameters)

            listener?.newConnectionHandler = { [weak self] newConnection in
                self?.handleNewConnection(newConnection)
            }

            listener?.stateUpdateHandler = { state in
                switch state {
                case .ready:
                    print("리스너 준비됨")
                case .failed(let error):
                    print("리스너 실패: \(error)")
                default:
                    break
                }
            }

            listener?.start(queue: .main)
        } catch {
            print("리스너 시작 실패: \(error)")
        }
    }

    // 피어에 연결 (클라이언트 역할)
    func connectToPeer(endpoint: NWEndpoint) {
        let parameters = NWParameters.tcp
        parameters.requiredInterfaceType = .wifi

        connection = NWConnection(to: endpoint, using: parameters)

        connection?.stateUpdateHandler = { [weak self] state in
            switch state {
            case .ready:
                self?.isConnected = true
                print("피어 연결 완료")
                self?.receiveData()
            case .failed(let error):
                self?.isConnected = false
                print("연결 실패: \(error)")
            case .cancelled:
                self?.isConnected = false
                print("연결 취소됨")
            default:
                break
            }
        }

        connection?.start(queue: .main)
    }

    // 새 연결 처리
    private func handleNewConnection(_ newConnection: NWConnection) {
        connection = newConnection
        isConnected = true

        connection?.stateUpdateHandler = { [weak self] state in
            if state == .ready {
                self?.receiveData()
            }
        }

        connection?.start(queue: .main)
    }

    // 데이터 전송
    func sendData(_ message: String) {
        guard let data = message.data(using: .utf8) else { return }

        connection?.send(
            content: data,
            completion: .contentProcessed { error in
                if let error = error {
                    print("전송 실패: \(error)")
                } else {
                    print("메시지 전송 완료: \(message)")
                }
            }
        )
    }

    // 데이터 수신
    private func receiveData() {
        connection?.receive(minimumIncompleteLength: 1, maximumLength: 65536) { [weak self] data, context, isComplete, error in
            if let data = data, !data.isEmpty {
                if let message = String(data: data, encoding: .utf8) {
                    self?.receivedMessages.append(message)
                    print("메시지 수신: \(message)")
                }
            }

            if error == nil {
                self?.receiveData() // 계속 수신 대기
            }
        }
    }

    // 연결 종료
    func disconnect() {
        connection?.cancel()
        listener?.cancel()
        connection = nil
        listener = nil
        isConnected = false
    }
}

import SwiftUI
import CoreImage.filters

class TokenExchangeHelper {
    // Token을 QR 코드로 변환
    func generateQRCode(from tokenData: Data) -> UIImage? {
        let filter = CIFilter.qrCodeGenerator()
        filter.message = tokenData

        if let outputImage = filter.outputImage {
            let transform = CGAffineTransform(scaleX: 10, y: 10)
            let scaledImage = outputImage.transformed(by: transform)

            let context = CIContext()
            if let cgImage = context.createCGImage(scaledImage, from: scaledImage.extent) {
                return UIImage(cgImage: cgImage)
            }
        }

        return nil
    }

    // Base64 문자열로 변환 (간단한 공유)
    func encodeTokenToString(_ tokenData: Data) -> String {
        return tokenData.base64EncodedString()
    }

    // Base64 문자열을 Token Data로 변환
    func decodeTokenFromString(_ string: String) -> Data? {
        return Data(base64Encoded: string)
    }
}

import SwiftUI
import NearbyInteraction

struct WiFiAwareView: View {
    @State private var manager = WiFiAwareManager()
    @State private var dataChannel = WiFiAwareDataChannel()
    @State private var tokenHelper = TokenExchangeHelper()

    @State private var messageToSend = ""
    @State private var showQRCode = false
    @State private var qrCodeImage: UIImage?

    var body: some View {
        NavigationStack {
            List {
                // 세션 상태
                Section("세션") {
                    HStack {
                        Text("상태")
                        Spacer()
                        Text(manager.isRunning ? "활성" : "비활성")
                            .foregroundStyle(manager.isRunning ? .green : .secondary)
                    }

                    if manager.isRunning {
                        Button("내 QR 코드 표시") {
                            if let tokenData = manager.getDiscoveryTokenData() {
                                qrCodeImage = tokenHelper.generateQRCode(from: tokenData)
                                showQRCode = true
                            }
                        }
                    }

                    Button(manager.isRunning ? "세션 중지" : "세션 시작") {
                        if manager.isRunning {
                            manager.stopSession()
                            dataChannel.disconnect()
                        } else {
                            manager.startSession()
                        }
                    }
                    .foregroundStyle(manager.isRunning ? .red : .blue)
                }

                // 발견된 피어
                Section("발견된 기기 (\(manager.discoveredPeers.count))") {
                    if manager.discoveredPeers.isEmpty {
                        Text("주변에 기기가 없습니다")
                            .foregroundStyle(.secondary)
                    } else {
                        ForEach(manager.discoveredPeers.indices, id: \.self) { index in
                            HStack {
                                Image(systemName: "wifi")
                                    .foregroundStyle(.blue)
                                Text("기기 \(index + 1)")

                                Spacer()

                                if dataChannel.isConnected {
                                    Image(systemName: "checkmark.circle.fill")
                                        .foregroundStyle(.green)
                                }
                            }
                        }
                    }
                }

                // 메시지 전송
                if dataChannel.isConnected {
                    Section("메시지 전송") {
                        TextField("메시지 입력", text: $messageToSend)

                        Button("전송") {
                            dataChannel.sendData(messageToSend)
                            messageToSend = ""
                        }
                        .disabled(messageToSend.isEmpty)
                    }
                }

                // 수신 메시지
                Section("수신 메시지") {
                    if dataChannel.receivedMessages.isEmpty {
                        Text("수신된 메시지가 없습니다")
                            .foregroundStyle(.secondary)
                    } else {
                        ForEach(dataChannel.receivedMessages, id: \.self) { message in
                            Text(message)
                        }
                    }
                }
            }
            .navigationTitle("Wi-Fi Aware")
            .sheet(isPresented: $showQRCode) {
                QRCodeView(qrCodeImage: qrCodeImage)
            }
        }
    }
}

struct QRCodeView: View {
    let qrCodeImage: UIImage?
    @Environment(\.dismiss) var dismiss

    var body: some View {
        NavigationStack {
            VStack(spacing: 20) {
                Text("다른 기기에서 이 QR 코드를 스캔하세요")
                    .font(.headline)

                if let image = qrCodeImage {
                    Image(uiImage: image)
                        .interpolation(.none)
                        .resizable()
                        .scaledToFit()
                        .frame(width: 300, height: 300)
                        .padding()
                        .background(Color.white)
                        .cornerRadius(12)
                        .shadow(radius: 4)
                } else {
                    Text("QR 코드 생성 실패")
                        .foregroundStyle(.secondary)
                }
            }
            .padding()
            .navigationTitle("내 QR 코드")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .confirmationAction) {
                    Button("완료") {
                        dismiss()
                    }
                }
            }
        }
    }
}

import SwiftUI

struct GameMessage: Codable {
    enum Action: String, Codable {
        case move, attack, heal
    }

    let playerName: String
    let action: Action
    let position: CGPoint?
    let timestamp: Date
}

@Observable
class GameController {
    let wifiManager = WiFiAwareManager()
    let dataChannel = WiFiAwareDataChannel()

    var playerName = "Player"
    var playerPosition: CGPoint = .zero
    var opponentPosition: CGPoint = .zero
    var gameLog: [String] = []

    func startGame() {
        wifiManager.startSession()
    }

    func sendAction(action: GameMessage.Action, position: CGPoint? = nil) {
        let message = GameMessage(
            playerName: playerName,
            action: action,
            position: position,
            timestamp: Date()
        )

        if let data = try? JSONEncoder().encode(message),
           let string = String(data: data, encoding: .utf8) {
            dataChannel.sendData(string)
            gameLog.append("\(playerName): \(action.rawValue)")
        }
    }

    func processReceivedMessage(_ messageString: String) {
        guard let data = messageString.data(using: .utf8),
              let message = try? JSONDecoder().decode(GameMessage.self, from: data) else {
            return
        }

        if let position = message.position {
            opponentPosition = position
        }

        gameLog.append("\(message.playerName): \(message.action.rawValue)")
    }
}

struct WiFiAwareGameView: View {
    @State private var controller = GameController()

    var body: some View {
        VStack {
            // 게임 화면
            ZStack {
                Color.gray.opacity(0.2)

                // 내 캐릭터
                Circle()
                    .fill(Color.blue)
                    .frame(width: 40, height: 40)
                    .position(controller.playerPosition)

                // 상대 캐릭터
                Circle()
                    .fill(Color.red)
                    .frame(width: 40, height: 40)
                    .position(controller.opponentPosition)
            }
            .frame(height: 300)
            .gesture(
                DragGesture()
                    .onChanged { value in
                        controller.playerPosition = value.location
                        controller.sendAction(action: .move, position: value.location)
                    }
            )

            // 액션 버튼
            HStack(spacing: 20) {
                Button("공격") {
                    controller.sendAction(action: .attack)
                }
                .buttonStyle(.borderedProminent)
                .tint(.red)

                Button("힐") {
                    controller.sendAction(action: .heal)
                }
                .buttonStyle(.borderedProminent)
                .tint(.green)
            }
            .padding()

            // 게임 로그
            List(controller.gameLog, id: \.self) { log in
                Text(log)
                    .font(.caption)
            }
            .frame(height: 150)
        }
        .onAppear {
            controller.startGame()
        }
    }
}