// 기본적인 접근성 설정
let loginButton = UIButton()
loginButton.setTitle("로그인", for: .normal)

// 접근성 활성화
loginButton.isAccessibilityElement = true

// 레이블 설정 (VoiceOver가 읽을 텍스트)
loginButton.accessibilityLabel = "로그인"

// 특성 설정 (요소의 타입)
loginButton.accessibilityTraits = .button

// 힌트 설정 (사용 방법 안내)
loginButton.accessibilityHint = "두 번 탭하여 계정에 로그인하세요"

// 값 설정 (동적으로 변하는 정보)
// 예: 토글 버튼의 경우
loginButton.accessibilityValue = "활성화됨"

class ProfileCardView: UIView {
    let profileImageView = UIImageView()
    let nameLabel = UILabel()
    let bioLabel = UILabel()
    let followButton = UIButton()
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupAccessibility()
    }
    
    func setupAccessibility() {
        // 전체 카드를 하나의 접근성 요소로 만들기
        isAccessibilityElement = true
        accessibilityTraits = .button
        
        // 하위 뷰들은 개별적으로 접근 불가능하게
        profileImageView.isAccessibilityElement = false
        nameLabel.isAccessibilityElement = false
        bioLabel.isAccessibilityElement = false
        followButton.isAccessibilityElement = false
    }
    
    func updateAccessibility(name: String, bio: String, isFollowing: Bool) {
        // 모든 정보를 하나의 레이블로 결합
        accessibilityLabel = "\(name)의 프로필"
        
        // 상세 정보를 값으로 제공
        accessibilityValue = bio
        
        // 현재 팔로우 상태에 따른 힌트
        if isFollowing {
            accessibilityHint = "두 번 탭하여 팔로우 취소"
        } else {
            accessibilityHint = "두 번 탭하여 팔로우"
        }
    }
}

import SwiftUI

struct LoginView: View {
    @State private var username = ""
    @State private var password = ""
    @State private var isLoading = false
    
    var body: some View {
        VStack(spacing: 20) {
            // 텍스트 필드 접근성
            TextField("사용자 이름", text: $username)
                .accessibilityLabel("사용자 이름 입력")
                .accessibilityHint("계정의 사용자 이름을 입력하세요")
            
            SecureField("비밀번호", text: $password)
                .accessibilityLabel("비밀번호 입력")
                .accessibilityHint("계정의 비밀번호를 입력하세요")
            
            // 버튼 접근성
            Button(action: login) {
                if isLoading {
                    ProgressView()
                        .accessibilityLabel("로그인 중")
                } else {
                    Text("로그인")
                }
            }
            .accessibilityLabel("로그인 버튼")
            .accessibilityHint("두 번 탭하여 로그인")
            .disabled(username.isEmpty || password.isEmpty)
            
            // 이미지 접근성
            Image("logo")
                .accessibilityLabel("재능넷 로고")
                .accessibilityHidden(true) // 장식용 이미지는 숨기기
        }
    }
    
    func login() {
        isLoading = true
        // 로그인 로직...
    }
}

// Traits 조합 예시
let playButton = UIButton()
playButton.accessibilityLabel = "재생"
playButton.accessibilityTraits = [.button, .startsMediaSession]

// SwiftUI에서
Button("재생") { }
    .accessibilityAddTraits(.startsMediaSession)

// 여러 trait 조합
Text("중요 공지")
    .accessibilityAddTraits([.isHeader, .updatesFrequently])

// Swift에서 색상 대비 확인하기
extension UIColor {
    // 상대 휘도 계산
    var luminance: CGFloat {
        var red: CGFloat = 0
        var green: CGFloat = 0
        var blue: CGFloat = 0
        
        getRed(&red, green: &green, blue: &blue, alpha: nil)
        
        func adjust(component: CGFloat) -> CGFloat {
            if component <= 0.03928 {
                return component / 12.92
            }
            return pow((component + 0.055) / 1.055, 2.4)
        }
        
        let r = adjust(component: red)
        let g = adjust(component: green)
        let b = adjust(component: blue)
        
        return 0.2126 * r + 0.7152 * g + 0.0722 * b
    }
    
