kotlin {
  sourceSets {
    commonMain.dependencies {
      // Core library - required
      implementation("com.alorma.fireandforget:core:$version")

      // Optional: multiplatform-settings implementation
      implementation("com.alorma.fireandforget:multiplatform-settings:$version")
    }
  }
}

dependencies {
  // Core library - required
  implementation("com.alorma.fireandforget:core:$version")

  // Optional: multiplatform-settings implementation
  implementation("com.alorma.fireandforget:multiplatform-settings:$version")
}

dependencies {
  implementation("com.alorma.fireandforget:core:$version")
  implementation("com.alorma.fireandforget:multiplatform-settings:$version")
}

class OnboardingFlag(
  runner: FireAndForgetRunner,
) : FireAndForget(
  fireAndForgetRunner = runner,
  name = "user_onboarding",
  defaultValue = true // Default: enabled (will execute)
)

import com.alorma.fireandforget.multiplatform.settings.SettingsFireAndForgetRunner
import com.russhwolf.settings.Settings

val settings = Settings()
val runner = SettingsFireAndForgetRunner(settings)
val onboardingFlag = OnboardingFlag(runner)

class InMemoryRunner : FireAndForgetRunner() {
  private val map = mutableMapOf<String, Boolean>()
  private val counterMap = mutableMapOf<String, Int>()

  override fun checkEnabled(fireAndForget: FireAndForget): Boolean {
    return map[fireAndForget.name] ?: fireAndForget.defaultValue
  }

  override fun disable(fireAndForget: FireAndForget) {
    map[fireAndForget.name] = false
  }

  override fun reset(fireAndForget: FireAndForget) {
    map.remove(fireAndForget.name)
  }

  override fun getCounter(counterFireAndForget: CounterFireAndForget): Int? {
    return counterMap[counterFireAndForget.name]
  }

  override fun setCounter(counterFireAndForget: CounterFireAndForget, value: Int) {
    counterMap[counterFireAndForget.name] = value
  }
}

class DataStoreRunner(
  private val dataStore: DataStore<Preferences>
) : FireAndForgetRunner() {
  override fun checkEnabled(fireAndForget: FireAndForget): Boolean {
    // Your DataStore implementation
  }

  override fun disable(fireAndForget: FireAndForget) {
    // Your DataStore implementation
  }

  override fun reset(fireAndForget: FireAndForget) {
    // Your DataStore implementation
  }

  override fun getCounter(counterFireAndForget: CounterFireAndForget): Int? {
    // Your DataStore implementation for counter
  }

  override fun setCounter(counterFireAndForget: CounterFireAndForget, value: Int) {
    // Your DataStore implementation for counter
  }
}

fun showAppContent() {
  val runner = SettingsFireAndForgetRunner(Settings())
  val onboarding = OnboardingFlag(runner)

  if (onboarding.isEnabled()) {
    // This will only show once
    showOnboardingScreen(
      onComplete = {
        onboarding.disable() // Mark as completed
      }
    )
  } else {
    showMainScreen()
  }
}

abstract class FireAndForget(
  val fireAndForgetRunner: FireAndForgetRunner,
  val name: String,
  val defaultValue: Boolean = true,
  val autoDisable: Boolean = false,
)

abstract class CounterFireAndForget(
  fireAndForgetRunner: FireAndForgetRunner,
  name: String,
  val counter: Int,
) : FireAndForget(...)

val feature = CounterFireAndForget(runner, "feature", counter = 3)
feature.isEnabled() // Call 1: true (counter: 3 → 2)
feature.isEnabled() // Call 2: true (counter: 2 → 1)
feature.isEnabled() // Call 3: true (counter: 1 → 0)
feature.isEnabled() // Call 4+: false (counter: 0)
feature.reset()     // Resets counter to 3

abstract class FireAndForgetRunner {
  fun isEnabled(fireAndForget: FireAndForget): Boolean
  protected abstract fun checkEnabled(fireAndForget: FireAndForget): Boolean
  abstract fun disable(fireAndForget: FireAndForget)
  abstract fun reset(fireAndForget: FireAndForget)
  
  // Counter support for CounterFireAndForget
  fun isEnabledCounter(counterFireAndForget: CounterFireAndForget): Boolean
  protected abstract fun getCounter(counterFireAndForget: CounterFireAndForget): Int?
  protected abstract fun setCounter(counterFireAndForget: CounterFireAndForget, value: Int)
  fun resetCounter(counterFireAndForget: CounterFireAndForget)
}

class WelcomeMessage(runner: FireAndForgetRunner) : FireAndForget(
  fireAndForgetRunner = runner,
  name = "welcome_message"
)

fun showHomeScreen() {
  val runner = SettingsFireAndForgetRunner(Settings())
  val welcomeFlag = WelcomeMessage(runner)

  if (welcomeFlag.isEnabled()) {
    showWelcomeDialog(
      onDismiss = { welcomeFlag.disable() }
    )
  }
}

