dependencies {
    implementation("io.github.ebinjoy999:compose-skeleton-shimmer:2.0.1")
}

// Rectangular skeleton with rounded corners
SkeletonBox(
    modifier = Modifier
        .fillMaxWidth()
        .height(100.dp),
    shape = RoundedCornerShape(12.dp)
)

// Circular skeleton for avatars
SkeletonCircle(size = 64.dp)

// Text line skeleton
SkeletonLine(
    modifier = Modifier.fillMaxWidth(0.7f),
    height = 16.dp
)

// Card skeleton with image, title, and description
SkeletonCard(
    imageHeight = 180.dp,
    titleLines = 1,
    showDescription = true,
    descriptionLines = 2
)

// List item skeleton with avatar and text
SkeletonListItem(
    leadingSize = 48.dp,
    isLeadingCircle = true,
    showSubtitle = true
)

// Profile skeleton with avatar, name, bio, and buttons
SkeletonProfile(
    avatarSize = 80.dp,
    showBio = true,
    actionButtonCount = 2
)

// Grid tile skeleton
SkeletonTile(
    modifier = Modifier.aspectRatio(1f),
    showLabel = true
)

Skeleton(
    isLoading = viewModel.isLoading,
    skeleton = { SkeletonCard() }
) {
    ActualCard(data = viewModel.data)
}

// With crossfade transition
Skeleton(
    isLoading = isLoading,
    transition = SkeletonTransition.Crossfade,
    transitionDurationMs = 400,
    skeleton = { SkeletonProfile() }
) {
    UserProfile(user = user)
}

SkeletonIfNull(
    data = user,
    skeleton = { SkeletonProfile() }
) { user ->
    UserProfile(user = user)
}

LazyColumn {
    skeletonItems(
        isLoading = isLoading,
        count = 5
    ) {
        SkeletonListItem()
    }
    
    // Real items
    items(actualItems) { item ->
        ListItem(item)
    }
}

LazyVerticalGrid(columns = GridCells.Fixed(2)) {
    skeletonGridItems(
        isLoading = isLoading,
        count = 6
    ) {
        SkeletonTile(
            modifier = Modifier.aspectRatio(1f)
        )
    }
}

Box(
    modifier = Modifier
        .size(100.dp)
        .background(Color.LightGray)
        .shimmer()
)

val shimmerState = rememberShimmerState(
    durationMillis = 1200,
    direction = ShimmerDirection.LeftToRight
)

SkeletonCard(shimmerState = shimmerState)
SkeletonListItem(shimmerState = shimmerState)

// Horizontal shimmer
rememberShimmerState(direction = ShimmerDirection.LeftToRight)
rememberShimmerState(direction = ShimmerDirection.RightToLeft)

// Vertical shimmer
rememberShimmerState(direction = ShimmerDirection.TopToBottom)
rememberShimmerState(direction = ShimmerDirection.BottomToTop)

// Linear shimmer (default) - Traditional left-to-right sweep
val linearConfig = ShimmerConfig(shimmerType = ShimmerType.Linear)

// Radial/Spotlight shimmer - Expanding circle effect
val radialConfig = ShimmerConfig(shimmerType = ShimmerType.Radial)

// Pulse/Breathing shimmer - Soft fade in/out effect
val pulseConfig = ShimmerConfig(shimmerType = ShimmerType.Pulse)

// Wave shimmer - Multiple wave ripples
val waveConfig = ShimmerConfig(shimmerType = ShimmerType.Wave, waveCount = 3)

// Use ready-made configurations
ShimmerConfig.Default      // Standard linear shimmer
ShimmerConfig.Subtle       // Gentle, slow shimmer
ShimmerConfig.Prominent    // Bold, fast shimmer
ShimmerConfig.Pulse        // Breathing effect
ShimmerConfig.Spotlight    // Radial spotlight
ShimmerConfig.MultiWave    // Multiple wave ripples
ShimmerConfig.Accessible   // Reduced motion safe

val customConfig = ShimmerConfig(
    shimmerType = ShimmerType.Linear,
    direction = ShimmerDirection.LeftToRight,
    durationMillis = 1200,
    angle = 20f,                    // Tilt angle in degrees
    shimmerWidth = 200f,            // Width of shimmer band
    intensity = 0.7f,               // Highlight intensity (0.0-1.0)
    dropOff = ShimmerDropOff.Soft,  // Gradient falloff style
    easing = ShimmerEasing.EaseInOut,
    repeatMode = ShimmerRepeatMode.Restart,
    staggerDelayMillis = 0,         // Delay for list items
    respectReducedMotion = true     // Accessibility support
)