    // 대비 비율 계산
    func contrastRatio(with color: UIColor) -> CGFloat {
        let l1 = self.luminance
        let l2 = color.luminance
        
        let lighter = max(l1, l2)
        let darker = min(l1, l2)
        
        return (lighter + 0.05) / (darker + 0.05)
    }
    
    // WCAG AA 기준 통과 여부
    func meetsWCAGAA(with backgroundColor: UIColor, 
                      fontSize: CGFloat) -> Bool {
        let ratio = contrastRatio(with: backgroundColor)
        let threshold: CGFloat = fontSize >= 18 ? 3.0 : 4.5
        return ratio >= threshold
    }
}

// 사용 예시
let textColor = UIColor.black
let bgColor = UIColor.white
let ratio = textColor.contrastRatio(with: bgColor)
print("대비 비율: \(ratio):1") // 21:1

if textColor.meetsWCAGAA(with: bgColor, fontSize: 16) {
    print("✅ WCAG AA 기준 통과!")
}

// 접근성 좋은 에러 표시
struct ErrorView: View {
    let message: String
    
    var body: some View {
        HStack(spacing: 12) {
            // 아이콘으로 시각적 단서 제공
            Image(systemName: "exclamationmark.triangle.fill")
                .foregroundColor(.red)
                .accessibilityHidden(true) // 중복 정보 방지
            
            VStack(alignment: .leading, spacing: 4) {
                // 명확한 텍스트 레이블
                Text("오류")
                    .font(.headline)
                    .foregroundColor(.red)
                
                Text(message)
                    .font(.body)
                    .foregroundColor(.primary)
            }
        }
        .padding()
        .background(
            RoundedRectangle(cornerRadius: 8)
                .fill(Color.red.opacity(0.1))
                .overlay(
                    RoundedRectangle(cornerRadius: 8)
                        .stroke(Color.red, lineWidth: 2) // 테두리로 추가 강조
                )
        )
        .accessibilityElement(children: .combine)
        .accessibilityLabel("오류: \(message)")
    }
}

// UIKit에서 Dynamic Type 지원
let label = UILabel()
label.font = UIFont.preferredFont(forTextStyle: .body)
label.adjustsFontForContentSizeCategory = true

// SwiftUI에서는 자동 지원!
Text("안녕하세요")
    .font(.body) // 자동으로 Dynamic Type 적용됨

// 커스텀 폰트에서 Dynamic Type 지원
Text("커스텀 폰트")
    .font(.custom("MyFont", size: 17, relativeTo: .body))

// 최소/최대 크기 제한
Text("제한된 크기")
    .font(.body)
    .dynamicTypeSize(...DynamicTypeSize.xxxLarge)

// UIKit에서 포커스 순서 커스터마이징
class CustomViewController: UIViewController {
    let usernameField = UITextField()
    let passwordField = UITextField()
    let loginButton = UIButton()
    
    override var preferredFocusEnvironments: [UIFocusEnvironment] {
        // 처음 포커스를 받을 요소 지정
        return [usernameField]
    }
    
    override func didUpdateFocus(in context: UIFocusUpdateContext,
                                 with coordinator: UIFocusAnimationCoordinator) {
        super.didUpdateFocus(in: context, with: coordinator)
        
        // 포커스 변경 시 애니메이션 추가
        coordinator.addCoordinatedAnimations({
            context.nextFocusedView?.layer.borderWidth = 2
            context.nextFocusedView?.layer.borderColor = UIColor.blue.cgColor
            context.previouslyFocusedView?.layer.borderWidth = 0
        }, completion: nil)
    }
}

// SwiftUI에서 포커스 관리
struct LoginForm: View {
    @FocusState private var focusedField: Field?
    @State private var username = ""
    @State private var password = ""
    
    enum Field {
        case username, password
    }
    
    var body: some View {
        VStack {
            TextField("사용자 이름", text: $username)
                .focused($focusedField, equals: .username)
                .submitLabel(.next)
                .onSubmit {
                    focusedField = .password
                }
            
            SecureField("비밀번호", text: $password)
                .focused($focusedField, equals: .password)
                .submitLabel(.done)
                .onSubmit {
                    login()
                }
            
            Button("로그인", action: login)
        }
        .onAppear {
            // 화면 표시 시 첫 필드에 포커스
            focusedField = .username
        }
    }
    
    func login() {
        // 로그인 로직
    }
}

