🛡️ CrashGuard

dependencies {
    implementation("io.github.alims-repo:crash-guard:1.0.0")
}

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

        CrashGuard.install(
            application = this,
            config = CrashGuardConfig.Builder(this)
                .debugMode(BuildConfig.DEBUG)
                .build()
        )
    }
}

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

        val config = CrashGuardConfig.Builder(this)
            // Basic Settings
            .debugMode(BuildConfig.DEBUG)
            .enableLogging(true)
            .enableCrashReporting(true)
            .maxCrashLogs(100)

            // Custom Activities
            .customUserActivity(MyCustomUserCrashActivity::class)
            .customDeveloperActivity(MyCustomDeveloperCrashActivity::class)

            // Auto-Restart
            .enableAutoRestart(enabled = true, delayMs = 2000L)

            // Notifications
            .showNotification(
                enabled = true,
                config = NotificationConfig(
                    channelId = "app_crashes",
                    channelName = "App Crashes",
                    notificationTitle = "MyApp Crashed",
                    notificationMessage = "Tap to restart",
                    smallIcon = R.drawable.ic_notification
                )
            )

            // Analytics Integration
            .enableAnalytics(
                enabled = true,
                provider = object : AnalyticsProvider {
                    override fun logCrash(crashData: CrashData) {
                        // Send to your analytics platform
                        FirebaseCrashlytics.getInstance()
                            .recordException(crashData.exception)
                    }

                    override fun logEvent(eventName: String, params: Map<String, Any>) {
                        // Log analytics events
                    }
                }
            )

            // Custom Data
            .customDataProvider(object : CustomDataProvider {
                override fun provideCustomData(context: Context): Map<String, String> {
                    return mapOf(
                        "user_id" to getUserId(),
                        "session_id" to getSessionId(),
                        "build_type" to BuildConfig.BUILD_TYPE
                    )
                }
            })

            // Crash Interception
            .crashInterceptor(object : CrashInterceptor {
                override fun onCrashIntercepted(
                    throwable: Throwable,
                    thread: Thread
                ): Boolean {
                    // Return true to prevent crash screen
                    return false
                }
            })

            // Security
            .enableSecureMode(true) // Sanitizes sensitive data

            // Exception Exclusion
            .excludeException(InterruptedException::class)
            .excludeException(CancellationException::class)

            // Lifecycle Callbacks
            .onCrashDetected { crashData ->
                Log.e("CrashGuard", "Crash detected: ${crashData.exceptionType}")
            }
            .onBeforeCrashScreen { crashData ->
                // Return false to prevent showing crash screen
                true
            }
            .onAfterCrashScreen { crashData ->
                // Cleanup after crash screen dismissed
            }
            .onInitialized {
                Log.d("CrashGuard", "Initialized successfully")
            }

            .build()

        CrashGuard.install(this, config)
    }
}

class MyCustomCrashActivity : BaseCrashActivity(), CrashActivityContract {

    override fun setupUI() {
        setContentView(R.layout.activity_my_crash)

        // Access crash data
        crashData?.let { crash ->
            findViewById<TextView>(R.id.errorMessage).text = crash.exceptionMessage
            findViewById<TextView>(R.id.stackTrace).text = crash.stackTrace
        }

        // Setup buttons
        findViewById<Button>(R.id.btnRestart).setOnClickListener {
            onRestartRequested()
        }

        findViewById<Button>(R.id.btnClose).setOnClickListener {
            onCloseRequested()
        }
    }

    override fun onCrashDataReceived(crashData: CrashData) {
        // Handle crash data
    }

    override fun onRestartRequested() {
        restartApp() // Provided by BaseCrashActivity
    }

    override fun onCloseRequested() {
        closeApp() // Provided by BaseCrashActivity
    }
}

// Get crash repository
val storage = CrashLogStorage(context, CrashGuard.getConfig())
val repository = CrashRepositoryImpl(storage)

