'use client';

import { useCallback, useState } from 'react';
import { getCsrfToken } from '@/lib/csrf';
import { fetchWithRefresh } from '@/lib/api/refresh-on-401';
import { captureCaught } from '@/lib/observability';
import type { UserRow } from './UsersMgmt';
import { userDisplayLabel } from './usersMgmt.shared';

interface UseUserActionsArgs {
  t: (key: string) => string;
  tD: (key: string) => string;
  toast: (args: {
    title: string;
    description?: string;
    tone?: 'success' | 'warning' | 'danger';
  }) => void;
  refetch: () => void | Promise<void>;
  data: UserRow[];
  selectedIds: string[];
  setSelectedIds: (ids: string[]) => void;
}

export function useUserActions({
  t,
  tD,
  toast,
  refetch,
  data,
  selectedIds,
  setSelectedIds,
}: UseUserActionsArgs) {
  const [freezeReason, setFreezeReason] = useState('');
  const [quickFreezeUser, setQuickFreezeUser] = useState<UserRow | null>(null);
  const [quickFreezeReason, setQuickFreezeReason] = useState('');
  const [bulkFreezeOpen, setBulkFreezeOpen] = useState(false);
  const [bulkFreezeReason, setBulkFreezeReason] = useState('');
  const [adminConfirmOpen, setAdminConfirmOpen] = useState(false);
  const [actionLoading, setActionLoading] = useState<string | null>(null);
  const [actionError, setActionError] = useState<string | null>(null);
  const [actionSuccess, setActionSuccess] = useState<string | null>(null);

  const postAction = useCallback(
    async (userId: string, segment: string, body?: object) => {
      setActionLoading(segment);
      setActionError(null);
      setActionSuccess(null);
      try {
        const res = await fetchWithRefresh(`/api/admin/users/${userId}/${segment}`, {
          method: 'POST',
          headers: { 'Content-Type': 'application/json', 'x-csrf-token': getCsrfToken() },
          body: body ? JSON.stringify(body) : undefined,
        });
        if (!res.ok) throw new Error(await res.text());
        setActionSuccess(tD('success'));
        await refetch();
        return true;
      } catch (err) {
        captureCaught(err, {
          scope: 'features.admin-users.useUserActions.postAction',
          severity: 'info',
        });
        setActionError(err instanceof Error ? err.message : String(err));
        return false;
      } finally {
        setActionLoading(null);
      }
    },
    [refetch, tD],
  );

  const freezeUser = useCallback(
    async (userId: string, reason: string) => {
      if (!reason.trim()) return false;
      return postAction(userId, 'freeze', { reason: reason.trim() });
    },
    [postAction],
  );

  const unfreezeUser = useCallback(
    async (userId: string) => postAction(userId, 'unfreeze'),
    [postAction],
  );

  const toggleAdminFlag = useCallback(
    async (user: UserRow) => postAction(user.id, 'admin-flag', { isAdmin: !user.isAdmin }),
    [postAction],
  );

  const handleQuickFreeze = useCallback(async () => {
    if (!quickFreezeUser) return;
    const ok = await freezeUser(quickFreezeUser.id, quickFreezeReason);
    if (!ok) return;
    toast({ title: t('freeze'), description: userDisplayLabel(quickFreezeUser), tone: 'success' });
    setQuickFreezeUser(null);
    setQuickFreezeReason('');
  }, [freezeUser, quickFreezeReason, quickFreezeUser, t, toast]);

  const handleBulkFreeze = useCallback(async () => {
    const reason = bulkFreezeReason.trim();
    if (!reason) return;
    for (const id of selectedIds) {
      const ok = await postAction(id, 'freeze', { reason });
      const row = data.find((candidate) => candidate.id === id);
      if (ok) {
        toast({
          title: t('bulk_freeze'),
          description: row ? userDisplayLabel(row) : id,
          tone: 'success',
        });
      } else {
        toast({
          title: t('bulk_freeze_failed').replace('{name}', row ? userDisplayLabel(row) : id),
          description: id,
          tone: 'danger',
        });
      }
    }
    setSelectedIds([]);
    setBulkFreezeOpen(false);
    setBulkFreezeReason('');
  }, [bulkFreezeReason, data, postAction, selectedIds, setSelectedIds, t, toast]);

  return {
    freezeReason,
    setFreezeReason,
    quickFreezeUser,
    setQuickFreezeUser,
    quickFreezeReason,
    setQuickFreezeReason,
    bulkFreezeOpen,
    setBulkFreezeOpen,
    bulkFreezeReason,
    setBulkFreezeReason,
    adminConfirmOpen,
    setAdminConfirmOpen,
    actionLoading,
    actionError,
    actionSuccess,
    setActionError,
    setActionSuccess,
    freezeUser,
    unfreezeUser,
    toggleAdminFlag,
    handleQuickFreeze,
    handleBulkFreeze,
  };
}