// UIKit에서 커스텀 액션
class MessageCell: UITableViewCell {
    func setupAccessibility() {
        // 기본 접근성 설정
        isAccessibilityElement = true
        accessibilityLabel = "김철수님의 메시지"
        accessibilityValue = "안녕하세요!"
        
        // 커스텀 액션 추가
        accessibilityCustomActions = [
            UIAccessibilityCustomAction(
                name: "답장하기",
                target: self,
                selector: #selector(reply)
            ),
            UIAccessibilityCustomAction(
                name: "삭제하기",
                target: self,
                selector: #selector(delete)
            ),
            UIAccessibilityCustomAction(
                name: "전달하기",
                target: self,
                selector: #selector(forward)
            )
        ]
    }
    
    @objc func reply() -> Bool {
        // 답장 로직
        return true // 성공 시 true 반환
    }
    
    @objc func delete() -> Bool {
        // 삭제 로직
        return true
    }
    
    @objc func forward() -> Bool {
        // 전달 로직
        return true
    }
}

// SwiftUI에서 커스텀 액션
struct MessageRow: View {
    let message: Message
    
    var body: some View {
        Text(message.content)
            .accessibilityLabel("\(message.sender)님의 메시지")
            .accessibilityValue(message.content)
            .accessibilityAction(named: "답장하기") {
                reply()
            }
            .accessibilityAction(named: "삭제하기") {
                delete()
            }
            .accessibilityAction(named: "전달하기") {
                forward()
            }
    }
    
    func reply() { /* ... */ }
    func delete() { /* ... */ }
    func forward() { /* ... */ }
}

import SwiftUI

struct AccessibleSignUpForm: View {
    @State private var name = ""
    @State private var email = ""
    @State private var password = ""
    @State private var confirmPassword = ""
    @State private var agreeToTerms = false
    @State private var showingError = false
    @State private var errorMessage = ""
    
    @FocusState private var focusedField: Field?
    
    enum Field {
        case name, email, password, confirmPassword
    }
    
    var body: some View {
        ScrollView {
            VStack(spacing: 24) {
                // 헤더
                headerSection
                
                // 입력 필드들
                formFields
                
                // 약관 동의
                termsSection
                
                // 제출 버튼
                submitButton
            }
            .padding()
        }
        .alert("오류", isPresented: $showingError) {
            Button("확인", role: .cancel) { }
        } message: {
            Text(errorMessage)
        }
    }
    
    // MARK: - 헤더 섹션
    var headerSection: some View {
        VStack(spacing: 12) {
            Image(systemName: "person.crop.circle.badge.plus")
                .font(.system(size: 60))
                .foregroundColor(.blue)
                .accessibilityHidden(true) // 장식용 이미지
            
            Text("회원가입")
                .font(.largeTitle)
                .fontWeight(.bold)
                .accessibilityAddTraits(.isHeader)
            
            Text("재능넷에 오신 것을 환영합니다")
                .font(.subheadline)
                .foregroundColor(.secondary)
        }
        .accessibilityElement(children: .combine)
        .accessibilityLabel("회원가입 화면. 재능넷에 오신 것을 환영합니다")
    }
    
    // MARK: - 폼 필드들
    var formFields: some View {
        VStack(spacing: 16) {
            // 이름 필드
            AccessibleTextField(
                title: "이름",
                placeholder: "홍길동",
                text: $name,
                focusedField: $focusedField,
                field: .name,
                keyboardType: .default,
                textContentType: .name
            )
            .submitLabel(.next)
            .onSubmit { focusedField = .email }
            
            // 이메일 필드
            AccessibleTextField(
                title: "이메일",
                placeholder: "example@email.com",
                text: $email,
                focusedField: $focusedField,
                field: .email,
                keyboardType: .emailAddress,
                textContentType: .emailAddress
            )
            .submitLabel(.next)
            .onSubmit { focusedField = .password }
            
            // 비밀번호 필드
            AccessibleSecureField(
                title: "비밀번호",
                placeholder: "8자 이상 입력",
                text: $password,
                focusedField: $focusedField,
                field: .password
            )
            .submitLabel(.next)
            .onSubmit { focusedField = .confirmPassword }
            
            // 비밀번호 확인 필드
            AccessibleSecureField(
                title: "비밀번호 확인",
                placeholder: "비밀번호 재입력",
                text: $confirmPassword,
                focusedField: $focusedField,
                field: .confirmPassword
            )
            .submitLabel(.done)
            .onSubmit { validateAndSubmit() }
            
            // 비밀번호 강도 표시
            if !password.isEmpty {
                PasswordStrengthIndicator(password: password)
            }
        }
    }
    
