const API_BASE = process.env.NEXT_PUBLIC_API_URL || '/api';

interface ApiResponse<T> {
  data?: T;
  error?: string;
}

async function request<T>(
  endpoint: string,
  options: RequestInit = {}
): Promise<ApiResponse<T>> {
  const token = typeof window !== 'undefined' ? localStorage.getItem('sc_token') : null;
  
  const headers: Record<string, string> = {
    'Content-Type': 'application/json',
    ...((options.headers as Record<string, string>) || {}),
  };
  
  if (token) {
    headers['Authorization'] = `Bearer ${token}`;
  }
  
  try {
    const res = await fetch(`${API_BASE}${endpoint}`, {
      ...options,
      headers,
    });
    
    const data = await res.json();
    
    if (!res.ok) {
      return { error: data.error || 'Request failed' };
    }
    
    return { data };
  } catch (err) {
    return { error: 'Network error' };
  }
}

// Auth
export async function signup(email: string, password: string, telegramUsername?: string) {
  return request<{
    success: boolean;
    token: string;
    user: {
      id: string;
      email: string;
      plan: string;
      telegram_username: string;
      bot_token: string;
    };
  }>('/auth/signup', {
    method: 'POST',
    body: JSON.stringify({ email, password, telegram_username: telegramUsername }),
  });
}

export async function login(email: string, password: string) {
  return request<{
    success: boolean;
    token: string;
    user: {
      id: string;
      email: string;
      plan: string;
      telegram_username: string;
      telegram_chat_id: number | null;
      bot_token: string;
    };
  }>('/auth/login', {
    method: 'POST',
    body: JSON.stringify({ email, password }),
  });
}

export async function getMe() {
  return request<{
    user: {
      id: string;
      email: string;
      plan: string;
      role: string;
      telegram_username: string;
      telegram_chat_id: number | null;
      subscription_status: string;
      bot_token: string;
    };
  }>('/auth/me');
}

// User
export async function getDashboard() {
  return request<{
    user: {
      id: string;
      email: string;
      plan: string;
      telegram_username: string;
      telegram_connected: boolean;
    };
    usage: {
      today: number;
      limit: number;
      remaining: number;
      unlimited: boolean;
    };
    bot: {
      token: string;
      link: string;
      username: string;
    };
    stats: Array<{ date: string; query_count: number }>;
  }>('/user/dashboard');
}

export async function getTelegramLink() {
  return request<{
    link: string;
    bot_username: string;
  }>('/user/telegram-link');
}

// Billing
export async function createCheckout(plan: 'weekly' | 'monthly') {
  return request<{ url: string }>('/billing/checkout', {
    method: 'POST',
    body: JSON.stringify({ plan }),
  });
}

export async function createPortal() {
  return request<{ url: string }>('/billing/portal', {
    method: 'POST',
  });
}

// Admin
export async function getAdminUsers() {
  return request<{ users: any[] }>('/admin/users');
}

export async function updateUserRole(userId: string, role: 'user' | 'admin') {
  return request<{ success: boolean }>(`/admin/users/${userId}/role`, {
    method: 'PUT',
    body: JSON.stringify({ role }),
  });
}

export async function freezeUserAccount(userId: string, frozen: boolean) {
  return request<{ success: boolean }>(`/admin/users/${userId}/freeze`, {
    method: 'PUT',
    body: JSON.stringify({ frozen }),
  });
}

export async function getAdminAudit(limit = 50) {
  return request<{ entries: any[] }>(`/admin/audit?limit=${limit}`);
}

export async function getSystemHealth() {
  return request<{ global_state: any; unresolved_events: any }>('/admin/system/health');
}

export async function getSystemProcesses() {
  return request<{ processes: any[] }>('/admin/system/processes');
}

export async function getSystemEvents(params?: { limit?: number; severity?: string; unresolved?: boolean }) {
  const qs = new URLSearchParams();
  if (params?.limit) qs.set('limit', String(params.limit));
  if (params?.severity) qs.set('severity', params.severity);
  if (params?.unresolved) qs.set('unresolved', 'true');
  return request<{ events: any[] }>(`/admin/system/events?${qs.toString()}`);
}

export async function getDataFreshness() {
  return request<{ freshness: any[] }>('/admin/system/data-freshness');
}

export async function unfreezeSystem() {
  return request<{ success: boolean }>('/admin/system/unfreeze', { method: 'POST' });
}

// Auth helpers
export function setToken(token: string) {
  if (typeof window !== 'undefined') {
    localStorage.setItem('sc_token', token);
  }
}

export function getToken(): string | null {
  if (typeof window !== 'undefined') {
    return localStorage.getItem('sc_token');
  }
  return null;
}

export function clearToken() {
  if (typeof window !== 'undefined') {
    localStorage.removeItem('sc_token');
  }
}

export function isLoggedIn(): boolean {
  return !!getToken();
}