// settings.gradle.kts
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven(url = "https://jitpack.io")
    }
}

// app/build.gradle.kts
dependencies {
    // Full SDK (recommended)
    implementation("com.github.redfast.redfast-sdk-android-build:redfast-sdk-ui:v3.0.0")

    // Or, data layer only (bring your own UI)
    implementation("com.github.redfast.redfast-sdk-android-build:redfast-sdk-core:v3.0.0")
}

dependencies {
    implementation "com.github.redfast.redfast-sdk-android-build:redfast-sdk-ui:v3.0.0"
}

<repositories>
    <repository>
        <id>jitpack.io</id>
        <url>https://jitpack.io</url>
    </repository>
</repositories>

<dependency>
    <groupId>com.github.redfast.redfast-sdk-android-build</groupId>
    <artifactId>redfast-sdk-ui</artifactId>
    <version>v3.0.0</version>
</dependency>

dependencies {
    implementation(files("libs/redfast-sdk-core-release.aar"))
    implementation(files("libs/redfast-sdk-ui-google-fcm-release.aar"))

    // Required Compose dependencies
    implementation(platform("androidx.compose:compose-bom:2024.09.00"))
    implementation("androidx.compose.ui:ui")
    implementation("androidx.compose.material3:material3")
    implementation("io.coil-kt:coil-compose:2.6.0")

    // Only if using the google store flavor
    implementation("com.android.billingclient:billing:8.0.0")
    implementation("com.android.billingclient:billing-ktx:8.0.0")
}

android {
    buildFeatures {
        compose = true
    }
}

class RedflixApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        PromptManager.initialize(
            context = this,
            appId = APP_ID,
            userId = USER_ID,
            onComplete = { result ->
                Log.d("Engage", "SDK initialized: ${result.code}")
            }
        )
    }
}

val pm = PromptManager.get()

@Composable
fun HomeScreen() {
    // ... your screen content ...

    PromptOverlay(
        triggerType = PromptOverlayTriggerType.Screen(name = "home"),
        onEvent = { event ->
            when (event) {
                is PromptEvent.Impression -> Log.d("Engage", "shown: ${event.result.promptMeta?.promptName}")
                is PromptEvent.Clicked    -> handleDeeplink(event.result.value)
                is PromptEvent.Decline    -> { /* user clicked button 3 */ }
                is PromptEvent.Timeout    -> { /* auto-dismissed */ }
                is PromptEvent.Dismissed  -> { /* close or back */ }
            }
        }
    )
}

sealed class PromptOverlayTriggerType {
    data class Screen(val name: String) : PromptOverlayTriggerType()
    data class Button(val clickId: String) : PromptOverlayTriggerType()
}

@Composable
fun DetailScreen() {
    var triggeredClickId by remember { mutableStateOf<String?>(null) }

    Column {
        Button(onClick = { triggeredClickId = "subscribe" }) {
            Text("Subscribe")
        }
    }

    triggeredClickId?.let { clickId ->
        PromptOverlay(
            triggerType = PromptOverlayTriggerType.Button(clickId = clickId),
            onEvent = { event ->
                // optionally clear the click id on terminal events
                if (event is PromptEvent.Dismissed || event is PromptEvent.Clicked) {
                    triggeredClickId = null
                }
            }
        )
    }
}

val prompts = PromptManager.get().getTriggerablePrompts(
    screenName = "home",
    clickId    = "subscribe",
    type       = PathType.MODAL
)

prompts.firstOrNull()?.let { prompt ->
    // Render prompt manually, or let the SDK render it:
    // ShowPrompt(prompt, onEvent = { ... })
}

item {
    PromptInline(
        zoneId = InlineType.general.value, // "android-banner"
        closeButton = InlineCloseButtonStyle(
            color   = "#000000",
            bgColor = "#FFFFFF",
            size    = 20
        ),
        timer = InlineTimerStyle(
            fontSize  = 14,
            fontColor = "#FFFFFF"
        ),
        focusStyle = InlineFocusStyle(
            borderColor  = "#ff4400",
            borderWidth  = 1,
            borderRadius = 5
        ),
        modifier = Modifier.padding(horizontal = 16.dp),
        onEvent = { event -> Log.d("Engage", "inline event: $event") }
    )
}

enum class InlineType(val value: String) {
    all("all"),
    general("android-banner"),
    featured("featured"),
    horizontal("horizontal"),
    billboard("billboard"),
    redfit_shop_banner("redfit-shop-banner"),
    redflix("redflix-featured")
}

val pm = PromptManager.get()

pm.getTriggerablePrompts(
    screenName = "home",
    clickId    = "*",
    type       = PathType.HORIZONTAL,
    zoneId     = InlineType.featured.value
).firstOrNull()?.let { prompt ->
    // Device-aware background image (selected from rf_settings_bg_image_* fields)
    val bgImage        = prompt.pathItem.actions.rfSettingsBgImage
    val deviceMeta     = prompt.deviceMeta
    val deeplink       = prompt.deeplink
    val accessibility  = prompt.accessibilityLabel
    val customMetadata = prompt.pathItem.actions.rfMetadata

    // Button colors (from Pulse configuration)
    val button1Color = prompt.button1?.textColor
    val button2Color = prompt.button2?.textColor
    val button3Color = prompt.button3?.textColor

    // Countdown configuration
    val countDownSeconds     = prompt.countDown
    val countDownPrompt      = prompt.countDownPrompt
    val countDownColor       = prompt.countDownPromptColor
    val countDownFontSize    = prompt.countDownPromptFontSize
    val countDownInvisible   = prompt.countDownPromptInvisible

    // Suspend-based tracking primitives (invoke on a coroutine scope)
    lifecycleScope.launch {
        val impression = prompt.impression()   // PromptEvent.Impression equivalent
        val dismiss    = prompt.dismiss()
        val timeout    = prompt.timeout()
        val decline    = prompt.decline()       // user clicked button 3
        val goal       = prompt.goal()          // user clicked button 1 (accept)
        val goal2      = prompt.goal2()         // user clicked button 2 (accept2)
        val holdout    = prompt.holdout()       // invoked automatically when holdout=true
    }
}

