📱 Core NFC

import CoreNFC
import SwiftUI

@Observable
class NFCReaderManager: NSObject {
    var session: NFCNDEFReaderSession?
    var detectedMessages: [NFCNDEFMessage] = []
    var isScanning = false
    var lastError: String?

    // NFC 지원 여부 확인
    var isNFCAvailable: Bool {
        NFCNDEFReaderSession.readingAvailable
    }

    // 태그 읽기 시작
    func startScanning() {
        guard isNFCAvailable else {
            lastError = "이 기기는 NFC를 지원하지 않습니다"
            print("❌ NFC 미지원")
            return
        }

        detectedMessages.removeAll()
        lastError = nil

        // NDEF Reader Session 생성
        session = NFCNDEFReaderSession(
            delegate: self,
            queue: nil,
            invalidateAfterFirstRead: false
        )

        // 사용자에게 표시될 메시지
        session?.alertMessage = "NFC 태그를 iPhone 상단에 가까이 대주세요"

        // 스캔 시작
        session?.begin()
        isScanning = true

        print("🔍 NFC 스캔 시작")
    }

    // 스캔 중지
    func stopScanning() {
        session?.invalidate()
        isScanning = false
        print("⏹️ NFC 스캔 중지")
    }

    // NDEF 레코드 파싱
    func parseNDEFRecords(from message: NFCNDEFMessage) -> [String] {
        var results: [String] = []

        for record in message.records {
            // Type Name Format
            let tnf = record.typeNameFormat

            switch tnf {
            case .nfcWellKnown:
                // URI 레코드
                if let url = record.wellKnownTypeURIPayload() {
                    results.append("🔗 URL: \(url.absoluteString)")
                }
                // Text 레코드
                else if let text = String(data: record.payload, encoding: .utf8) {
                    results.append("📝 Text: \(text)")
                }

            case .absoluteURI:
                if let text = String(data: record.payload, encoding: .utf8) {
                    results.append("🌐 URI: \(text)")
                }

            case .media:
                let mimeType = String(data: record.type, encoding: .utf8) ?? "unknown"
                results.append("📄 Media Type: \(mimeType)")

            case .empty:
                results.append("⚪️ Empty record")

            @unknown default:
                results.append("❓ Unknown record type")
            }

            // Payload 크기
            results.append("  Size: \(record.payload.count) bytes")
        }

        return results
    }
}

import CoreNFC

extension NFCReaderManager: NFCNDEFReaderSessionDelegate {
    // 태그 발견
    func readerSession(_ session: NFCNDEFReaderSession, didDetectNDEFs messages: [NFCNDEFMessage]) {
        print("📱 태그 발견! 메시지 개수: \(messages.count)")

        // 메시지 저장
        detectedMessages.append(contentsOf: messages)

        // 각 메시지 처리
        for (index, message) in messages.enumerated() {
            print("  메시지 \(index + 1): \(message.records.count)개 레코드")

            for (recordIndex, record) in message.records.enumerated() {
                print("    레코드 \(recordIndex + 1):")

                // URL 파싱
                if let url = record.wellKnownTypeURIPayload() {
                    print("      🔗 URL: \(url.absoluteString)")
                }

                // Text 파싱
                if let text = parseTextPayload(record.payload) {
                    print("      📝 Text: \(text)")
                }
            }
        }

        // 성공 메시지
        session.alertMessage = "✅ \(messages.count)개 메시지를 읽었습니다"
    }

    // 태그 발견 (고급 API)
    func readerSession(_ session: NFCNDEFReaderSession, didDetect tags: [NFCNDEFTag]) {
        guard tags.count == 1 else {
            session.alertMessage = "⚠️ 태그가 너무 많습니다. 하나만 가까이 대주세요"
            session.restartPolling()
            return
        }

        let tag = tags.first!

        // 태그 연결
        session.connect(to: tag) { error in
            if let error = error {
                session.invalidate(errorMessage: "❌ 태그 연결 실패: \(error.localizedDescription)")
                return
            }

            print("✅ 태그 연결 성공")

            // NDEF 메시지 읽기
            tag.queryNDEFStatus { status, capacity, error in
                if let error = error {
                    session.invalidate(errorMessage: "❌ 상태 확인 실패: \(error.localizedDescription)")
                    return
                }

                print("📊 태그 상태: \(status.rawValue), 용량: \(capacity) bytes")

                switch status {
                case .notSupported:
                    session.invalidate(errorMessage: "❌ NDEF를 지원하지 않는 태그입니다")

                case .readOnly:
                    self.readNDEFMessage(from: tag, session: session)

                case .readWrite:
                    self.readNDEFMessage(from: tag, session: session)

                @unknown default:
                    session.invalidate(errorMessage: "❓ 알 수 없는 태그 상태")
                }
            }
        }
    }