val shimmerState = rememberShimmerState(config = customConfig)
SkeletonCard(shimmerState = shimmerState)

// Angled shimmer (e.g., diagonal sweep)
val angledConfig = ShimmerConfig(
    angle = 30f  // 30 degrees tilt
)

ShimmerDropOff.Linear   // Standard linear falloff
ShimmerDropOff.Soft     // Gentle Gaussian-like falloff
ShimmerDropOff.Sharp    // Quick, crisp edges

ShimmerEasing.Linear       // Constant speed
ShimmerEasing.EaseIn       // Slow start, fast end
ShimmerEasing.EaseOut      // Fast start, slow end
ShimmerEasing.EaseInOut    // Slow start & end, fast middle
ShimmerEasing.Spring       // Bouncy spring effect

val controller = rememberShimmerController()

// Pause all shimmers
controller.pause()

// Resume all shimmers
controller.resume()

// Create states that respect the controller
val shimmerState = rememberShimmerState(controller = controller)

val shimmerState = rememberLifecycleAwareShimmerState(
    config = ShimmerConfig.Default
)

val shimmerState = rememberLimitedShimmerState(
    maxIterations = 5,
    onComplete = { /* Animation finished */ }
)

val shimmerState = rememberShimmerStateWithCallbacks(
    onAnimationStart = { /* Started */ },
    onAnimationIteration = { iteration -> /* Iteration $iteration */ },
    onAnimationEnd = { /* Stopped */ }
)

// Individual stagger delay
val shimmerState1 = rememberShimmerState(
    config = ShimmerConfig(staggerDelayMillis = 0)
)
val shimmerState2 = rememberShimmerState(
    config = ShimmerConfig(staggerDelayMillis = 100)
)
val shimmerState3 = rememberShimmerState(
    config = ShimmerConfig(staggerDelayMillis = 200)
)

// Or use the helper function
val states = rememberStaggeredShimmerStates(
    count = 5,
    staggerDelayMillis = 100,
    config = ShimmerConfig.Default
)

states.forEachIndexed { index, state ->
    SkeletonListItem(shimmerState = state)
}

val shimmerState = rememberShimmerState(
    baseColor = Color(0xFFE0E0E0),
    highlightColor = Color(0xFFF5F5F5)
)

Box(
    modifier = Modifier
        .size(100.dp)
        .shimmerWithBrush { progress, size ->
            Brush.linearGradient(
                colors = listOf(Color.Red, Color.Blue, Color.Red),
                start = Offset(-size.width + size.width * 2 * progress, 0f),
                end = Offset(size.width * 2 * progress, size.height)
            )
        }
)

// Light mode defaults
baseColor = Color(0xFFE0E0E0)
highlightColor = Color(0xFFF5F5F5)

// Dark mode defaults
baseColor = Color(0xFF3A3A3A)
highlightColor = Color(0xFF4A4A4A)

// Use Material 3 surface colors
val colors = materialSkeletonColors()

SkeletonTheme(colors = colors) {
    SkeletonCard()
}

val customColors = customSkeletonColors(
    baseColor = MaterialTheme.colorScheme.surfaceVariant,
    highlightColor = MaterialTheme.colorScheme.surface
)

SkeletonTheme(colors = customColors) {
    // All skeleton components will use these colors
    SkeletonCard()
    SkeletonListItem()
}

// Config that disables animation when reduced motion is enabled
val config = ShimmerConfig(respectReducedMotion = true)

// Or use the accessible preset
val accessibleState = rememberShimmerStateWithPreset(ShimmerConfig.Accessible)

// Check system setting manually
val reduceMotion = rememberReduceMotionEnabled()
if (reduceMotion) {
    // Show static placeholder
}

SkeletonBox(
    modifier = Modifier
        .skeletonSemantics(
            type = SkeletonSemanticType.Image,
            description = "Loading profile picture"
        )
)

// Get an accessible shimmer config based on system settings
val accessibleConfig = rememberAccessibleShimmerConfig()