// build.gradle (Module)
dependencies {
    // Retrofit
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    
    // Gson 컨버터 (JSON 파싱용)
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
    
    // OkHttp (Retrofit이 내부적으로 사용)
    implementation 'com.squareup.okhttp3:okhttp:4.11.0'
    implementation 'com.squareup.okhttp3:logging-interceptor:4.11.0'
}

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

interface UserApiService {
    
    @GET("users/{id}")
    suspend fun getUser(@Path("id") userId: Int): Response<User>
    
    @GET("users")
    suspend fun getUserList(
        @Query("page") page: Int,
        @Query("per_page") perPage: Int
    ): Response<List<User>>
    
    @POST("users")
    suspend fun createUser(@Body user: User): Response<User>
    
    @PUT("users/{id}")
    suspend fun updateUser(
        @Path("id") userId: Int,
        @Body user: User
    ): Response<User>
    
    @DELETE("users/{id}")
    suspend fun deleteUser(@Path("id") userId: Int): Response<Unit>
}

object RetrofitClient {
    
    private const val BASE_URL = "https://api.example.com/"
    
    private val loggingInterceptor = HttpLoggingInterceptor().apply {
        level = HttpLoggingInterceptor.Level.BODY
    }
    
    private val okHttpClient = OkHttpClient.Builder()
        .addInterceptor(loggingInterceptor)
        .connectTimeout(30, TimeUnit.SECONDS)
        .readTimeout(30, TimeUnit.SECONDS)
        .writeTimeout(30, TimeUnit.SECONDS)
        .build()
    
    private val retrofit = Retrofit.Builder()
        .baseUrl(BASE_URL)
        .client(okHttpClient)
        .addConverterFactory(GsonConverterFactory.create())
        .build()
    
    val userApiService: UserApiService = retrofit.create(UserApiService::class.java)
}

class UserViewModel : ViewModel() {
    
    private val _userState = MutableLiveData<UiState<User>>()
    val userState: LiveData<UiState<User>> = _userState
    
    fun fetchUser(userId: Int) {
        viewModelScope.launch {
            _userState.value = UiState.Loading
            
            try {
                val response = RetrofitClient.userApiService.getUser(userId)
                
                if (response.isSuccessful) {
                    response.body()?.let { user ->
                        _userState.value = UiState.Success(user)
                    } ?: run {
                        _userState.value = UiState.Error("응답 본문이 비어있습니다")
                    }
                } else {
                    _userState.value = UiState.Error("에러 코드: ${response.code()}")
                }
            } catch (e: Exception) {
                _userState.value = UiState.Error(e.message ?: "알 수 없는 오류")
            }
        }
    }
    
    fun createUser(name: String, email: String) {
        viewModelScope.launch {
            try {
                val newUser = User(name = name, email = email)
                val response = RetrofitClient.userApiService.createUser(newUser)
                
                if (response.isSuccessful) {
                    // 성공 처리
                    Log.d("UserViewModel", "사용자 생성 성공: ${response.body()}")
                }
            } catch (e: Exception) {
                Log.e("UserViewModel", "사용자 생성 실패", e)
            }
        }
    }
}

sealed class UiState<out T> {
    object Loading : UiState<Nothing>()
    data class Success<T>(val data: T) : UiState<T>()
    data class Error(val message: String) : UiState<Nothing>()
}

# Podfile
platform :ios, '13.0'
use_frameworks!

target 'YourApp' do
  pod 'Alamofire', '~> 5.8'
end

github "Alamofire/Alamofire" ~> 5.8

import Alamofire

// 간단한 GET 요청
AF.request("https://api.example.com/users")
    .responseJSON { response in
        switch response.result {
        case .success(let value):
            print("응답 성공: \(value)")
        case .failure(let error):
            print("에러 발생: \(error)")
        }
    }

// Decodable을 사용한 자동 파싱
struct User: Decodable {
    let id: Int
    let name: String
    let email: String
}

