import { NativeEventEmitter, NativeModules, Platform } from "react-native";

import type {
  AndroidNotificationChannelConfig,
  IOSNotificationCategoryConfig,
  NativeNotificationEvent,
  NotificationPermissionStatus,
  PushNotificationPayload,
} from "../types";

interface NativeSirrusNotificationsModule {
  requestPermission(): Promise<NotificationPermissionStatus>;
  registerAndroidChannels(channels: AndroidNotificationChannelConfig[]): Promise<void>;
  registerIOSCategories(categories: IOSNotificationCategoryConfig[]): Promise<void>;
  showLocalNotification(payload: Record<string, unknown>): Promise<void>;
  cancelNotification(notificationId: string): Promise<void>;
  cancelAllNotifications(): Promise<void>;
  setBadgeCount(count: number): Promise<void>;
  consumeInitialNotificationEvent(): Promise<NativeNotificationEvent | null>;
  consumeLatestNativePushToken(): Promise<{
    token: string;
    provider: "fcm" | "apns";
  } | null>;
  addListener?(eventName: string): void;
  removeListeners?(count: number): void;
}

const moduleRef = NativeModules.SirrusReactNativeSdk as
  | NativeSirrusNotificationsModule
  | undefined;
const eventEmitter = moduleRef ? new NativeEventEmitter(moduleRef as never) : null;
const NOTIFICATION_EVENT_NAME = "sirrusNotificationEvent";

const ensureModule = (): NativeSirrusNotificationsModule => {
  if (!moduleRef) {
    throw new Error(
      "Sirrus native notification module is not linked. Reinstall pods / Gradle dependencies and rebuild the app."
    );
  }

  return moduleRef;
};

export const isSirrusNativeNotificationsAvailable = (): boolean => Boolean(moduleRef);

export const requestNativeNotificationPermission =
  async (): Promise<NotificationPermissionStatus> => {
    return {
      granted: false,
      status: "unavailable",
    };
  };

export const registerNativeAndroidChannels = async (
  channels: AndroidNotificationChannelConfig[]
): Promise<void> => {
  if (Platform.OS !== "android" || channels.length === 0 || !moduleRef) {
    return;
  }

  await ensureModule().registerAndroidChannels(channels);
};

export const registerNativeIOSCategories = async (
  categories: IOSNotificationCategoryConfig[]
): Promise<void> => {
  if (Platform.OS !== "ios" || categories.length === 0 || !moduleRef) {
    return;
  }

  await ensureModule().registerIOSCategories(categories);
};

export const showNativeLocalNotification = async (
  payload: PushNotificationPayload
): Promise<void> => {
  await ensureModule().showLocalNotification(payload as unknown as Record<string, unknown>);
};

export const cancelNativeNotification = async (
  notificationId: string
): Promise<void> => {
  if (!moduleRef) {
    return;
  }

  await ensureModule().cancelNotification(notificationId);
};

export const cancelAllNativeNotifications = async (): Promise<void> => {
  if (!moduleRef) {
    return;
  }

  await ensureModule().cancelAllNotifications();
};

export const setNativeBadgeCount = async (count: number): Promise<void> => {
  if (!moduleRef) {
    return;
  }

  await ensureModule().setBadgeCount(count);
};

export const subscribeToNativeNotificationEvents = (
  listener: (event: NativeNotificationEvent) => void
): (() => void) => {
  if (!eventEmitter) {
    return () => undefined;
  }

  const subscription = eventEmitter.addListener(
    NOTIFICATION_EVENT_NAME,
    listener
  );

  return () => {
    subscription.remove();
  };
};

export const consumeInitialNativeNotificationEvent =
  async (): Promise<NativeNotificationEvent | null> => {
    if (!moduleRef) {
      return null;
    }

    return ensureModule().consumeInitialNotificationEvent();
  };

export const consumeLatestNativePushToken =
  async (): Promise<{ token: string; provider: "fcm" | "apns" } | null> => {
    if (!moduleRef) {
      return null;
    }

    return ensureModule().consumeLatestNativePushToken();
  };