    // MARK: - 약관 동의 섹션
    var termsSection: some View {
        Button(action: { agreeToTerms.toggle() }) {
            HStack(spacing: 12) {
                Image(systemName: agreeToTerms ? "checkmark.square.fill" : "square")
                    .font(.title2)
                    .foregroundColor(agreeToTerms ? .blue : .gray)
                
                Text("이용약관 및 개인정보처리방침에 동의합니다")
                    .font(.body)
                    .foregroundColor(.primary)
                    .multilineTextAlignment(.leading)
            }
        }
        .accessibilityElement(children: .combine)
        .accessibilityLabel("이용약관 및 개인정보처리방침 동의")
        .accessibilityValue(agreeToTerms ? "동의함" : "동의하지 않음")
        .accessibilityHint("두 번 탭하여 동의 상태를 변경하세요")
        .accessibilityAddTraits(.isButton)
    }
    
    // MARK: - 제출 버튼
    var submitButton: some View {
        Button(action: validateAndSubmit) {
            Text("가입하기")
                .font(.headline)
                .foregroundColor(.white)
                .frame(maxWidth: .infinity)
                .padding()
                .background(
                    RoundedRectangle(cornerRadius: 12)
                        .fill(isFormValid ? Color.blue : Color.gray)
                )
        }
        .disabled(!isFormValid)
        .accessibilityLabel("가입하기 버튼")
        .accessibilityHint(isFormValid ? 
            "두 번 탭하여 회원가입을 완료하세요" : 
            "모든 필드를 올바르게 입력하고 약관에 동의해야 합니다")
        .accessibilityAddTraits(isFormValid ? [] : .notEnabled)
    }
    
    // MARK: - 유효성 검사
    var isFormValid: Bool {
        !name.isEmpty &&
        isValidEmail(email) &&
        password.count >= 8 &&
        password == confirmPassword &&
        agreeToTerms
    }
    
    func isValidEmail(_ email: String) -> Bool {
        let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
        let emailPredicate = NSPredicate(format:"SELF MATCHES %@", emailRegex)
        return emailPredicate.evaluate(with: email)
    }
    
    func validateAndSubmit() {
        if name.isEmpty {
            showError("이름을 입력해주세요")
        } else if !isValidEmail(email) {
            showError("올바른 이메일 주소를 입력해주세요")
        } else if password.count < 8 {
            showError("비밀번호는 8자 이상이어야 합니다")
        } else if password != confirmPassword {
            showError("비밀번호가 일치하지 않습니다")
        } else if !agreeToTerms {
            showError("이용약관에 동의해주세요")
        } else {
            // 회원가입 처리
            submitForm()
        }
    }
    
    func showError(_ message: String) {
        errorMessage = message
        showingError = true
        
        // VoiceOver 사용자를 위한 즉각적인 피드백
        UIAccessibility.post(
            notification: .announcement,
            argument: "오류: \(message)"
        )
    }
    
    func submitForm() {
        // 실제 회원가입 로직
        print("회원가입 처리: \(name), \(email)")
        
        // 성공 알림
        UIAccessibility.post(
            notification: .announcement,
            argument: "회원가입이 완료되었습니다"
        )
    }
}

// MARK: - 접근성 좋은 텍스트 필드
struct AccessibleTextField: View {
    let title: String
    let placeholder: String
    @Binding var text: String
    var focusedField: FocusState<AccessibleSignUpForm.Field?>.Binding
    let field: AccessibleSignUpForm.Field
    var keyboardType: UIKeyboardType = .default
    var textContentType: UITextContentType?
    
    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Text(title)
                .font(.headline)
                .accessibilityHidden(true) // 레이블에 포함될 것이므로
            
            TextField(placeholder, text: $text)
                .textFieldStyle(.roundedBorder)
                .keyboardType(keyboardType)
                .textContentType(textContentType)
                .autocapitalization(.none)
                .disableAutocorrection(true)
                .focused(focusedField, equals: field)
                .accessibilityLabel("\(title) 입력")
                .accessibilityValue(text.isEmpty ? "비어있음" : text)
                .accessibilityHint("\(title)을 입력하세요")
        }
    }
}

