import type { SirrusReactNativeSDK } from "../SirrusReactNativeSDK";
import type { SDKConfig } from "../types";
import {
  bindFirebaseMessaging,
  type FirebaseMessagingBridge,
  type FirebaseMessagingBridgeOptions,
  type FirebaseMessagingLike,
} from "./firebaseMessaging";

export interface SirrusManagedCampaignOptions extends FirebaseMessagingBridgeOptions {
  firebaseMessaging?: FirebaseMessagingLike;
  strictStart?: boolean;
}

export interface SirrusManagedCampaignClient {
  start(): Promise<void>;
  stop(): void;
  processInitialNotification(): Promise<void>;
}

export const createSirrusManagedCampaignClient = (
  sdk: SirrusReactNativeSDK,
  options: SirrusManagedCampaignOptions = {}
): SirrusManagedCampaignClient => {
  let bridge: FirebaseMessagingBridge | null = null;
  let started = false;

  const getBridge = (): FirebaseMessagingBridge | null => {
    if (!options.firebaseMessaging) {
      return null;
    }

    if (!bridge) {
      bridge = bindFirebaseMessaging(
        sdk,
        options.firebaseMessaging,
        options
      );
    }

    return bridge;
  };

  return {
    async start(): Promise<void> {
      if (started) {
        return;
      }

      started = true;
      try {
        getBridge();
      } catch (error) {
        started = false;
        throw error;
      }
    },

    stop(): void {
      bridge?.unsubscribe();
      bridge = null;
      started = false;
    },

    async processInitialNotification(): Promise<void> {
      await getBridge()?.processInitialNotification();
    },
  };
};

export const initSirrusManagedSdk = async (
  sdk: SirrusReactNativeSDK,
  config: SDKConfig,
  options: SirrusManagedCampaignOptions = {}
): Promise<SirrusManagedCampaignClient> => {
  await sdk.init(config);

  const client = createSirrusManagedCampaignClient(sdk, options);
  const startClient = async (): Promise<void> => {
    try {
      await client.start();
    } catch (error) {
      await config.onError?.(
        error instanceof Error ? error : new Error(String(error))
      );

      if (options.strictStart) {
        throw error;
      }
    }
  };

  if (options.strictStart) {
    await startClient();
  } else {
    void startClient();
  }

  return client;
};