AF.request("https://api.example.com/users/1")
    .responseDecodable(of: User.self) { response in
        switch response.result {
        case .success(let user):
            print("사용자 이름: \(user.name)")
        case .failure(let error):
            print("파싱 에러: \(error)")
        }
    }

// POST 요청
let parameters: [String: Any] = [
    "name": "홍길동",
    "email": "hong@example.com",
    "age": 25
]

AF.request("https://api.example.com/users",
           method: .post,
           parameters: parameters,
           encoding: JSONEncoding.default)
    .responseDecodable(of: User.self) { response in
        // 응답 처리
    }

// PUT 요청
AF.request("https://api.example.com/users/1",
           method: .put,
           parameters: parameters,
           encoding: JSONEncoding.default)
    .response { response in
        // 응답 처리
    }

// DELETE 요청
AF.request("https://api.example.com/users/1",
           method: .delete)
    .response { response in
        if response.response?.statusCode == 204 {
            print("삭제 성공!")
        }
    }

// 헤더 추가
let headers: HTTPHeaders = [
    "Authorization": "Bearer your_token_here",
    "Content-Type": "application/json",
    "Accept": "application/json"
]

AF.request("https://api.example.com/protected",
           headers: headers)
    .responseJSON { response in
        // 응답 처리
    }

// Interceptor를 사용한 자동 토큰 추가
class AuthenticationInterceptor: RequestInterceptor {
    
    func adapt(_ urlRequest: URLRequest, 
               for session: Session, 
               completion: @escaping (Result<URLRequest, Error>) -> Void) {
        var urlRequest = urlRequest
        
        // 토큰 가져오기 (예: Keychain에서)
        if let token = getAccessToken() {
            urlRequest.setValue("Bearer \(token)", 
                              forHTTPHeaderField: "Authorization")
        }
        
        completion(.success(urlRequest))
    }
    
    func retry(_ request: Request, 
               for session: Session, 
               dueTo error: Error, 
               completion: @escaping (RetryResult) -> Void) {
        
        // 401 에러면 토큰 갱신 후 재시도
        if let response = request.task?.response as? HTTPURLResponse,
           response.statusCode == 401 {
            refreshToken { success in
                completion(success ? .retry : .doNotRetry)
            }
        } else {
            completion(.doNotRetry)
        }
    }
    
    private func getAccessToken() -> String? {
        // 실제로는 Keychain이나 UserDefaults에서 가져옴
        return "your_access_token"
    }
    
    private func refreshToken(completion: @escaping (Bool) -> Void) {
        // 토큰 갱신 로직
        completion(true)
    }
}

// Session에 Interceptor 적용
let interceptor = AuthenticationInterceptor()
let session = Session(interceptor: interceptor)

session.request("https://api.example.com/protected")
    .responseJSON { response in
        // 자동으로 토큰이 추가되고, 401 에러 시 재시도됨
    }

class UserRepository(private val apiService: UserApiService) {
    
    // Flow를 사용한 반응형 데이터 스트림
    fun getUserFlow(userId: Int): Flow<Result<User>> = flow {
        emit(Result.Loading)
        
        try {
            val response = apiService.getUser(userId)
            if (response.isSuccessful) {
                response.body()?.let {
                    emit(Result.Success(it))
                } ?: emit(Result.Error("데이터 없음"))
            } else {
                emit(Result.Error("HTTP ${response.code()}"))
            }
        } catch (e: Exception) {
            emit(Result.Error(e.message ?: "알 수 없는 오류"))
        }
    }.flowOn(Dispatchers.IO)
    
    // 여러 API를 병렬로 호출
    suspend fun getUserWithPosts(userId: Int): Pair<User?, List<Post>?> {
        return coroutineScope {
            val userDeferred = async { apiService.getUser(userId) }
            val postsDeferred = async { apiService.getUserPosts(userId) }
            
            val user = userDeferred.await().body()
            val posts = postsDeferred.await().body()
            
            Pair(user, posts)
        }
    }
    
