Módulo iPhone

// Atajos de teclado imprescindibles en Xcode
Cmd + R          → Compilar y ejecutar la app
Cmd + B          → Solo compilar (sin ejecutar)
Cmd + .          → Detener la ejecución
Cmd + Shift + K  → Limpiar la build (Clean Build Folder)
Cmd + /          → Comentar / descomentar línea
Ctrl + I         → Re-indentar código seleccionado
Cmd + 0          → Mostrar/ocultar Navigator
Cmd + Option + 0 → Mostrar/ocultar Inspector
Cmd + U          → Ejecutar todos los tests
Cmd + Shift + O  → Open Quickly (buscar archivo)

// Constante (inmutable) — usar siempre que sea posible
let nombre: String = "Ana García"
let edad = 28               // Swift infiere el tipo: Int

// Variable (mutable)
var puntuacion: Int = 0
var activo: Bool = true

// Optional — puede ser un valor o nil
var email: String? = nil
email = "ana@ejemplo.com"

// Optional binding — unwrap seguro
if let e = email {
    print("Email: \(e)")
}

// Guard let — early exit, código más limpio
func procesar(email: String?) {
    guard let e = email else { return }
    enviarCorreo(a: e)
}

// Nil coalescing — valor por defecto si nil
let texto = email ?? "sin email"

// Struct (tipo valor — se copia al asignar)
struct Producto {
    let id: UUID = UUID()
    var nombre: String
    var precio: Double
    
    // Computed property — se calcula, no se almacena
    var descripcion: String { "\(nombre) — \(precio)€" }
    
    mutating func aplicarDescuento(_ porcentaje: Double) {
        precio *= (1 - porcentaje)
    }
}

// Enum con valores asociados — muy potente
enum EstadoPedido {
    case pendiente
    case procesando(progreso: Double)
    case enviado(tracking: String)
    case entregado(fecha: Date)
    case cancelado(motivo: String)
}

// Protocolo — define un contrato
protocol Persistible {
    var id: UUID { get }
    func guardar() throws
}

// async/await — llamada de red sin callbacks
func obtenerUsuario(id: String) async throws -> Usuario {
    let url = URL(string: "https://api.ejemplo.com/users/\(id)")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode(Usuario.self, from: data)
}

// Uso en SwiftUI con .task
.task {
    do {
        usuario = try await obtenerUsuario(id: "123")
    } catch {
        errorMessage = error.localizedDescription
    }
}

// async let — paralelismo: ambas peticiones a la vez
async let perfil = obtenerPerfil(userId)
async let pedidos = obtenerPedidos(userId)
let (p, o) = try await (perfil, pedidos)

// Actor — protege datos con acceso concurrente seguro
actor ContadorSeguro {
    private var valor = 0
    func incrementar() { valor += 1 }
}

// Vista SwiftUI completa con @State
struct ContentView: View {
    @State private var contador = 0
    @State private var nombre = ""
    
    var body: some View {
        NavigationStack {
            VStack(spacing: 20) {
                Text("Contador: \(contador)")
                    .font(.largeTitle)
                    .foregroundStyle(.blue)
                
                HStack {
                    Button("-") { contador -= 1 }
                        .buttonStyle(.bordered)
                    Button("+") { contador += 1 }
                        .buttonStyle(.borderedProminent)
                }
                
                TextField("Tu nombre", text: $nombre)
                    .textFieldStyle(.roundedBorder)
                
                if !nombre.isEmpty {
                    Text("Hola, \(nombre)!")
                        .transition(.opacity)
                }
            }
            .navigationTitle("Mi App")
        }
    }
}

// ViewModel con @Observable (Swift 5.9, iOS 17+)
@Observable class UserViewModel {
    var users: [User] = []
    var isLoading = false
    var errorMessage: String?
    
    func loadUsers() async {
        isLoading = true
        defer { isLoading = false }
        do {
            users = try await UserService.fetchAll()
        } catch {
            errorMessage = error.localizedDescription
        }
    }
}

// Vista: solo renderiza, nunca contiene lógica
struct UsersView: View {
    @State private var vm = UserViewModel()
    
    var body: some View {
        Group {
            if vm.isLoading {
                ProgressView("Cargando...")
            } else {
                List(vm.users) { user in
                    Text(user.name)
                }
            }
        }
        .task { await vm.loadUsers() }
    }
}

// UIKit dentro de SwiftUI — UIViewRepresentable
struct MapaView: UIViewRepresentable {
    func makeUIView(context: Context) -> MKMapView {
        MKMapView(frame: .zero)
    }
    func updateUIView(_ uiView: MKMapView, context: Context) {
        // actualizar cuando cambia el estado SwiftUI
    }
}

// SwiftUI dentro de UIKit — UIHostingController
class MiViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        let hostingVC = UIHostingController(rootView: ContentView())
        addChild(hostingVC)
        view.addSubview(hostingVC.view)
        hostingVC.didMove(toParent: self)
    }
}