import * as SecureStore from "expo-secure-store";
import type { MobileConfig, StoredMobileConfig } from "../types/mobileConfig";

const MOBILE_CONFIG_KEY = "mf_mobile_config";

let mobileConfigCache: StoredMobileConfig | null = null;

function isValidHexColor(value: string): boolean {
  return /^#[0-9A-Fa-f]{6}$/.test(value);
}

function stripTrailingSlashes(value: string): string {
  let out = value;
  while (out.endsWith("/")) {
    out = out.slice(0, -1);
  }
  return out;
}

function sanitizeMobileConfig(raw: MobileConfig): MobileConfig {
  const appName = String(raw.app_name || "").trim();
  const primaryColor = String(raw.primary_color || "").trim();

  if (!appName) {
    throw new Error("mobile-config invalide: app_name manquant.");
  }

  if (!isValidHexColor(primaryColor)) {
    throw new Error("mobile-config invalide: primary_color doit etre un hex #RRGGBB.");
  }

  const supportEmail = raw.support_email ? String(raw.support_email).trim() : "";
  const supportPhone = raw.support_phone ? String(raw.support_phone).trim() : "";

  return {
    app_name: appName,
    primary_color: primaryColor,
    logo_url: raw.logo_url ? String(raw.logo_url).trim() : null,
    tenant_id: raw.tenant_id ?? null,
    support_email: supportEmail || null,
    support_phone: supportPhone || null,
  };
}

export async function saveMobileConfig(
  baseUrl: string,
  config: MobileConfig
): Promise<StoredMobileConfig> {
  const stored: StoredMobileConfig = {
    base_url: stripTrailingSlashes(baseUrl),
    config: sanitizeMobileConfig(config),
    saved_at: new Date().toISOString(),
  };

  mobileConfigCache = stored;
  await SecureStore.setItemAsync(MOBILE_CONFIG_KEY, JSON.stringify(stored));
  return stored;
}

export async function getMobileConfig(): Promise<StoredMobileConfig | null> {
  if (mobileConfigCache) {
    return mobileConfigCache;
  }

  const raw = await SecureStore.getItemAsync(MOBILE_CONFIG_KEY);
  if (!raw) {
    return null;
  }

  try {
    const parsed = JSON.parse(raw) as StoredMobileConfig;
    if (!parsed || typeof parsed.base_url !== "string" || !parsed.config) {
      return null;
    }

    const normalized: StoredMobileConfig = {
      base_url: stripTrailingSlashes(parsed.base_url),
      config: sanitizeMobileConfig(parsed.config),
      saved_at: String(parsed.saved_at || ""),
    };

    mobileConfigCache = normalized;
    return normalized;
  } catch {
    return null;
  }
}

export async function getMobileConfigForBaseUrl(
  baseUrl: string
): Promise<StoredMobileConfig | null> {
  const stored = await getMobileConfig();
  if (!stored) {
    return null;
  }

  return stored.base_url === stripTrailingSlashes(baseUrl) ? stored : null;
}

export async function clearMobileConfig(): Promise<void> {
  mobileConfigCache = null;
  await SecureStore.deleteItemAsync(MOBILE_CONFIG_KEY);
}