    // 순차적 API 호출
    suspend fun createUserAndProfile(user: User, profile: Profile): Result<Boolean> {
        return try {
            // 1. 사용자 생성
            val userResponse = apiService.createUser(user)
            if (!userResponse.isSuccessful) {
                return Result.Error("사용자 생성 실패")
            }
            
            val createdUser = userResponse.body() ?: return Result.Error("응답 없음")
            
            // 2. 프로필 생성 (사용자 ID 필요)
            val profileResponse = apiService.createProfile(createdUser.id, profile)
            if (profileResponse.isSuccessful) {
                Result.Success(true)
            } else {
                Result.Error("프로필 생성 실패")
            }
        } catch (e: Exception) {
            Result.Error(e.message ?: "알 수 없는 오류")
        }
    }
}

sealed class Result<out T> {
    object Loading : Result<Nothing>()
    data class Success<T>(val data: T) : Result<T>()
    data class Error(val message: String) : Result<Nothing>()
}

class UserService {
    
    // async/await를 사용한 간단한 요청
    func fetchUser(id: Int) async throws -> User {
        let response = await AF.request("https://api.example.com/users/\(id)")
            .serializingDecodable(User.self)
            .response
        
        switch response.result {
        case .success(let user):
            return user
        case .failure(let error):
            throw error
        }
    }
    
    // 여러 API를 병렬로 호출
    func fetchUserWithPosts(id: Int) async throws -> (User, [Post]) {
        async let user = fetchUser(id: id)
        async let posts = fetchPosts(userId: id)
        
        return try await (user, posts)
    }
    
    // Task Group을 사용한 다중 요청
    func fetchMultipleUsers(ids: [Int]) async throws -> [User] {
        try await withThrowingTaskGroup(of: User.self) { group in
            for id in ids {
                group.addTask {
                    try await self.fetchUser(id: id)
                }
            }
            
            var users: [User] = []
            for try await user in group {
                users.append(user)
            }
            return users
        }
    }
    
    private func fetchPosts(userId: Int) async throws -> [Post] {
        let response = await AF.request("https://api.example.com/users/\(userId)/posts")
            .serializingDecodable([Post].self)
            .response
        
        switch response.result {
        case .success(let posts):
            return posts
        case .failure(let error):
            throw error
        }
    }
}

// SwiftUI에서 사용
struct UserView: View {
    @State private var user: User?
    @State private var isLoading = false
    @State private var errorMessage: String?
    
    let userService = UserService()
    
    var body: some View {
        VStack {
            if isLoading {
                ProgressView()
            } else if let user = user {
                Text(user.name)
                Text(user.email)
            } else if let error = errorMessage {
                Text("에러: \(error)")
            }
        }
        .task {
            await loadUser()
        }
    }
    
    func loadUser() async {
        isLoading = true
        defer { isLoading = false }
        
        do {
            user = try await userService.fetchUser(id: 1)
        } catch {
            errorMessage = error.localizedDescription
        }
    }
}

// Retrofit - OkHttp 캐시 설정
val cacheSize = 10 * 1024 * 1024 // 10 MB
val cache = Cache(context.cacheDir, cacheSize.toLong())

val okHttpClient = OkHttpClient.Builder()
    .cache(cache)
    .addInterceptor { chain ->
        var request = chain.request()
        
        // 네트워크가 있으면 캐시를 5분간 유지
        // 없으면 7일간 유지
        request = if (hasNetwork(context)) {
            request.newBuilder()
                .header("Cache-Control", "public, max-age=" + 300)
                .build()
        } else {
            request.newBuilder()
                .header("Cache-Control", "public, only-if-cached, max-stale=" + 60 * 60 * 24 * 7)
                .build()
        }
        
        chain.proceed(request)
    }
    .build()

// Alamofire - URLCache 설정
let configuration = URLSessionConfiguration.default
configuration.requestCachePolicy = .returnCacheDataElseLoad
configuration.urlCache = URLCache(
    memoryCapacity: 10 * 1024 * 1024,  // 10 MB
    diskCapacity: 50 * 1024 * 1024,    // 50 MB
    diskPath: "alamofire_cache"
)

let session = Session(configuration: configuration)