class NewFeatureAnnouncement(runner: FireAndForgetRunner) : FireAndForget(
  fireAndForgetRunner = runner,
  name = "feature_announcement_v2"
)

fun showMainScreen() {
  val runner = SettingsFireAndForgetRunner(Settings())
  val announcement = NewFeatureAnnouncement(runner)

  if (announcement.isEnabled()) {
    // Show announcement
    displayMessage("Check out our new feature!")
    announcement.disable()
  }
}

class AppTutorial(runner: FireAndForgetRunner) : FireAndForget(
  fireAndForgetRunner = runner,
  name = "app_tutorial"
)

fun handleRestartTutorial() {
  val runner = SettingsFireAndForgetRunner(Settings())
  val tutorial = AppTutorial(runner)

  // Allow tutorial to run again
  tutorial.reset()
  navigateToTutorial()
}

fun showApp() {
  val runner = SettingsFireAndForgetRunner(Settings())

  // Multiple flags can share the same runner
  val onboarding = OnboardingFlag(runner)
  val tutorial = TutorialFlag(runner)
  val featureAnnouncement = FeatureAnnouncementFlag(runner)

  when {
    onboarding.isEnabled() -> showOnboardingScreen { onboarding.disable() }
    tutorial.isEnabled() -> showTutorialScreen { tutorial.disable() }
    else -> showMainScreen()
  }
}

class FirstRunSetup(runner: FireAndForgetRunner) : FireAndForget(
  fireAndForgetRunner = runner,
  name = "first_run_setup"
)

fun initializeApp() {
  val runner = SettingsFireAndForgetRunner(Settings())
  val setup = FirstRunSetup(runner)

  if (setup.isEnabled()) {
    // Perform first-run initialization
    initializeDatabase()
    downloadInitialData()
    setup.disable()
  }
}

class QuickTip(runner: FireAndForgetRunner) : FireAndForget(
  fireAndForgetRunner = runner,
  name = "quick_tip",
  autoDisable = true  // Automatically disables after first isEnabled() call
)

fun showScreen() {
  val runner = SettingsFireAndForgetRunner(Settings())
  val quickTip = QuickTip(runner)

  // First call: returns true and automatically disables
  if (quickTip.isEnabled()) {
    showTooltip("Here's a quick tip!")
    // No need to call quickTip.disable()
  }

  // Subsequent calls: returns false
  quickTip.isEnabled() // false
}

import com.alorma.fireandforget.CounterFireAndForget

class LimitedPromo(runner: FireAndForgetRunner, times: Int = 3) : CounterFireAndForget(
  fireAndForgetRunner = runner,
  name = "limited_promo",
  counter = times  // Will return true 3 times, then false
)

fun showScreen() {
  val runner = SettingsFireAndForgetRunner(Settings())
  val promo = LimitedPromo(runner, times = 3)

  // First 3 calls: returns true and decrements counter
  if (promo.isEnabled()) {
    showPromoBanner("Special offer!")
  }

  // After 3 calls: returns false
  // Counter state persists across app restarts
}

class ShowAfterVisits(runner: FireAndForgetRunner, visits: Int = 3) : CounterFireAndForget(
  fireAndForgetRunner = runner,
  name = "show_after_visits",
  counter = visits
)

fun showScreen() {
  val runner = SettingsFireAndForgetRunner(Settings())
  val showAfterVisits = ShowAfterVisits(runner, visits = 3)

  // Track visits silently - returns true for first 3 visits, false after
  val stillCounting = showAfterVisits.isEnabled()
  
  // Show feature ONLY after counter reaches 0 (inverse logic)
  if (!stillCounting) {
    showAdvancedFeature("You've visited 3 times! Here's an advanced feature.")
  }
  
  // Visit 1: stillCounting = true  → feature NOT shown
  // Visit 2: stillCounting = true  → feature NOT shown  
  // Visit 3: stillCounting = true  → feature NOT shown
  // Visit 4+: stillCounting = false → feature SHOWN
}

class UnlockAfterUses(runner: FireAndForgetRunner, requiredUses: Int = 3) : CounterFireAndForget(
  fireAndForgetRunner = runner,
  name = "unlock_tracker",
  counter = requiredUses
)

class FeatureUnlocked(runner: FireAndForgetRunner) : FireAndForget(
  fireAndForgetRunner = runner,
  name = "feature_unlocked",
  autoDisable = true  // Show once, then auto-disable
)

fun showScreen() {
  val runner = SettingsFireAndForgetRunner(Settings())
  val unlockTracker = UnlockAfterUses(runner, requiredUses = 3)
  val featureUnlocked = FeatureUnlocked(runner)
  
  // Track usage silently
  val stillTracking = unlockTracker.isEnabled()
  
  // Show unlock message once when counter reaches 0
  if (!stillTracking && featureUnlocked.isEnabled()) {
    showUnlockMessage("🎉 Premium feature unlocked after 3 uses!")
  }
}