// MARK: - 접근성 좋은 보안 필드
struct AccessibleSecureField: View {
    let title: String
    let placeholder: String
    @Binding var text: String
    var focusedField: FocusState<AccessibleSignUpForm.Field?>.Binding
    let field: AccessibleSignUpForm.Field
    
    @State private var isSecure = true
    
    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Text(title)
                .font(.headline)
                .accessibilityHidden(true)
            
            HStack {
                if isSecure {
                    SecureField(placeholder, text: $text)
                        .textFieldStyle(.roundedBorder)
                        .focused(focusedField, equals: field)
                } else {
                    TextField(placeholder, text: $text)
                        .textFieldStyle(.roundedBorder)
                        .focused(focusedField, equals: field)
                }
                
                Button(action: { isSecure.toggle() }) {
                    Image(systemName: isSecure ? "eye.slash" : "eye")
                        .foregroundColor(.gray)
                }
                .accessibilityLabel(isSecure ? "비밀번호 보기" : "비밀번호 숨기기")
                .accessibilityHint("두 번 탭하여 비밀번호 표시 상태를 변경하세요")
            }
            .accessibilityElement(children: .contain)
            .accessibilityLabel("\(title) 입력")
            .accessibilityValue(text.isEmpty ? "비어있음" : "입력됨")
        }
    }
}

// MARK: - 비밀번호 강도 표시기
struct PasswordStrengthIndicator: View {
    let password: String
    
    var strength: (level: Int, text: String, color: Color) {
        let length = password.count
        let hasUppercase = password.range(of: "[A-Z]", options: .regularExpression) != nil
        let hasLowercase = password.range(of: "[a-z]", options: .regularExpression) != nil
        let hasNumber = password.range(of: "[0-9]", options: .regularExpression) != nil
        let hasSpecial = password.range(of: "[^A-Za-z0-9]", options: .regularExpression) != nil
        
        var score = 0
        if length >= 8 { score += 1 }
        if length >= 12 { score += 1 }
        if hasUppercase && hasLowercase { score += 1 }
        if hasNumber { score += 1 }
        if hasSpecial { score += 1 }
        
        switch score {
        case 0...1: return (1, "약함", .red)
        case 2...3: return (2, "보통", .orange)
        case 4: return (3, "강함", .green)
        default: return (4, "매우 강함", .blue)
        }
    }
    
    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            HStack(spacing: 4) {
                ForEach(0..<4) { index in
                    Rectangle()
                        .fill(index < strength.level ? strength.color : Color.gray.opacity(0.3))
                        .frame(height: 4)
                }
            }
            
            Text("비밀번호 강도: \(strength.text)")
                .font(.caption)
                .foregroundColor(strength.color)
        }
        .accessibilityElement(children: .combine)
        .accessibilityLabel("비밀번호 강도: \(strength.text)")
        .accessibilityValue("4단계 중 \(strength.level)단계")
    }
}

// 테스트 체크리스트

✅ VoiceOver 테스트
- 모든 화면을 VoiceOver로 탐색 가능한가?
- 레이블이 명확하고 이해하기 쉬운가?
- 버튼과 링크가 명확히 구분되는가?
- 커스텀 액션이 제대로 작동하는가?

✅ 색상 및 대비 테스트
- 다크 모드에서도 잘 보이는가?
- 색맹 모드에서 정보를 구분할 수 있는가?
- 모든 텍스트가 WCAG AA 기준을 만족하는가?

✅ Dynamic Type 테스트
- 텍스트 크기를 최대로 키웠을 때 레이아웃이 깨지지 않는가?
- 모든 텍스트가 잘리지 않고 표시되는가?

✅ 키보드 내비게이션 테스트
- 외부 키보드로 모든 기능을 사용할 수 있는가?
- Tab 키로 논리적인 순서로 이동하는가?
- 포커스가 명확히 표시되는가?

✅ Switch Control 테스트
- 스위치 컨트롤로 앱을 사용할 수 있는가?
- 모든 인터랙티브 요소에 접근 가능한가?

import XCTest

class AccessibilityTests: XCTestCase {
    var app: XCUIApplication!
    
