import {

requireNativeModule,

requireNativeViewManager,

EventEmitter,

} from "expo-modules-core";

import { Platform } from "react-native";

import React from "react";

import type {

PermissionStatus,

AndroidPermissions,

IOSPermissions,

AndroidBlockableApp,

AndroidConfig,

IOSBlockedItem,

IOSBlockConfiguration,

TemporaryUnlockResult,

RelockResult,

FamilyActivityPickerSelectionEvent,

FamilyActivityPickerViewProps,

BlockedAppsNativeListProps,

} from "./ExpoAppBlocker.types";

export type {

PermissionStatus,

AndroidPermissions,

IOSPermissions,

AndroidBlockableApp,

IOSBlockedItem,

IOSBlockConfiguration,

TemporaryUnlockResult,

RelockResult,

ShieldConfig,

AndroidConfig,

PluginConfig,

FamilyActivityPickerSelectionEvent,

FamilyActivityPickerViewProps,

BlockedAppsNativeListProps,

} from "./ExpoAppBlocker.types";

// ──────────────────────────────────────────────────────────────────────────────

// Native module bridge

// ──────────────────────────────────────────────────────────────────────────────

const NativeModule = requireNativeModule("ExpoAppBlocker");

// ──────────────────────────────────────────────────────────────────────────────

// Permissions

// ──────────────────────────────────────────────────────────────────────────────

export async function getPermissionStatus(): Promise<PermissionStatus> {

if (Platform.OS === "android") {

const overlay = await NativeModule.checkOverlayPermission();

const usageStats = await NativeModule.checkUsageStatsPermission();

const notifications = await NativeModule.checkNotificationPermission();

const details: AndroidPermissions = { platform: "android", overlay, usageStats, notifications };

return { allGranted: overlay && usageStats && notifications, details };

}

if (Platform.OS === "ios") {

const result = NativeModule.getAuthorizationStatus();

const details: IOSPermissions = {

platform: "ios",

authorized: result.authorized,

status: result.status,

};

return { allGranted: result.authorized, details };

}

throw new Error("Unsupported platform");

}

export async function requestPermissions(): Promise<PermissionStatus> {

if (Platform.OS === "ios") {

const result = await NativeModule.requestAuthorization();

const details: IOSPermissions = {

platform: "ios",

authorized: result.authorized,

status: result.status,

};

return { allGranted: result.authorized, details };

}

return getPermissionStatus();

}

// ──────────────────────────────────────────────────────────────────────────────

// Android-specific: permission settings

// ──────────────────────────────────────────────────────────────────────────────

export function openOverlaySettings(): void {

if (Platform.OS !== "android") return;

NativeModule.openOverlaySettings();

}

export function openUsageStatsSettings(): void {

if (Platform.OS !== "android") return;

NativeModule.openUsageStatsSettings();

}

// ──────────────────────────────────────────────────────────────────────────────

// Android-specific: app list and blocking

// ──────────────────────────────────────────────────────────────────────────────

export async function getInstalledApps(): Promise<AndroidBlockableApp[]> {

if (Platform.OS !== "android") return [];

return NativeModule.getInstalledApps();

}

export function setBlockedApps(packageNames: string[]): void {

if (Platform.OS !== "android") return;

NativeModule.setBlockedApps(packageNames);

}

export function getBlockedApps(): string[] {

if (Platform.OS !== "android") return [];

return NativeModule.getBlockedApps();

}

export function configureAndroid(config: AndroidConfig): void {

if (Platform.OS !== "android") return;

NativeModule.setAndroidConfig(config);

}

export function startMonitoring(): void {

if (Platform.OS !== "android") return;

NativeModule.startMonitoring();

}

export function stopMonitoring(): void {

if (Platform.OS !== "android") return;

NativeModule.stopMonitoring();

}

// ──────────────────────────────────────────────────────────────────────────────

// iOS-specific: Family Controls

// ──────────────────────────────────────────────────────────────────────────────

export async function presentFamilyActivityPicker(): Promise<IOSBlockedItem[]> {

if (Platform.OS !== "ios") {

throw new Error("Family Activity Picker is only available on iOS");

}

return NativeModule.presentFamilyActivityPicker();

}

export async function setBlockConfiguration(config: IOSBlockConfiguration): Promise<void> {

if (Platform.OS !== "ios") {

throw new Error("Block configuration is only available on iOS");

}

return NativeModule.setBlockConfiguration(config);

}

export function getBlockConfiguration(): IOSBlockConfiguration | null {

if (Platform.OS !== "ios") return null;

return NativeModule.getBlockConfiguration();

}

export function clearAllBlocks(): void {

if (Platform.OS !== "ios") return;

NativeModule.clearAllBlocks();

}

export function isAppBlocked(bundleIdentifier: string): boolean {

if (Platform.OS !== "ios") return false;

return NativeModule.isAppBlocked(bundleIdentifier);

}

// ──────────────────────────────────────────────────────────────────────────────

// iOS-specific: Temporary unlock

// ──────────────────────────────────────────────────────────────────────────────

/**

* Suppress blocking for `durationMinutes`, then auto-resume.

*

* iOS removes the Family Controls shields; Android pauses the foreground-service

* poll (the timer lives in the service, so it survives app backgrounding).

* Calling again replaces any active unlock. Android rounds to a whole minute (min 1).

*/

export async function temporaryUnlock(durationMinutes: number = 15): Promise<TemporaryUnlockResult> {

if (Platform.OS === "android") {

NativeModule.temporaryUnlockAndroid(Math.max(1, Math.round(durationMinutes)));

return { unlocked: true, expiresAt: Date.now() + durationMinutes * 60_000 };

}

return NativeModule.temporaryUnlock(durationMinutes);

}