    // NDEF 메시지 읽기
    private func readNDEFMessage(from tag: NFCNDEFTag, session: NFCNDEFReaderSession) {
        tag.readNDEF { message, error in
            if let error = error {
                session.invalidate(errorMessage: "❌ 읽기 실패: \(error.localizedDescription)")
                return
            }

            if let message = message {
                self.detectedMessages.append(message)
                session.alertMessage = "✅ \(message.records.count)개 레코드를 읽었습니다"
                print("📖 NDEF 메시지 읽기 성공")
            }

            session.invalidate()
        }
    }

    // 세션 무효화
    func readerSession(_ session: NFCNDEFReaderSession, didInvalidateWithError error: Error) {
        isScanning = false

        if let nfcError = error as? NFCReaderError {
            switch nfcError.code {
            case .readerSessionInvalidationErrorUserCanceled:
                print("⏹️ 사용자가 스캔을 취소했습니다")
            case .readerSessionInvalidationErrorSessionTimeout:
                print("⏱️ 세션 시간 초과")
                lastError = "스캔 시간이 초과되었습니다"
            case .readerSessionInvalidationErrorFirstNDEFTagRead:
                print("✅ 첫 번째 태그 읽기 완료")
            default:
                print("❌ NFC 에러: \(nfcError.localizedDescription)")
                lastError = nfcError.localizedDescription
            }
        } else {
            print("❌ 에러: \(error.localizedDescription)")
            lastError = error.localizedDescription
        }
    }

    // Text Payload 파싱
    private func parseTextPayload(_ payload: Data) -> String? {
        guard payload.count > 1 else { return nil }

        // Status byte: bit 7 = UTF-16 여부, bit 0-5 = 언어 코드 길이
        let statusByte = payload[0]
        let isUTF16 = (statusByte & 0x80) != 0
        let langCodeLength = Int(statusByte & 0x3F)

        guard payload.count > langCodeLength + 1 else { return nil }

        // 텍스트 추출
        let textData = payload.subdata(in: (1 + langCodeLength)..<payload.count)
        let encoding: String.Encoding = isUTF16 ? .utf16 : .utf8

        return String(data: textData, encoding: encoding)
    }
}

import CoreNFC

@Observable
class NFCWriterManager: NSObject {
    var session: NFCNDEFReaderSession?
    var messageToWrite: NFCNDEFMessage?
    var writeSuccess = false

    // URL을 태그에 쓰기
    func writeURL(_ url: URL) {
        guard NFCNDEFReaderSession.readingAvailable else {
            print("❌ NFC 미지원")
            return
        }

        // NDEF Payload 생성
        guard let payload = NFCNDEFPayload.wellKnownTypeURIPayload(url: url) else {
            print("❌ Payload 생성 실패")
            return
        }

        messageToWrite = NFCNDEFMessage(records: [payload])

        // 세션 시작
        session = NFCNDEFReaderSession(delegate: self, queue: nil, invalidateAfterFirstRead: false)
        session?.alertMessage = "쓰기를 원하는 NFC 태그를 가까이 대주세요"
        session?.begin()

        print("✍️ URL 쓰기 시작: \(url.absoluteString)")
    }

    // 텍스트를 태그에 쓰기
    func writeText(_ text: String) {
        guard NFCNDEFReaderSession.readingAvailable else { return }

        // Text Payload 생성
        guard let payload = createTextPayload(text: text, languageCode: "en") else {
            print("❌ Text Payload 생성 실패")
            return
        }

        messageToWrite = NFCNDEFMessage(records: [payload])

        session = NFCNDEFReaderSession(delegate: self, queue: nil, invalidateAfterFirstRead: false)
        session?.alertMessage = "쓰기를 원하는 NFC 태그를 가까이 대주세요"
        session?.begin()

        print("✍️ 텍스트 쓰기 시작: \(text)")
    }

    // 여러 레코드를 태그에 쓰기
    func writeMultipleRecords(url: URL, text: String) {
        guard NFCNDEFReaderSession.readingAvailable else { return }

        var records: [NFCNDEFPayload] = []

        // URL Payload
        if let urlPayload = NFCNDEFPayload.wellKnownTypeURIPayload(url: url) {
            records.append(urlPayload)
        }

        // Text Payload
        if let textPayload = createTextPayload(text: text, languageCode: "en") {
            records.append(textPayload)
        }

        messageToWrite = NFCNDEFMessage(records: records)

        session = NFCNDEFReaderSession(delegate: self, queue: nil, invalidateAfterFirstRead: false)
        session?.alertMessage = "쓰기를 원하는 NFC 태그를 가까이 대주세요"
        session?.begin()

        print("✍️ 다중 레코드 쓰기 시작")
    }