    override func setUp() {
        super.setUp()
        continueAfterFailure = false
        app = XCUIApplication()
        app.launch()
    }
    
    // 모든 버튼에 레이블이 있는지 확인
    func testAllButtonsHaveLabels() {
        let buttons = app.buttons.allElementsBoundByIndex
        
        for button in buttons {
            XCTAssertFalse(
                button.label.isEmpty,
                "버튼에 접근성 레이블이 없습니다: \(button)"
            )
        }
    }
    
    // 터치 영역 크기 확인
    func testButtonSizeIsAccessible() {
        let loginButton = app.buttons["로그인"]
        let frame = loginButton.frame
        
        XCTAssertGreaterThanOrEqual(
            frame.width,
            44,
            "버튼 너비가 최소 권장 크기(44pt)보다 작습니다"
        )
        XCTAssertGreaterThanOrEqual(
            frame.height,
            44,
            "버튼 높이가 최소 권장 크기(44pt)보다 작습니다"
        )
    }
    
    // VoiceOver로 화면 탐색 가능한지 확인
    func testVoiceOverNavigation() {
        // VoiceOver 활성화
        app.activate()
        
        let usernameField = app.textFields["사용자 이름 입력"]
        XCTAssertTrue(usernameField.exists)
        XCTAssertTrue(usernameField.isAccessibilityElement)
        
        let passwordField = app.secureTextFields["비밀번호 입력"]
        XCTAssertTrue(passwordField.exists)
        XCTAssertTrue(passwordField.isAccessibilityElement)
        
        let loginButton = app.buttons["로그인 버튼"]
        XCTAssertTrue(loginButton.exists)
        XCTAssertTrue(loginButton.isAccessibilityElement)
    }
    
    // 오류 메시지가 접근 가능한지 확인
    func testErrorMessageAccessibility() {
        let loginButton = app.buttons["로그인 버튼"]
        loginButton.tap()
        
        // 오류 메시지가 표시되는지 확인
        let errorAlert = app.alerts.firstMatch
        XCTAssertTrue(errorAlert.waitForExistence(timeout: 2))
        
        // 오류 메시지에 접근 가능한지 확인
        XCTAssertTrue(errorAlert.isAccessibilityElement)
        XCTAssertFalse(errorAlert.label.isEmpty)
    }
    
    // Dynamic Type 지원 확인
    func testDynamicTypeSupport() {
        // 큰 텍스트 크기로 설정
        app.launchArguments.append("-UIPreferredContentSizeCategoryName")
        app.launchArguments.append("UICTContentSizeCategoryAccessibilityExtraExtraExtraLarge")
        app.launch()
        
        let titleLabel = app.staticTexts["회원가입"]
        XCTAssertTrue(titleLabel.exists)
        
        // 텍스트가 잘리지 않았는지 확인
        XCTAssertFalse(titleLabel.label.isEmpty)
    }
}

// SwiftUI는 자동으로 RTL 지원!
HStack {
    Image(systemName: "arrow.right")
    Text("다음")
}
// RTL 언어에서는 자동으로 좌우가 뒤집힘

// 특정 요소만 RTL 적용 제외
Text("12345")
    .environment(\.layoutDirection, .leftToRight)

// UIKit에서 RTL 지원
let imageView = UIImageView()
imageView.image = UIImage(systemName: "arrow.right")?
    .withHorizontallyFlippedOrientation() // RTL에서 자동 뒤집기

// 레이아웃 제약 조건
// leading/trailing 사용 (left/right 대신)
label.leadingAnchor.constraint(equalTo: view.leadingAnchor)
label.trailingAnchor.constraint(equalTo: view.trailingAnchor)

// Localizable.strings
// en
"login.button.label" = "Log In";
"login.button.hint" = "Double tap to log in to your account";

// ko
"login.button.label" = "로그인";
"login.button.hint" = "두 번 탭하여 계정에 로그인하세요";

// ar (아랍어)
"login.button.label" = "تسجيل الدخول";
"login.button.hint" = "انقر نقرًا مزدوجًا لتسجيل الدخول";

// Swift 코드
button.accessibilityLabel = NSLocalizedString(
    "login.button.label",
    comment: "Login button accessibility label"
)
button.accessibilityHint = NSLocalizedString(
    "login.button.hint",
    comment: "Login button accessibility hint"
)