PromptOverlay(
    triggerType = PromptOverlayTriggerType.Screen(name = "home"),
    onEvent = { event ->
        if (event is PromptEvent.Clicked) {
            val deeplink = event.result.value            // Map<String, Any>?
            val target   = deeplink?.get("deeplink") as? String
            target?.let { navigateTo(it) }
        }
    }
)

onEvent = { event ->
    val campaign: String? = event.result.meta?.get("campaign") as? String
    val tier: String?     = event.result.meta?.get("tier") as? String
}

val allMeta: Map<String, Any> = PromptManager.get().getMeta()

PromptManager.get().customTrack("video_played")

PromptManager.get().setUserId("new-user-id")

// Read the currently active user id
val currentUserId = PromptManager.get().getUserId()

PromptManager.get().enablePrompt(false)
// ...later
PromptManager.get().enablePrompt(true)

PromptManager.get().resetGoal()

sealed class PromptEvent {
    abstract val result: PromptResult

    data class Impression(override val result: PromptResult) : PromptEvent()
    data class Clicked(override val result: PromptResult)    : PromptEvent()
    data class Decline(override val result: PromptResult)    : PromptEvent()
    data class Timeout(override val result: PromptResult)    : PromptEvent()
    data class Dismissed(override val result: PromptResult)  : PromptEvent()
}

data class PromptResult(
    val code: PromptResultCode,
    val value: Map<String, Any>? = null,       // decoded deeplink payload
    val meta:  Map<String, Any?>? = null,      // custom metadata from Pulse
    val promptMeta: PromptMeta? = null          // prompt / experiment identity
)

enum class PromptResultCode(val value: Int) {
    OK(1),
    ERROR(-100),
    NOT_APPLICABLE(-101),
    DISABLED(-102),
    SUPPRESSED(-103),
    IMPRESSION(100),
    BUTTON1(101),   // accept
    BUTTON2(102),   // accept2
    BUTTON3(103),   // decline
    DISMISS(110),
    TIMEOUT(111),
    HOLDOUT(120)
}

data class PromptMeta(
    val promptName: String?,
    val promptID: String?,
    val promptVariationName: String?,
    val promptVariationID: String?,
    val promptExperimentName: String?,
    val promptExperimentID: String?,
    val promptType: Int?,          // PathType.value
    val buttonLabel: String?       // localized label of the pressed button
)

val prompt = PromptManager.get().getPrompt(promptId)
prompt?.let {
    ShowPrompt(
        prompt = it,
        onEvent = { event -> /* ... */ }
    )
}

val pm = PromptManager.get()

// Query previous purchases for the signed-in Play/Amazon user
pm.iapGetPurchased { purchases, type ->
    // 'purchases' is List<com.android.billingclient.api.Purchase> on google
}

// Resolve SKU metadata (title, price, description)
pm.iapGetProductDetails(
    sku  = "com.myapp.premium",
    type = IapProductType.subscription
) { skus: List<IapProduct> ->
    val product = skus.firstOrNull() ?: return@iapGetProductDetails
    // Launch the platform billing flow
    pm.iapPurchaseProducts(
        activity = currentActivity,
        productDetailsList = listOf(product.platformProduct), // ProductDetails / IapItem
        subscriptionUpdateParams = null
    ) { purchases, error ->
        // Acknowledge / consume the purchase and notify Engage
        purchases.firstOrNull()?.let { purchase ->
            pm.iapNotifyAppStore(purchase, IapProductType.subscription) { code, msg ->
                Log.d("IAP", "notify app store: $code $msg")
            }
        }
    }
}

data class IapProduct(
    val sku: String?,
    val title: String?,
    val description: String?,
    val price: String?,
    val platformProduct: Any   // ProductDetails (Google) or com.amazon.device.iap.model.Product
)

enum class IapProductType(val value: String) {
    consumable("consumable"),
    nonConsumable("android-nonConsumable"),
    subscription("subscription")
}

class MyFcmService : FirebaseMessagingService() {
    override fun onNewToken(token: String) {
        PushManager.onTokenReceived(token, channel = "fcm")
    }
    override fun onMessageReceived(message: RemoteMessage) {
        PushManager.onMessageReceived(
            PushMessage(
                title = message.notification?.title,
                body  = message.notification?.body,
                smallIconUrl = message.data["imageSmallIconUrl"],
                iconUrl      = message.data["imageIconUrl"],
                imageUrl     = message.data["imageUrl"],
                campaignId   = message.data["promptId"],
                actionUrl    = message.data["actionUrl"],
                actionDeeplink = message.data["actionDeeplink"]
            )
        )
    }
}

enum class PathType(val value: Int) {
    ALL(-1), INVISIBLE(1), MODAL(2), HORIZONTAL(5), VIDEO(6),
    TEXT(7), VERTICAL(8), TILE(9), INTERSTITIAL(10),
    NOTIFICATION(11), EMAIL(12), BOTTOM_BANNER(13)
}