import { ID, Permission, Query, Role, account, databaseId, tables, teams } from './appwrite';

/** Eine Zeile aus `brands`, so weit die App sie braucht. */
export type Brand = {
  $id: string;
  team_id?: string;
  label_name: string;
  anzeigename?: string;
  nische?: string;
  plan?: string;
  status?: string;
};

export type Konto = { $id: string; email: string; name: string };

export async function aktuellesKonto(): Promise<Konto | null> {
  try {
    const u = await account.get();
    return { $id: u.$id, email: u.email, name: u.name };
  } catch {
    return null; // keine Session – kein Fehlerfall, sondern der Normalzustand vor dem Login
  }
}

/**
 * Die Brand des angemeldeten Kontos.
 *
 * Es braucht hier bewusst **keinen** Filter auf die eigene ID: `brands` hat
 * `rowSecurity`, und die Zeile trägt nur die Team-Permission ihrer Brand. Die
 * Abfrage liefert deshalb von sich aus ausschließlich die eigene Zeile. Genau
 * das ist die Mandantentrennung – sie steckt in den Rechten, nicht im Query.
 */
export async function eigeneBrand(): Promise<Brand | null> {
  const res = await tables.listRows({
    databaseId,
    tableId: 'brands',
    queries: [Query.limit(1)],
  });
  return (res.rows[0] as unknown as Brand) ?? null;
}

/**
 * Legt Team + `brands`-Zeile an, falls beides noch fehlt.
 *
 * Eigene Funktion, weil die Registrierung aus vier Schritten besteht und
 * zwischen Schritt 2 und 4 abbrechen kann (Netz weg, App geschlossen). Dann
 * existiert ein Konto ohne Brand. Statt diesen Zustand als Fehler zu behandeln,
 * wird er beim nächsten Start einfach nachgeholt.
 */
export async function brandSicherstellen(labelName: string): Promise<Brand> {
  const vorhanden = await eigeneBrand();
  if (vorhanden) return vorhanden;

  const meine = await teams.list({ queries: [Query.limit(1)] });
  const team = meine.teams[0] ?? (await teams.create({ teamId: ID.unique(), name: labelName }));

  const rolle = Role.team(team.$id);
  const row = await tables.createRow({
    databaseId,
    tableId: 'brands',
    rowId: ID.unique(),
    data: { team_id: team.$id, label_name: labelName, status: 'trial', plan: 'trial' },
    // Kein create() – die Zeile existiert ja bereits. Lesen/Ändern/Löschen
    // ausschließlich für das Team dieser Brand.
    permissions: [Permission.read(rolle), Permission.update(rolle), Permission.delete(rolle)],
  });
  return row as unknown as Brand;
}

export async function registrieren(email: string, password: string, labelName: string): Promise<Brand> {
  await account.create({ userId: ID.unique(), email, password, name: labelName });
  await account.createEmailPasswordSession({ email, password });
  return brandSicherstellen(labelName);
}

export async function anmelden(email: string, password: string): Promise<void> {
  await account.createEmailPasswordSession({ email, password });
}

export async function abmelden(): Promise<void> {
  await account.deleteSession({ sessionId: 'current' });
}

/** Appwrite-Fehler tragen die Meldung in `message`; alles andere abfangen. */
export function fehlertext(e: unknown): string {
  if (e && typeof e === 'object' && 'message' in e) return String((e as { message: unknown }).message);
  return 'Unbekannter Fehler.';
}
