import { Browser } from "@capacitor/browser";
import { registerPlugin } from "@capacitor/core";
import { Preferences } from "@capacitor/preferences";
import { createEngine } from "../src/engine.js";
import { MemoryResponseCache } from "../src/core/memoryCache.js";
import { PoliteCore } from "../src/core/politeCore.js";
import { createAndroidBrowserFetcher, type NativeWebViewFetcher } from "./androidBrowserFetcher.js";
import { createCapacitorHttpTransport } from "./capacitorHttpTransport.js";
import {
  configureLanguagePersistence,
  isAppLanguage,
  LANGUAGE_STORAGE_KEY,
  resolveAppLanguage,
  setAppLanguage,
  type AppLanguage,
} from "../web/src/app/core/strings.js";

const NativeWebView = registerPlugin<NativeWebViewFetcher>("WebViewFetcher");
const browser = createAndroidBrowserFetcher(NativeWebView);

export const androidEngine = createEngine({
  http: new PoliteCore({ transport: createCapacitorHttpTransport() }),
  browser,
  cache: new MemoryResponseCache(-1),
});

type SolveListener = (storeId: string) => void;

export class AndroidHostBridge {
  private readonly cleared = new Set<SolveListener>();
  private readonly dismissed = new Set<SolveListener>();

  async showSolve(storeId: string): Promise<void> {
    const result = await NativeWebView.show({ storeId });
    const listeners = result.cleared ? this.cleared : this.dismissed;
    for (const listener of listeners) listener(storeId);
  }

  async dismissSolve(storeId: string): Promise<boolean> {
    return (await NativeWebView.dismiss({ storeId })).dismissed;
  }

  onSolveCleared(listener: SolveListener): () => void {
    this.cleared.add(listener);
    return () => this.cleared.delete(listener);
  }

  onSolveDismissed(listener: SolveListener): () => void {
    this.dismissed.add(listener);
    return () => this.dismissed.delete(listener);
  }

  async openOffer(raw: string): Promise<void> {
    await Browser.open({ url: raw, toolbarColor: "#166534" });
  }
}

export const androidHostBridge = new AndroidHostBridge();

export interface AndroidPlanStore {
  get(key: string): Promise<string | null>;
  set(key: string, value: string): Promise<void>;
}

export const androidPlanStore: AndroidPlanStore = {
  async get(key) {
    return (await Preferences.get({ key })).value;
  },
  async set(key, value) {
    await Preferences.set({ key, value });
  },
};

export async function initializeAndroidLanguage(): Promise<void> {
  const savedValue = (await Preferences.get({ key: LANGUAGE_STORAGE_KEY })).value;
  const saved = isAppLanguage(savedValue) ? savedValue : null;
  let legacy: string | null = null;
  if (saved === null) {
    try {
      const legacyValue = globalThis.localStorage?.getItem(LANGUAGE_STORAGE_KEY) ?? null;
      legacy = isAppLanguage(legacyValue) ? legacyValue : null;
    }
    catch { /* Ignore an unreadable legacy WebView preference. */ }
  }

  let deviceLanguages: string[] = [];
  if (saved === null && legacy === null) {
    try { deviceLanguages = (await NativeWebView.getDeviceLanguages()).languages; }
    catch { /* Latvian remains the safe fallback. */ }
  }

  const language = resolveAppLanguage(saved ?? legacy, deviceLanguages);
  setAppLanguage(language);
  configureLanguagePersistence((next: AppLanguage) =>
    Preferences.set({ key: LANGUAGE_STORAGE_KEY, value: next }));

  if (saved === null && legacy === language) {
    await Preferences.set({ key: LANGUAGE_STORAGE_KEY, value: language });
  }
}