struct TalentSearchView: View {
    @State private var searchText = ""
    @State private var selectedCategory: Category?
    @State private var talents: [Talent] = []
    
    var body: some View {
        NavigationView {
            VStack(spacing: 0) {
                // 검색 바
                searchBar
                
                // 카테고리 필터
                categoryFilter
                
                // 검색 결과
                searchResults
            }
            .navigationTitle("재능 찾기")
        }
    }
    
    // MARK: - 검색 바
    var searchBar: some View {
        HStack {
            Image(systemName: "magnifyingglass")
                .foregroundColor(.gray)
                .accessibilityHidden(true) // 장식용 아이콘
            
            TextField("어떤 재능을 찾으시나요?", text: $searchText)
                .textFieldStyle(.plain)
                .accessibilityLabel("재능 검색")
                .accessibilityHint("찾고 싶은 재능의 키워드를 입력하세요")
            
            if !searchText.isEmpty {
                Button(action: { searchText = "" }) {
                    Image(systemName: "xmark.circle.fill")
                        .foregroundColor(.gray)
                }
                .accessibilityLabel("검색어 지우기")
                .accessibilityHint("두 번 탭하여 입력한 검색어를 지웁니다")
            }
        }
        .padding()
        .background(Color(.systemGray6))
        .cornerRadius(10)
        .padding(.horizontal)
    }
    
    // MARK: - 카테고리 필터
    var categoryFilter: some View {
        ScrollView(.horizontal, showsIndicators: false) {
            HStack(spacing: 12) {
                ForEach(Category.allCases) { category in
                    CategoryChip(
                        category: category,
                        isSelected: selectedCategory == category,
                        action: {
                            if selectedCategory == category {
                                selectedCategory = nil
                            } else {
                                selectedCategory = category
                            }
                        }
                    )
                }
            }
            .padding(.horizontal)
        }
        .accessibilityElement(children: .contain)
        .accessibilityLabel("카테고리 필터")
        .accessibilityHint("원하는 카테고리를 선택하여 검색 결과를 필터링하세요")
    }
    
    // MARK: - 검색 결과
    var searchResults: some View {
        ScrollView {
            LazyVStack(spacing: 16) {
                ForEach(talents) { talent in
                    TalentCard(talent: talent)
                }
            }
            .padding()
        }
        .accessibilityElement(children: .contain)
        .accessibilityLabel("검색 결과")
        .accessibilityValue("\(talents.count)개의 재능이 검색되었습니다")
    }
}

// MARK: - 카테고리 칩
struct CategoryChip: View {
    let category: Category
    let isSelected: Bool
    let action: () -> Void
    
    var body: some View {
        Button(action: action) {
            HStack(spacing: 6) {
                Text(category.icon)
                    .accessibilityHidden(true)
                Text(category.name)
                    .font(.subheadline)
            }
            .padding(.horizontal, 16)
            .padding(.vertical, 8)
            .background(
                Capsule()
                    .fill(isSelected ? Color.blue : Color(.systemGray5))
            )
            .foregroundColor(isSelected ? .white : .primary)
        }
        .accessibilityLabel(category.name)
        .accessibilityValue(isSelected ? "선택됨" : "선택 안 됨")
        .accessibilityHint("두 번 탭하여 \(category.name) 카테고리를 \(isSelected ? "선택 해제" : "선택")합니다")
        .accessibilityAddTraits(.isButton)
        .accessibilityRemoveTraits(isSelected ? [] : .isSelected)
        .accessibilityAddTraits(isSelected ? .isSelected : [])
    }
}

// MARK: - 재능 카드
struct TalentCard: View {
    let talent: Talent
    
