EventKit en SwiftUI

import Foundation
import EventKit

@MainActor
class CalendarManager: ObservableObject {
    // La única instancia del store que usaremos
    let store = EKEventStore()
    
    // Lista de eventos publicados para que SwiftUI reaccione
    @Published var events: [EKEvent] = []
    @Published var isAccessGranted: Bool = false
    
    // Método para solicitar permisos
    func requestAccess() async {
        do {
            // Solicitamos acceso completo para eventos
            let granted = try await store.requestFullAccessToEvents()
            self.isAccessGranted = granted
            
            if granted {
                fetchEvents()
            }
        } catch {
            print("Error al solicitar permisos del calendario: \(error.localizedDescription)")
            self.isAccessGranted = false
        }
    }
    
    // Método para obtener los eventos del próximo mes
    func fetchEvents() {
        guard isAccessGranted else { return }
        
        let calendars = store.calendars(for: .event)
        let now = Date()
        
        // Calculamos la fecha de dentro de 30 días
        guard let nextMonth = Calendar.current.date(byAdding: .day, value: 30, to: now) else { return }
        
        // Creamos un predicado (una consulta de búsqueda)
        let predicate = store.predicateForEvents(withStart: now, end: nextMonth, calendars: calendars)
        
        // Obtenemos los eventos y los asignamos a nuestra variable publicada
        self.events = store.events(matching: predicate)
    }
}

import SwiftUI
import EventKit

struct ContentView: View {
    @StateObject private var calendarManager = CalendarManager()
    
    var body: some View {
        NavigationView {
            Group {
                if calendarManager.isAccessGranted {
                    EventsListView(events: calendarManager.events)
                } else {
                    PermissionView(manager: calendarManager)
                }
            }
            .navigationTitle("Mi Agenda")
        }
        .task {
            // Verificamos el estado actual del permiso al cargar la vista
            let status = EKEventStore.authorizationStatus(for: .event)
            if status == .fullAccess {
                calendarManager.isAccessGranted = true
                calendarManager.fetchEvents()
            }
        }
    }
}

// Sub-vista para solicitar permisos
struct PermissionView: View {
    @ObservedObject var manager: CalendarManager
    
    var body: some View {
        VStack(spacing: 20) {
            Image(systemName: "calendar.badge.exclamationmark")
                .font(.system(size: 60))
                .foregroundColor(.orange)
            
            Text("Se requiere acceso al calendario")
                .font(.title2)
                .bold()
            
            Text("Para mostrar tus próximas citas, necesitamos tu permiso para leer el calendario.")
                .multilineTextAlignment(.center)
                .foregroundColor(.secondary)
                .padding(.horizontal)
            
            Button(action: {
                Task {
                    await manager.requestAccess()
                }
            }) {
                Text("Conceder Permiso")
                    .bold()
                    .frame(maxWidth: .infinity)
                    .padding()
                    .background(Color.blue)
                    .foregroundColor(.white)
                    .cornerRadius(10)
            }
            .padding(.horizontal, 40)
        }
    }
}

// Sub-vista para mostrar la lista de eventos
struct EventsListView: View {
    var events: [EKEvent]
    
    var body: some View {
        List {
            if events.isEmpty {
                Text("No tienes eventos próximos.")
                    .foregroundColor(.secondary)
            } else {
                ForEach(events, id: \.eventIdentifier) { event in
                    EventRowView(event: event)
                }
            }
        }
        // Recomendable para una buena experiencia de usuario en iOS
        .refreshable {
            // Aquí llamarías de nuevo a fetchEvents si estuviera directamente accesible
        }
    }
}

// Diseño individual de cada celda de evento
struct EventRowView: View {
    let event: EKEvent
    