    // Text Payload 생성
    private func createTextPayload(text: String, languageCode: String) -> NFCNDEFPayload? {
        guard let textData = text.data(using: .utf8) else { return nil }
        guard let langData = languageCode.data(using: .utf8) else { return nil }

        // Status byte: UTF-8, 언어 코드 길이
        var payload = Data()
        payload.append(UInt8(langData.count))
        payload.append(langData)
        payload.append(textData)

        return NFCNDEFPayload(
            format: .nfcWellKnown,
            type: "T".data(using: .utf8)!,
            identifier: Data(),
            payload: payload
        )
    }
}

extension NFCWriterManager: NFCNDEFReaderSessionDelegate {
    // 태그 발견 (쓰기용)
    func readerSession(_ session: NFCNDEFReaderSession, didDetect tags: [NFCNDEFTag]) {
        guard tags.count == 1, let tag = tags.first else {
            session.alertMessage = "⚠️ 태그가 너무 많습니다"
            session.restartPolling()
            return
        }

        session.connect(to: tag) { error in
            if let error = error {
                session.invalidate(errorMessage: "❌ 연결 실패: \(error.localizedDescription)")
                return
            }

            // 태그 상태 확인
            tag.queryNDEFStatus { status, capacity, error in
                if let error = error {
                    session.invalidate(errorMessage: "❌ 상태 확인 실패: \(error.localizedDescription)")
                    return
                }

                guard status == .readWrite else {
                    session.invalidate(errorMessage: "❌ 읽기 전용 태그입니다")
                    return
                }

                // 메시지 쓰기
                guard let message = self.messageToWrite else {
                    session.invalidate(errorMessage: "❌ 쓸 메시지가 없습니다")
                    return
                }

                tag.writeNDEF(message) { error in
                    if let error = error {
                        session.invalidate(errorMessage: "❌ 쓰기 실패: \(error.localizedDescription)")
                    } else {
                        session.alertMessage = "✅ 쓰기 성공!"
                        self.writeSuccess = true
                        print("✅ NFC 태그 쓰기 완료")
                        session.invalidate()
                    }
                }
            }
        }
    }

    func readerSession(_ session: NFCNDEFReaderSession, didDetectNDEFs messages: [NFCNDEFMessage]) {
        // 쓰기 모드에서는 사용하지 않음
    }

    func readerSession(_ session: NFCNDEFReaderSession, didInvalidateWithError error: Error) {
        if let nfcError = error as? NFCReaderError,
           nfcError.code != .readerSessionInvalidationErrorUserCanceled {
            print("❌ 세션 종료: \(error.localizedDescription)")
        }
    }
}

import SwiftUI

struct NFCReaderView: View {
    @State private var readerManager = NFCReaderManager()
    @State private var writerManager = NFCWriterManager()
    @State private var urlText = "https://developer.apple.com"
    @State private var writeText = "Hello NFC!"

    var body: some View {
        NavigationStack {
            Form {
                // 읽기 섹션
                Section("태그 읽기") {
                    Button {
                        readerManager.startScanning()
                    } label: {
                        Label("NFC 태그 스캔", systemImage: "wave.3.right")
                    }
                    .disabled(!readerManager.isNFCAvailable || readerManager.isScanning)

                    if readerManager.isScanning {
                        HStack {
                            ProgressView()
                            Text("스캔 중...")
                                .foregroundStyle(.secondary)
                        }
                    }
                }

                // 읽은 메시지
                if !readerManager.detectedMessages.isEmpty {
                    Section("스캔 결과") {
                        ForEach(readerManager.detectedMessages.indices, id: \.self) { index in
                            let message = readerManager.detectedMessages[index]
                            VStack(alignment: .leading, spacing: 8) {
                                Text("메시지 \(index + 1)")
                                    .font(.headline)

                                ForEach(readerManager.parseNDEFRecords(from: message), id: \.self) { record in
                                    Text(record)
                                        .font(.caption)
                                        .foregroundStyle(.secondary)
                                }
                            }
                        }
                    }
                }

                // 쓰기 섹션
                Section("태그 쓰기") {
                    TextField("URL", text: $urlText)
                        .keyboardType(.URL)
                        .autocapitalization(.none)

                    Button {
                        if let url = URL(string: urlText) {
                            writerManager.writeURL(url)
                        }
                    } label: {
                        Label("URL 쓰기", systemImage: "link")
                    }
                    .disabled(!readerManager.isNFCAvailable)

                    TextField("텍스트", text: $writeText)

                    Button {
                        writerManager.writeText(writeText)
                    } label: {
                        Label("텍스트 쓰기", systemImage: "text.cursor")
                    }
                    .disabled(!readerManager.isNFCAvailable)
                }

                // 상태
                Section {
                    Text("NFC 지원: \(readerManager.isNFCAvailable ? "✅" : "❌")")
                        .foregroundStyle(.secondary)

                    if let error = readerManager.lastError {
                        Text("에러: \(error)")
                            .foregroundStyle(.red)
                            .font(.caption)
                    }
                }
            }
            .navigationTitle("NFC 리더/라이터")
        }
    }
}