// build.gradle.kts
dependencies {
    // Core CalDAV client (includes iCalendar parsing)
    implementation("io.github.icaldav:caldav-core:1.0.0")

    // Optional: Sync engine with offline support and conflict resolution
    implementation("io.github.icaldav:caldav-sync:1.0.0")

    // Optional: ICS subscription fetcher for read-only calendar feeds
    implementation("io.github.icaldav:ics-subscription:1.0.0")
}

val client = CalDavClient.forProvider(
    serverUrl = "https://caldav.icloud.com",
    username = "user@icloud.com",
    password = "app-specific-password"  // Use app-specific password for iCloud
)

when (val result = client.discoverAccount("https://caldav.icloud.com")) {
    is DavResult.Success -> {
        val account = result.value
        println("Found ${account.calendars.size} calendars:")
        account.calendars.forEach { calendar ->
            println("  - ${calendar.displayName} (${calendar.href})")
        }
    }
    is DavResult.HttpError -> println("HTTP ${result.code}: ${result.message}")
    is DavResult.NetworkError -> println("Network error: ${result.exception.message}")
    is DavResult.ParseError -> println("Parse error: ${result.message}")
}

// Create an event
val event = ICalEvent(
    uid = UUID.randomUUID().toString(),
    summary = "Team Meeting",
    description = "Weekly sync",
    dtStart = ICalDateTime.fromInstant(Instant.now()),
    dtEnd = ICalDateTime.fromInstant(Instant.now().plus(1, ChronoUnit.HOURS)),
    location = "Conference Room A"
)

val createResult = client.createEvent(calendarUrl, event)
if (createResult is DavResult.Success) {
    val (href, etag) = createResult.value
    println("Created event at $href")

    // Update the event
    val updated = event.copy(summary = "Team Meeting (Updated)")
    client.updateEvent(href, updated, etag)

    // Delete the event
    client.deleteEvent(href, etag)
}

// Fetch events in a date range
val events = client.fetchEvents(
    calendarUrl = calendarUrl,
    start = Instant.now(),
    end = Instant.now().plus(30, ChronoUnit.DAYS)
)

// Fetch specific events by URL
val specific = client.fetchEventsByHref(calendarUrl, listOf(href1, href2))

// Fetch only ETags for efficient change detection (96% less bandwidth)
val etags = client.fetchEtagsInRange(calendarUrl, start, end)

// Instead of fetching full events (expensive)
val events = client.fetchEvents(calendarUrl, start, end)

// Fetch only etags (96% smaller response)
val serverEtags = client.fetchEtagsInRange(calendarUrl, start, end)

// Compare with local etags to find changes
val changedHrefs = serverEtags
    .filter { it.etag != localEtags[it.href] }
    .map { it.href }

// Fetch only changed events
val changedEvents = client.fetchEventsByHref(calendarUrl, changedHrefs)

// Auto-detects provider from URL
val client = CalDavClient.forProvider(serverUrl, username, password)

// Or explicitly specify
val client = CalDavClient(
    webDavClient = webDavClient,
    quirks = ICloudQuirks()
)

val engine = SyncEngine(client)

// Initial sync (full fetch)
val result = engine.sync(
    calendarUrl = calendarUrl,
    previousState = SyncState.initial(calendarUrl),
    localProvider = myLocalProvider,
    handler = myResultHandler
)

// Incremental sync (only changes since last sync)
val result = engine.syncWithIncremental(
    calendarUrl = calendarUrl,
    previousState = savedSyncState,
    localProvider = myLocalProvider,
    handler = myResultHandler,
    forceFullSync = false
)

// Save state for next sync
saveSyncState(result.newState)

val syncEngine = CalDavSyncEngine(client, localProvider, handler, pendingStore)

// Queue local changes (works offline)
syncEngine.queueCreate(calendarUrl, newEvent)
syncEngine.queueUpdate(modifiedEvent, eventUrl, etag)
syncEngine.queueDelete(eventUid, eventUrl, etag)

// Push to server when online
val pushResult = syncEngine.push()

// Automatic resolution
syncEngine.resolveConflict(operation, ConflictStrategy.SERVER_WINS)
syncEngine.resolveConflict(operation, ConflictStrategy.LOCAL_WINS)
syncEngine.resolveConflict(operation, ConflictStrategy.NEWEST_WINS)

// Manual resolution
syncEngine.resolveConflict(operation, ConflictStrategy.MANUAL) { local, server ->
    // Return merged event
    mergeEvents(local, server)
}

val parser = ICalParser()

