server/auth.js

import { createClient } from '@supabase/supabase-js';
import { SUPABASE_URL, SUPABASE_ANON_KEY } from './config.js';

const supabaseAnon = createClient(SUPABASE_URL, SUPABASE_ANON_KEY);

function userClient(accessToken) {
  return createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
    global: { headers: { Authorization: `Bearer ${accessToken}` } },
    auth: { persistSession: false },
  });
}

export async function verifySupabaseToken(accessToken) {
  if (!accessToken) return null;
  try {
    const { data, error } = await supabaseAnon.auth.getUser(accessToken);
    if (error || !data?.user) return null;
    return data.user;
  } catch { return null; }
}

export async function getUserSettings(userId, accessToken) {
  try {
    const uc = userClient(accessToken);
    const { data } = await uc.from('user_settings').select('settings')
      .eq('user_id', userId).single();
    return { ...defaultSettings(), ...(data?.settings || {}) };
  } catch { return defaultSettings(); }
}

export async function saveUserSettings(userId, accessToken, settings) {
  try {
    const uc = userClient(accessToken);
    await uc.from('user_settings').upsert({
      user_id: userId, settings, updated_at: new Date().toISOString(),
    });
  } catch (e) { console.error('saveUserSettings', e.message); }
}

export async function getUserProfile(userId, accessToken) {
  try {
    const uc = userClient(accessToken);
    const { data } = await uc.from('profiles').select('username')
      .eq('id', userId).maybeSingle();
    return data || null;
  } catch { return null; }
}

export async function setUsername(userId, accessToken, username) {
  if (!username?.trim()) return { error: 'Invalid username' };
  const trimmed = username.trim().toLowerCase().replace(/[^a-z0-9_]/g, '');
  if (trimmed.length < 3) return { error: 'Username must be at least 3 characters' };
  try {
    const uc = userClient(accessToken);
    const { data: existing } = await uc.from('profiles')
      .select('id').eq('username', trimmed).maybeSingle();
    if (existing) return { error: 'Username already taken' };
    await uc.from('profiles').upsert({ id: userId, username: trimmed }, { onConflict: 'id' });
    return { success: true, username: trimmed };
  } catch (e) { return { error: e.message }; }
}

export async function getSubscriptionInfo(accessToken) {
  try {
    const r = await fetch('https://sharktide-lightning.hf.space/subscription', {
      headers: { Authorization: `Bearer ${accessToken}`, Accept: 'application/json' },
    });
    if (!r.ok) {
      console.warn(`[Subscription] Failed: HTTP ${r.status}`);
      return null;
    }
    const data = await r.json();    
    // Normalize snake_case keys from HF Space to camelCase
    const normalized = {
      planKey: data.plan_key || null,
      planName: data.plan_name || null,
      email: data.email,
      signedUp: data.signed_up,
      subscription: data.subscription,
    };
    return normalized;
  } catch (err) {
    console.error('[Subscription] Error fetching subscription info:', err.message);
    return null;
  }
}

export async function getTierConfig() {
  try {
    const r = await fetch('https://sharktide-lightning.hf.space/tier-config',
      { headers: { Accept: 'application/json' } });
    return r.ok ? r.json() : null;
  } catch { return null; }
}

export async function getUsageInfo(accessToken, clientId = '') {
  try {
    const h = { Accept: 'application/json' };
    if (accessToken) h.Authorization = `Bearer ${accessToken}`;
    if (clientId) h['X-Client-ID'] = clientId;
    const r = await fetch('https://sharktide-lightning.hf.space/usage', { headers: h });
    const payload = r.ok ? await r.json() : null;
    return payload;
  } catch (err) {
    console.error('[Usage API] request failed:', err.message);
    return null;
  }
}

function defaultSettings() {
  return { theme: 'dark', webSearch: true, imageGen: true, videoGen: true, audioGen: true };
}