/** iOS only — returns `false` on Android. On Android use `getRemainingUnlockTime() > 0`. */

export function isTemporarilyUnlocked(): boolean {

if (Platform.OS !== "ios") return false;

return NativeModule.isTemporarilyUnlocked();

}

/**

* Seconds remaining on the active temporary unlock, or 0 if none.

*

* Platform divergence: on **Android** this ticks down live as the budget is spent

* inside blocked apps (and freezes when you leave). On **iOS** Apple does not expose

* live cumulative usage, so this returns the *granted* budget and stays flat until

* the usage threshold re-applies the shield (then drops to 0). Don't rely on a

* smooth iOS countdown.

*/

export function getRemainingUnlockTime(): number {

if (Platform.OS === "android") return NativeModule.getRemainingUnlockTimeAndroid();

return NativeModule.getRemainingUnlockTime();

}

/**

* End an active temporary unlock immediately and re-block.

*

* iOS restores the shields; Android cancels the unlock and re-blocks the

* foreground app on the next poll. Safe to call when nothing is unlocked.

*/

export async function relockApps(): Promise<RelockResult> {

if (Platform.OS === "android") {

NativeModule.relockAndroid();

return { locked: true };

}

return NativeModule.relockApps();

}

export function checkAndClearPendingUnlock(): boolean {

if (Platform.OS !== "ios") return false;

return NativeModule.checkAndClearPendingUnlock();

}

/**

* Android-only, last-resort recovery: forces a genuine process kill and

* relaunch. Some native-layer failures (observed: an expo-sqlite connection

* that NPEs on every operation, even a fresh `openDatabaseAsync` against a

* freshly-rebuilt database file) can only be cleared by a real process

* restart — closing/reopening the JS-side handle doesn't reach far enough.

* Apps that run this module's `AppBlockerService` as a foreground service

* can end up with an unusually long-lived Android process (the OS won't

* kill it just because the Activity was "closed"), which surfaces this kind

* of native-module degradation far more than it would in a normal app.

*

* Queues a relaunch (optionally straight back into `deepLink`, e.g. the

* blocker intercept URL the caller was trying to reach), then calls

* `Process.killProcess`. If that succeeds the process is gone before the

* call would otherwise return. The native call itself can still reject

* (e.g. a missing Android permission) — this is already the last-resort

* path, so that failure is swallowed rather than left as an unhandled

* rejection.

*

* No-op on iOS: that platform's process model doesn't exhibit this failure

* mode, and there is no equivalent restart primitive.

*/

export function restartAppForRecovery(deepLink?: string): void {

if (Platform.OS !== "android") return;

NativeModule.restartApp(deepLink ?? null).catch((err: unknown) => {

console.warn("[expo-app-blocker] restartAppForRecovery failed", err);

});

}

/**

* One OS-level block event: the blocker intercepted a blocked app (iOS

* shield render / Android foreground block). `interceptedAt` is epoch

* milliseconds; `appName` is the localized app name when the platform

* can resolve it (null otherwise).

*/

export interface PendingIntercept {

appName: string | null;

interceptedAt: number;

}

/**

* Drain and clear the queue of block events recorded natively since the

* last call. Implemented on both platforms (iOS App Group queue / Android

* SharedPreferences queue). The app calls this on foreground and persists

* the results to power the "blocks" counter.

*/

export function drainPendingIntercepts(): PendingIntercept[] {

if (Platform.OS !== "ios" && Platform.OS !== "android") return [];

return NativeModule.drainPendingIntercepts() ?? [];

}

export function addPendingUnlockListener(

handler: () => void

): { remove: () => void } | null {

if (Platform.OS !== "ios") return null;

const emitter = new EventEmitter(NativeModule);

return (emitter as any).addListener("onPendingUnlockRequest", handler);

}

// ──────────────────────────────────────────────────────────────────────────────

// iOS Native View: renders blocked app tokens with real names and icons

// ──────────────────────────────────────────────────────────────────────────────

let NativeBlockedAppsView: any = null;

if (Platform.OS === "ios") {

try {

NativeBlockedAppsView = requireNativeViewManager("ExpoAppBlocker");

} catch {}

}

export function BlockedAppsNativeList({

items,

selectionData,

style,

}: BlockedAppsNativeListProps) {

if (!NativeBlockedAppsView || Platform.OS !== "ios") return null;

const tokens = items

.filter((item) => (item.type as string) !== "summary")

.map((item) => ({ token: item.token, type: item.type }));

return React.createElement(NativeBlockedAppsView, {

selectionData: selectionData || "",

tokens,

style: [{ minHeight: 50 }, style],

});

}

// ──────────────────────────────────────────────────────────────────────────────

// iOS Native View: inline FamilyActivityPicker (embedded in your UI)

// ──────────────────────────────────────────────────────────────────────────────

let NativePickerView: any = null;

if (Platform.OS === "ios") {

try {

NativePickerView = requireNativeViewManager("ExpoAppBlockerPicker");

} catch {}

}

export function FamilyActivityPickerView({

initialSelection,

onSelectionChange,

theme,

style,

clearTrigger,

}: FamilyActivityPickerViewProps) {

if (!NativePickerView || Platform.OS !== "ios") return null;

return React.createElement(NativePickerView, {

initialSelection: initialSelection || "",

theme: theme || "system",

onSelectionChange: onSelectionChange

? (e: any) => {

const ne = e.nativeEvent;

const items = (ne.items ?? []).filter(

(item: { type?: string }) =>

item?.type === "app" ||

item?.type === "category" ||

item?.type === "webDomain",

);

onSelectionChange({ ...ne, items });

}

: undefined,

...(clearTrigger !== undefined ? { clearTrigger } : {}),

style: [{ minHeight: 400 }, style],

});

}