// OkHttp는 자동으로 gzip 압축을 지원해
// Accept-Encoding: gzip 헤더를 자동으로 추가함

// 수동으로 압축 인터셉터 추가
class GzipRequestInterceptor : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        val originalRequest = chain.request()
        
        if (originalRequest.body == null || 
            originalRequest.header("Content-Encoding") != null) {
            return chain.proceed(originalRequest)
        }
        
        val compressedRequest = originalRequest.newBuilder()
            .header("Content-Encoding", "gzip")
            .method(originalRequest.method, gzip(originalRequest.body!!))
            .build()
        
        return chain.proceed(compressedRequest)
    }
    
    private fun gzip(body: RequestBody): RequestBody {
        return object : RequestBody() {
            override fun contentType() = body.contentType()
            
            override fun contentLength() = -1L
            
            override fun writeTo(sink: BufferedSink) {
                val gzipSink = GzipSink(sink).buffer()
                body.writeTo(gzipSink)
                gzipSink.close()
            }
        }
    }
}

// 나쁜 예: 여러 번 요청
for (id in userIds) {
    val user = apiService.getUser(id)
    // 처리...
}

// 좋은 예: 한 번에 요청
val users = apiService.getUsers(userIds)

// API 인터페이스
interface UserApiService {
    @GET("users/batch")
    suspend fun getUsers(@Query("ids") ids: List<Int>): Response<List<User>>
}

// Retrofit 페이지네이션
interface PostApiService {
    @GET("posts")
    suspend fun getPosts(
        @Query("page") page: Int,
        @Query("limit") limit: Int = 20
    ): Response<PostResponse>
}

data class PostResponse(
    val posts: List<Post>,
    val totalPages: Int,
    val currentPage: Int
)

// ViewModel에서 사용
class PostViewModel : ViewModel() {
    private var currentPage = 1
    private val _posts = MutableLiveData<List<Post>>()
    val posts: LiveData<List<Post>> = _posts
    
    fun loadMorePosts() {
        viewModelScope.launch {
            val response = apiService.getPosts(currentPage)
            if (response.isSuccessful) {
                response.body()?.let { postResponse ->
                    val currentList = _posts.value.orEmpty()
                    _posts.value = currentList + postResponse.posts
                    currentPage++
                }
            }
        }
    }
}

// network_security_config.xml
<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
    <base-config cleartextTrafficPermitted="false">
        <trust-anchors>
            <certificates src="system" />
        </trust-anchors>
    </base-config>
</network-security-config>

// AndroidManifest.xml
<application
    android:networkSecurityConfig="@xml/network_security_config"
    ...>

// OkHttp SSL Pinning
val hostname = "api.example.com"
val certificatePinner = CertificatePinner.Builder()
    .add(hostname, "sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=")
    .add(hostname, "sha256/BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB=")
    .build()

val okHttpClient = OkHttpClient.Builder()
    .certificatePinner(certificatePinner)
    .build()

// Alamofire SSL Pinning
let evaluators = [
    "api.example.com": PinnedCertificatesTrustEvaluator()
]

let serverTrustManager = ServerTrustManager(evaluators: evaluators)
let session = Session(serverTrustManager: serverTrustManager)

// 안드로이드 - Keystore 사용
class SecureStorage(private val context: Context) {
    
    private val keyStore = KeyStore.getInstance("AndroidKeyStore").apply {
        load(null)
    }
    
    fun saveToken(token: String) {
        val cipher = getCipher()
        val encryptedToken = cipher.doFinal(token.toByteArray())
        
        context.getSharedPreferences("secure_prefs", Context.MODE_PRIVATE)
            .edit()
            .putString("token", Base64.encodeToString(encryptedToken, Base64.DEFAULT))
            .apply()
    }
    
    fun getToken(): String? {
        val encryptedToken = context.getSharedPreferences("secure_prefs", Context.MODE_PRIVATE)
            .getString("token", null) ?: return null
        
        val cipher = getCipher()
        val decryptedToken = cipher.doFinal(Base64.decode(encryptedToken, Base64.DEFAULT))
        
        return String(decryptedToken)
    }
    