    var body: some View {
        VStack(alignment: .leading, spacing: 5) {
            Text(event.title)
                .font(.headline)
            
            HStack {
                // Color del calendario
                Circle()
                    .fill(Color(event.calendar.cgColor))
                    .frame(width: 10, height: 10)
                
                Text(formatDate(event.startDate))
                    .font(.subheadline)
                    .foregroundColor(.secondary)
                
                Spacer()
                
                if let location = event.location, !location.isEmpty {
                    Image(systemName: "mappin.and.ellipse")
                        .foregroundColor(.red)
                        .font(.caption)
                }
            }
        }
        .padding(.vertical, 4)
    }
    
    private func formatDate(_ date: Date) -> String {
        let formatter = DateFormatter()
        formatter.dateStyle = .medium
        formatter.timeStyle = .short
        return formatter.string(from: date)
    }
}

extension CalendarManager {
    func addEvent(title: String, startDate: Date, endDate: Date) {
        let newEvent = EKEvent(eventStore: self.store)
        newEvent.title = title
        newEvent.startDate = startDate
        newEvent.endDate = endDate
        
        // Asignamos el calendario por defecto del usuario
        newEvent.calendar = store.defaultCalendarForNewEvents
        
        do {
            try store.save(newEvent, span: .thisEvent)
            print("Evento guardado con éxito")
            // Refrescamos la lista para mostrar el nuevo evento
            fetchEvents() 
        } catch {
            print("Error al guardar el evento: \(error.localizedDescription)")
        }
    }
}

import SwiftUI
import EventKitUI

struct EventEditViewController: UIViewControllerRepresentable {
    let eventStore: EKEventStore
    let event: EKEvent?
    @Environment(\.presentationMode) var presentationMode
    
    func makeUIViewController(context: Context) -> EKEventEditViewController {
        let controller = EKEventEditViewController()
        controller.eventStore = eventStore
        
        if let event = event {
            controller.event = event
        }
        
        controller.editViewDelegate = context.coordinator
        return controller
    }
    
    func updateUIViewController(_ uiViewController: EKEventEditViewController, context: Context) {}
    
    func makeCoordinator() -> Coordinator {
        Coordinator(self)
    }
    
    class Coordinator: NSObject, EKEventEditViewDelegate {
        var parent: EventEditViewController
        
        init(_ parent: EventEditViewController) {
            self.parent = parent
        }
        
        func eventEditViewController(_ controller: EKEventEditViewController, didCompleteWith action: EKEventEditViewAction) {
            parent.presentationMode.wrappedValue.dismiss()
            // Aquí podrías notificar a tu CalendarManager para hacer un fetchEvents()
        }
    }
}

// ... dentro de tu ContentView
@State private var showingAddEvent = false

// ... en el botón de la barra de navegación:
.toolbar {
    Button(action: { showingAddEvent = true }) {
        Image(systemName: "plus")
    }
}
.sheet(isPresented: $showingAddEvent, onDismiss: {
    calendarManager.fetchEvents()
}) {
    EventEditViewController(eventStore: calendarManager.store, event: nil)
}

// En tu archivo de vista...
.toolbar {
    Button(action: { showingAddEvent = true }) {
        Image(systemName: "plus")
    }
}
#if os(iOS)
.sheet(isPresented: $showingAddEvent) {
    EventEditViewController(eventStore: calendarManager.store, event: nil)
}
#elseif os(watchOS)
.sheet(isPresented: $showingAddEvent) {
    // Para watchOS, debes crear tu propio formulario en SwiftUI
    CustomWatchEventForm(manager: calendarManager)
}
#endif

import Combine

class CalendarManager: ObservableObject {
    // ... propiedades anteriores ...
    private var cancellables = Set<AnyCancellable>()
    
    init() {
        // Escuchamos los cambios en la base de datos de EventKit
        NotificationCenter.default.publisher(for: .EKEventStoreChanged, object: store)
            // Aseguramos que recibimos la actualización en el hilo principal
            .receive(on: RunLoop.main) 
            .sink { [weak self] _ in
                // Si la base de datos externa cambia, recargamos nuestra lista
                self?.fetchEvents()
            }
            .store(in: &cancellables)
    }
    // ... resto del código ...
}