    var body: some View {
        Button(action: { /* 상세 페이지로 이동 */ }) {
            HStack(spacing: 16) {
                // 프로필 이미지
                AsyncImage(url: talent.profileImageURL) { image in
                    image
                        .resizable()
                        .aspectRatio(contentMode: .fill)
                } placeholder: {
                    Color.gray
                }
                .frame(width: 80, height: 80)
                .clipShape(RoundedRectangle(cornerRadius: 12))
                .accessibilityHidden(true) // 이미지는 레이블에 포함
                
                VStack(alignment: .leading, spacing: 8) {
                    // 재능 제목
                    Text(talent.title)
                        .font(.headline)
                        .foregroundColor(.primary)
                        .lineLimit(2)
                    
                    // 제공자 정보
                    HStack(spacing: 4) {
                        Image(systemName: "person.fill")
                            .font(.caption)
                        Text(talent.providerName)
                            .font(.subheadline)
                    }
                    .foregroundColor(.secondary)
                    
                    // 평점
                    HStack(spacing: 4) {
                        Image(systemName: "star.fill")
                            .font(.caption)
                            .foregroundColor(.yellow)
                        Text(String(format: "%.1f", talent.rating))
                            .font(.subheadline)
                        Text("(\(talent.reviewCount))")
                            .font(.caption)
                            .foregroundColor(.secondary)
                    }
                    
                    // 가격
                    Text(talent.priceText)
                        .font(.headline)
                        .foregroundColor(.blue)
                }
                
                Spacer()
                
                // 찜하기 버튼
                Button(action: { /* 찜하기 토글 */ }) {
                    Image(systemName: talent.isFavorite ? "heart.fill" : "heart")
                        .font(.title3)
                        .foregroundColor(talent.isFavorite ? .red : .gray)
                }
                .accessibilityLabel(talent.isFavorite ? "찜 해제" : "찜하기")
                .accessibilityHint("두 번 탭하여 관심 목록에 \(talent.isFavorite ? "제거" : "추가")합니다")
            }
            .padding()
            .background(Color(.systemBackground))
            .cornerRadius(12)
            .shadow(color: Color.black.opacity(0.1), radius: 5, x: 0, y: 2)
        }
        .accessibilityElement(children: .combine)
        .accessibilityLabel("""
            \(talent.title). \
            제공자: \(talent.providerName). \
            평점: \(String(format: "%.1f", talent.rating))점, \
            리뷰 \(talent.reviewCount)개. \
            가격: \(talent.priceText)
            """)
        .accessibilityHint("두 번 탭하여 상세 정보를 확인하세요")
        .accessibilityAction(named: "찜하기") {
            // 찜하기 액션
        }
    }
}

// MARK: - 모델
struct Talent: Identifiable {
    let id: UUID
    let title: String
    let providerName: String
    let profileImageURL: URL?
    let rating: Double
    let reviewCount: Int
    let priceText: String
    var isFavorite: Bool
}

enum Category: String, CaseIterable, Identifiable {
    case design = "디자인"
    case programming = "프로그래밍"
    case writing = "글쓰기"
    case music = "음악"
    case video = "영상"
    case consulting = "컨설팅"
    
    var id: String { rawValue }
    
    var name: String { rawValue }
    
    var icon: String {
        switch self {
        case .design: return "🎨"
        case .programming: return "💻"
        case .writing: return "✍️"
        case .music: return "🎵"
        case .video: return "🎬"
        case .consulting: return "💼"
        }
    }
}

// Vision Framework를 활용한 이미지 설명 생성
import Vision

func generateImageDescription(for image: UIImage) {
    guard let cgImage = image.cgImage else { return }
    
    let request = VNRecognizeTextRequest { request, error in
        guard let observations = request.results as? [VNRecognizedTextObservation] else {
            return
        }
        
        let recognizedText = observations.compactMap { observation in
            observation.topCandidates(1).first?.string
        }.joined(separator: " ")
        
        // VoiceOver에 알림
        UIAccessibility.post(
            notification: .announcement,
            argument: "이미지에서 인식된 텍스트: \(recognizedText)"
        )
    }
    
    let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
    try? handler.perform([request])
}

// Core ML을 활용한 이미지 분류
import CoreML

func classifyImage(_ image: UIImage) async -> String? {
    // 사전 학습된 모델 사용
    guard let model = try? VNCoreMLModel(for: MobileNetV2().model) else {
        return nil
    }
    
    let request = VNCoreMLRequest(model: model)
    
    guard let cgImage = image.cgImage else { return nil }
    let handler = VNImageRequestHandler(cgImage: cgImage)
    
    try? handler.perform([request])
    
    guard let results = request.results as? [VNClassificationObservation],
          let topResult = results.first else {
        return nil
    }
    
    return "\(topResult.identifier), 신뢰도 \(Int(topResult.confidence * 100))%"
}