/**
 * Backward-compatible shim that exposes a supabase-shaped client backed
 * by the local Express API (`src/lib/api.ts`). Existing components that
 * use `supabase.rpc(...)`, `supabase.from(view).select(...).eq(...)` and
 * `supabase.auth.*` keep working unchanged.
 */
import { api, type ApiSession } from '@/lib/api';

type Result<T> = Promise<{ data: T | null; error: { message: string } | null }>;

interface SelectBuilder<T> extends Result<T[]> {
  eq(column: string, value: string | number | boolean): SelectBuilder<T>;
}

function makeSelectBuilder<T>(view: string): SelectBuilder<T> {
  const filters: Record<string, string | number | boolean> = {};
  const exec = () => api.fromView<T>(view, filters);
  const builder = {
    eq(column: string, value: string | number | boolean) {
      filters[column] = value;
      return builder as SelectBuilder<T>;
    },
    then(onFulfilled?: Parameters<Promise<unknown>['then']>[0],
         onRejected?: Parameters<Promise<unknown>['then']>[1]) {
      return exec().then(onFulfilled as never, onRejected as never);
    },
  } as unknown as SelectBuilder<T>;
  return builder;
}

export const supabase = {
  auth: {
    async signInWithPassword(args: { email: string; password: string }) {
      const { data, error } = await api.auth.signInWithPassword(args);
      return { data: { session: data.session as ApiSession | null }, error };
    },
    async signOut() { return api.auth.signOut(); },
    async getSession() { return api.auth.getSession(); },
    onAuthStateChange(
      cb: (event: string, session: ApiSession | null) => void,
    ) {
      return api.auth.onAuthStateChange((event, session) => cb(event, session));
    },
  },

  rpc<T = unknown>(fn: string, args?: Record<string, unknown>) {
    return api.rpc<T>(fn, args);
  },

  from<T = unknown>(view: string) {
    return {
      select(_cols?: string) {
        return makeSelectBuilder<T>(view);
      },
    };
  },
};

export default supabase;