// In a coroutine
lifecycleScope.launch {
    // Get all crashes
    repository.getAllCrashes().onSuccess { crashes ->
        crashes.forEach { crash ->
            println("Crash: ${crash.exceptionType} at ${crash.formattedTimestamp}")
        }
    }

    // Get last crash
    repository.getLastCrash().onSuccess { crash ->
        crash?.let {
            println("Last crash: ${it.exceptionMessage}")
        }
    }

    // Get crash count
    repository.getCrashCount().onSuccess { count ->
        println("Total crashes: $count")
    }

    // Delete specific crash
    repository.deleteCrash(crashId)

    // Clear all crashes
    repository.deleteAllCrashes()
}

val storage = CrashLogStorage(context, CrashGuard.getConfig())

// Export as JSON
val jsonReport = storage.exportCrashesAsJson()

// Export specific crash as text file
crashData?.let { crash ->
    val file = storage.exportCrashAsText(crash)
    // Share or upload the file
}

data class CrashData(
    val id: String,                          // Unique crash ID
    val exception: Throwable,                // The exception
    val threadName: String,                  // Thread name
    val timestamp: Long,                     // Crash timestamp
    val appVersion: String,                  // App version
    val appPackage: String,                  // Package name
    val deviceInfo: DeviceInfo,              // Device details
    val customData: Map<String, String>,     // Custom data
    val activityStack: List<String>,         // Activity stack
    val availableMemory: Long,               // Available RAM
    val totalMemory: Long,                   // Total RAM
    val diskSpace: Long,                     // Free disk space
    val batteryLevel: Float,                 // Battery percentage
    val isCharging: Boolean,                 // Charging status
    val networkType: String,                 // Network type
    val orientation: String                  // Screen orientation
)

.enableAnalytics(
    enabled = true,
    provider = object : AnalyticsProvider {
        override fun logCrash(crashData: CrashData) {
            val crashlytics = FirebaseCrashlytics.getInstance()

            // Set custom keys
            crashlytics.setCustomKey("crash_id", crashData.id)
            crashlytics.setCustomKey("app_version", crashData.appVersion)
            crashlytics.setCustomKey("device_model", crashData.deviceInfo.model)

            // Add custom data
            crashData.customData.forEach { (key, value) ->
                crashlytics.setCustomKey(key, value)
            }

            // Record exception
            crashlytics.recordException(crashData.exception)
        }

        override fun logEvent(eventName: String, params: Map<String, Any>) {
            FirebaseAnalytics.getInstance(context)
                .logEvent(eventName, bundleOf(*params.toList().toTypedArray()))
        }
    }
)

.enableAnalytics(
    enabled = true,
    provider = object : AnalyticsProvider {
        override fun logCrash(crashData: CrashData) {
            Sentry.captureException(crashData.exception) { scope ->
                scope.setTag("crash_id", crashData.id)
                scope.setTag("device", crashData.deviceInfo.model)
                scope.setExtra("crash_report", crashData.getFullReport())
            }
        }

        override fun logEvent(eventName: String, params: Map<String, Any>) {
            Sentry.captureMessage(eventName)
        }
    }
)

.onCrashDetected { crashData ->
    // Send crash to your backend
    lifecycleScope.launch {
        try {
            api.reportCrash(
                crashId = crashData.id,
                report = crashData.toJson(),
                timestamp = crashData.timestamp
            )
        } catch (e: Exception) {
            Log.e("CrashGuard", "Failed to report crash", e)
        }
    }
}

// Trigger a test crash
CrashGuard.triggerCrash(RuntimeException("Test crash"))

// Or in a button click
findViewById<Button>(R.id.btnTestCrash).setOnClickListener {
    throw RuntimeException("Testing crash screen")
}

@Test
fun `test crash data collection`() = runTest {
        val exception = RuntimeException("Test exception")
        val repository = CrashRepositoryImpl(mockStorage)

        val crashData = CrashData(
            exception = exception,
            threadName = "main",
            appVersion = "1.0.0",
            appPackage = "com.test",
            deviceInfo = DeviceInfo()
        )

        repository.saveCrash(crashData).onSuccess {
            // Assert crash was saved
            assertTrue(true)
        }
    }