dependencies {
    // Core iCalendar parsing (required)
    implementation("io.github.icaldav:icalendar-core:1.0.0")

    // CalDAV client (includes webdav-core)
    implementation("io.github.icaldav:caldav-core:1.0.0")

    // Sync engine (optional)
    implementation("io.github.icaldav:caldav-sync:1.0.0")

    // ICS subscriptions (optional)
    implementation("io.github.icaldav:ics-subscription:1.0.0")
}

import com.icalendar.core.parser.ICalParser

val icsContent = """
    BEGIN:VCALENDAR
    VERSION:2.0
    BEGIN:VEVENT
    UID:event-123
    DTSTART:20241215T100000Z
    DTEND:20241215T110000Z
    SUMMARY:Team Meeting
    END:VEVENT
    END:VCALENDAR
""".trimIndent()

val result = ICalParser.parse(icsContent)
when (result) {
    is ParseResult.Success -> {
        result.events.forEach { event ->
            println("${event.summary} at ${event.dtStart}")
        }
    }
    is ParseResult.Error -> println("Parse error: ${result.message}")
}

import com.icalendar.core.generator.ICalGenerator
import com.icalendar.core.model.*

val event = ICalEvent(
    uid = "event-123",
    importId = "event-123",
    summary = "Team Meeting",
    dtStart = ICalDateTime.now(),
    dtEnd = ICalDateTime.now().plusHours(1),
    status = EventStatus.CONFIRMED,
    transparency = Transparency.OPAQUE,
    // ... other properties
)

val icsContent = ICalGenerator.generate(listOf(event))

import com.icalendar.core.recurrence.RRuleExpander
import com.icalendar.core.model.RRule
import com.icalendar.core.model.Frequency

val rrule = RRule(
    freq = Frequency.WEEKLY,
    interval = 1,
    byDay = listOf(DayOfWeek.MONDAY, DayOfWeek.WEDNESDAY),
    count = 10
)

val instances = RRuleExpander.expand(
    rule = rrule,
    start = event.dtStart,
    rangeEnd = event.dtStart.plusMonths(3),
    maxInstances = 100
)

import com.icalendar.caldav.client.CalDavClient
import com.icalendar.caldav.discovery.CalDavDiscovery

// Discover calendars
val discovery = CalDavDiscovery(httpClient)
val calendars = discovery.discoverCalendars(
    serverUrl = "https://caldav.example.com",
    username = "user",
    password = "pass"
)

// Fetch events from a calendar
val client = CalDavClient(httpClient)
val result = client.fetchEvents(calendars.first().url)

when (result) {
    is DavResult.Success -> result.data.forEach { println(it.event.summary) }
    is DavResult.HttpError -> println("HTTP ${result.code}: ${result.message}")
    is DavResult.NetworkError -> println("Network error: ${result.exception}")
    is DavResult.ParseError -> println("Parse error: ${result.message}")
}

import com.icalendar.sync.engine.SyncEngine
import com.icalendar.sync.model.*

val syncEngine = SyncEngine(calDavClient)

val report = syncEngine.sync(
    calendarUrl = "https://caldav.example.com/calendar/",
    previousState = SyncState.initial(calendarUrl),
    localProvider = myLocalProvider,
    handler = mySyncHandler,
    callback = object : SyncCallback {
        override fun onConflict(conflict: SyncConflict): ConflictResolution {
            return ConflictResolution.USE_REMOTE
        }
    }
)

println("Synced: ${report.upserted.size} added, ${report.deleted.size} deleted")