// Parse iCalendar string
when (val result = parser.parseAllEvents(icalString)) {
    is ParseResult.Success -> {
        result.value.forEach { event ->
            println("${event.summary} at ${event.dtStart}")
        }
    }
    is ParseResult.Error -> println("Parse error: ${result.message}")
}

// Generate iCalendar string
val generator = ICalGenerator()
val icalString = generator.generate(event)

// UTC time
ICalDateTime.fromInstant(Instant.now())

// With timezone
ICalDateTime.fromZonedDateTime(ZonedDateTime.now(ZoneId.of("America/New_York")))

// All-day event
ICalDateTime.fromLocalDate(LocalDate.now())

// Floating time (device timezone)
ICalDateTime.floating(LocalDateTime.now())

val client = CalDavClient.withBasicAuth(username, password)

val client = CalDavClient(
    webDavClient = WebDavClient(httpClient, DavAuth.Bearer(accessToken)),
    quirks = GoogleQuirks()
)

sealed class DavResult<out T> {
    data class Success<T>(val value: T) : DavResult<T>()
    data class HttpError(val code: Int, val message: String) : DavResult<Nothing>()
    data class NetworkError(val exception: Exception) : DavResult<Nothing>()
    data class ParseError(val message: String) : DavResult<Nothing>()
}

// Usage
when (val result = client.fetchEvents(calendarUrl, start, end)) {
    is DavResult.Success -> handleEvents(result.value)
    is DavResult.HttpError -> when (result.code) {
        401 -> promptReauth()
        403, 410 -> handleExpiredSyncToken()  // Re-sync needed
        404 -> handleNotFound()
        412 -> handleConflict()  // ETag mismatch
        429 -> handleRateLimit()
        else -> handleError(result)
    }
    is DavResult.NetworkError -> showOfflineMessage()
    is DavResult.ParseError -> reportBug(result.message)
}

// build.gradle.kts (app module)
dependencies {
    implementation("io.github.icaldav:caldav-core:1.0.0")
    implementation("io.github.icaldav:caldav-sync:1.0.0")
}

class CalendarSyncWorker(
    context: Context,
    params: WorkerParameters
) : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
        try {
            val client = CalDavClient.forProvider(serverUrl, username, password)
            val engine = SyncEngine(client)

            val result = engine.syncWithIncremental(
                calendarUrl = calendarUrl,
                previousState = loadSyncState(),
                localProvider = localProvider,
                handler = resultHandler
            )

            if (result.success) {
                saveSyncState(result)
                Result.success()
            } else {
                Result.retry()
            }
        } catch (e: Exception) {
            Result.retry()
        }
    }
}

// Schedule periodic sync
val syncRequest = PeriodicWorkRequestBuilder<CalendarSyncWorker>(
    repeatInterval = 15,
    repeatIntervalTimeUnit = TimeUnit.MINUTES
).setConstraints(
    Constraints.Builder()
        .setRequiredNetworkType(NetworkType.CONNECTED)
        .build()
).build()

WorkManager.getInstance(context).enqueueUniquePeriodicWork(
    "calendar_sync",
    ExistingPeriodicWorkPolicy.KEEP,
    syncRequest
)

val client = IcsSubscriptionClient()

// Fetch with ETag caching
val result = client.fetch(
    url = "webcal://example.com/calendar.ics",
    previousEtag = savedEtag
)

when (result) {
    is IcsResult.Success -> {
        saveEtag(result.etag)
        processEvents(result.events)
    }
    is IcsResult.NotModified -> println("No changes")
    is IcsResult.Error -> println("Error: ${result.message}")
}

when (val result = client.syncCollection(calendarUrl, syncToken)) {
    is DavResult.HttpError -> if (result.code == 403 || result.code == 410) {
        // Sync token expired, perform full sync
        client.fetchEvents(calendarUrl)
    }
}

suspend fun fetchWithRetry(href: String, maxRetries: Int = 3): EventWithMetadata? {
    repeat(maxRetries) { attempt ->
        val result = client.fetchEventsByHref(calendarUrl, listOf(href))
        if (result is DavResult.Success && result.value.isNotEmpty()) {
            return result.value.first()
        }
        delay(100L * (1 shl attempt))  // 100ms, 200ms, 400ms
    }
    return null
}

val client = CalDavClient(
    webDavClient = WebDavClient(httpClient, DavAuth.Bearer(refreshedToken)),
    quirks = GoogleQuirks()
)

// Fetch in chunks
val chunks = generateDateRanges(start, end, chunkSizeDays = 30)
val allEvents = chunks.flatMap { (chunkStart, chunkEnd) ->
    client.fetchEvents(calendarUrl, chunkStart, chunkEnd)
        .getOrNull() ?: emptyList()
}