    private fun getCipher(): Cipher {
        // Cipher 초기화 로직
        return Cipher.getInstance("AES/GCM/NoPadding")
    }
}

// iOS - Keychain 사용
import Security

class KeychainManager {
    
    func save(token: String, for key: String) -> Bool {
        guard let data = token.data(using: .utf8) else { return false }
        
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: key,
            kSecValueData as String: data
        ]
        
        SecItemDelete(query as CFDictionary)
        
        let status = SecItemAdd(query as CFDictionary, nil)
        return status == errSecSuccess
    }
    
    func get(for key: String) -> String? {
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: key,
            kSecReturnData as String: true
        ]
        
        var result: AnyObject?
        let status = SecItemCopyMatching(query as CFDictionary, &result)
        
        guard status == errSecSuccess,
              let data = result as? Data,
              let token = String(data: data, encoding: .utf8) else {
            return nil
        }
        
        return token
    }
}

// Retrofit with GraphQL
interface GraphQLApiService {
    @POST("graphql")
    suspend fun query(@Body request: GraphQLRequest): Response<GraphQLResponse>
}

data class GraphQLRequest(
    val query: String,
    val variables: Map<String, Any>? = null
)

data class GraphQLResponse(
    val data: JsonObject?,
    val errors: List<GraphQLError>?
)

// 사용 예제
val query = """
    query GetUser(${'$'}id: ID!) {
        user(id: ${'$'}id) {
            id
            name
            email
            posts {
                title
                content
            }
        }
    }
""".trimIndent()

val variables = mapOf("id" to "123")
val request = GraphQLRequest(query, variables)
val response = apiService.query(request)

// OkHttp WebSocket
class WebSocketManager {
    
    private var webSocket: WebSocket? = null
    private val client = OkHttpClient()
    
    fun connect(url: String, listener: WebSocketListener) {
        val request = Request.Builder()
            .url(url)
            .build()
        
        webSocket = client.newWebSocket(request, listener)
    }
    
    fun send(message: String) {
        webSocket?.send(message)
    }
    
    fun close() {
        webSocket?.close(1000, "Goodbye")
    }
}

// 사용 예제
val listener = object : WebSocketListener() {
    override fun onOpen(webSocket: WebSocket, response: Response) {
        println("연결됨!")
    }
    
    override fun onMessage(webSocket: WebSocket, text: String) {
        println("메시지 수신: $text")
    }
    
    override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
        println("에러: ${t.message}")
    }
}

val wsManager = WebSocketManager()
wsManager.connect("wss://echo.websocket.org", listener)

// Retrofit 파일 업로드
interface FileApiService {
    @Multipart
    @POST("upload")
    suspend fun uploadFile(
        @Part file: MultipartBody.Part,
        @Part("description") description: RequestBody
    ): Response<UploadResponse>
}

// 사용 예제
fun uploadImage(uri: Uri) {
    viewModelScope.launch {
        val file = File(uri.path!!)
        val requestFile = file.asRequestBody("image/*".toMediaTypeOrNull())
        val body = MultipartBody.Part.createFormData("file", file.name, requestFile)
        val description = "프로필 사진".toRequestBody("text/plain".toMediaTypeOrNull())
        
        val response = apiService.uploadFile(body, description)
        // 처리...
    }
}

// Alamofire 파일 업로드 with Progress
AF.upload(
    multipartFormData: { multipartFormData in
        if let imageData = image.jpegData(compressionQuality: 0.8) {
            multipartFormData.append(
                imageData,
                withName: "file",
                fileName: "image.jpg",
                mimeType: "image/jpeg"
            )
        }
    },
    to: "https://api.example.com/upload"
)
.uploadProgress { progress in
    print("업로드 진행률: \(progress.fractionCompleted * 100)%")
}
.responseDecodable(of: UploadResponse.self) { response in
    switch response.result {
    case .success(let uploadResponse):
        print("업로드 성공: \(uploadResponse)")
    case .failure(let error):
        print("업로드 실패: \(error)")
    }
}