'use client';

import { useQueryClient } from '@tanstack/react-query';
import { createContext, useCallback, useContext, useEffect, useMemo, useState, type ReactNode } from 'react';

import { ApiError, api, getAccessToken, refreshSession, setAccessToken } from '@/lib/api-client';
import { queryKeys } from '@/lib/query-keys';
import type { Permission } from '@/shared/permissions';
import type { MeResponse, TenantSummary, UserSummary } from '@/shared/types';

/** `unavailable`: the session could not be restored for a transient reason (rate limit, outage). */
export type AuthStatus = 'loading' | 'authenticated' | 'anonymous' | 'unavailable';

export interface AuthState {
  status: AuthStatus;
  /** Seconds the server asked us to wait, when `status` is `unavailable`. */
  retryAfterSeconds: number | null;
  /** Tries to restore the session again after it was `unavailable`. */
  retrySession: () => void;
  user: UserSummary | null;
  tenant: TenantSummary | null;
  permissions: readonly Permission[];
  login: (email: string, password: string) => Promise<MeResponse>;
  logout: () => Promise<void>;
  refreshMe: () => Promise<MeResponse>;
}

const AuthContext = createContext<AuthState | null>(null);

export function AuthProvider({ hasSession, children }: { hasSession: boolean; children: ReactNode }) {
  const queryClient = useQueryClient();
  const [status, setStatus] = useState<AuthStatus>(hasSession ? 'loading' : 'anonymous');
  const [user, setUser] = useState<UserSummary | null>(null);
  const [tenant, setTenant] = useState<TenantSummary | null>(null);
  const [permissions, setPermissions] = useState<readonly Permission[]>([]);
  const [retryAfterSeconds, setRetryAfterSeconds] = useState<number | null>(null);
  const [attempt, setAttempt] = useState(0);

  const refreshMe = useCallback(async (): Promise<MeResponse> => {
    const me = await api<MeResponse>('/auth/me');
    setUser(me.user);
    setTenant(me.tenant);
    setPermissions(me.permissions);
    setStatus('authenticated');
    queryClient.setQueryData(queryKeys.me, me);
    return me;
  }, [queryClient]);

  useEffect(() => {
    if (!hasSession) return;
    let active = true;
    void refreshSession().then(async (outcome) => {
      if (!active) return;
      if (outcome.status === 'invalid') {
        setStatus('anonymous');
        return;
      }
      if (outcome.status === 'unavailable') {
        // Keep the user "signed in but offline" instead of anonymous: redirecting to /login
        // while the session cookie is still set would bounce straight back here in a loop.
        setRetryAfterSeconds(outcome.retryAfterSeconds ?? null);
        setStatus('unavailable');
        return;
      }
      try {
        await refreshMe();
      } catch (error) {
        if (!active) return;
        if (error instanceof ApiError && (error.status === 401 || error.status === 403)) {
          setStatus('anonymous');
        } else {
          setRetryAfterSeconds(error instanceof ApiError ? (error.retryAfterSeconds ?? null) : null);
          setStatus('unavailable');
        }
      }
    });
    return () => {
      active = false;
    };
  }, [hasSession, refreshMe, attempt]);

  const retrySession = useCallback(() => {
    setRetryAfterSeconds(null);
    setStatus('loading');
    setAttempt((value) => value + 1);
  }, []);

  const value = useMemo<AuthState>(
    () => ({
      status,
      retryAfterSeconds,
      retrySession,
      user,
      tenant,
      permissions,
      login: async (email, password) => {
        const session = await api<{ accessToken: string }>('/auth/login', {
          json: { email, password },
        });
        setAccessToken(session.accessToken);
        return refreshMe();
      },
      logout: async () => {
        const token = getAccessToken();
        await fetch('/api/auth/logout', {
          method: 'POST',
          credentials: 'include',
          headers: {
            'x-requested-with': 'fetch',
            ...(token === null ? {} : { authorization: `Bearer ${token}` }),
          },
        }).catch(() => undefined);
        setAccessToken(null);
        setUser(null);
        setTenant(null);
        setPermissions([]);
        setStatus('anonymous');
        queryClient.removeQueries({ queryKey: queryKeys.me });
      },
      refreshMe,
    }),
    [permissions, queryClient, refreshMe, retryAfterSeconds, retrySession, status, tenant, user],
  );

  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
}

export const useAuth = (): AuthState => {
  const value = useContext(AuthContext);
  if (value === null) throw new Error('useAuth must be used within AuthProvider');
  return value;
};
