API Integration

// src/api/acs/fcc-config.ts
import {apiService} from '@/lib/axios';
import type {FccConfigEntryDto, FccConfigSnapshotDto} from '@/lib/definitions';

export const acsFccConfigApi = {
  // GET snapshot
  getSnapshot: async (): Promise<FccConfigSnapshotDto> => {
    const response = await apiService.get<FccConfigSnapshotDto>('/acs/fcc-config');
    return response.data;
  },

  // PUT bulk update
  updateEntries: async (entries: FccConfigEntryDto[]): Promise<FccConfigSnapshotDto> => {
    const response = await apiService.put<FccConfigSnapshotDto>('/acs/fcc-config', entries);
    return response.data;
  },

  // DELETE single entry
  deleteEntry: async (key: string): Promise<void> => {
    await apiService.delete(`/acs/fcc-config/${encodeURIComponent(key)}`);
  },
};

// Export configuration as file
export const exportConfiguration = async (): Promise<{blob: Blob; filename: string}> => {
  const response = await apiService.get<Blob>('/acs/fcc-config/export', undefined, {
    responseType: 'blob',
  });

  const contentDisposition = response.headers['content-disposition'];
  const filenameMatch = contentDisposition?.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/);
  const filename = filenameMatch?.[1]?.replace(/['"]/g, '') || 'fcc.properties';

  return {
    blob: response.data,
    filename,
  };
};

// Import workflow: dry-run → confirm → apply
export const importWithDryRun = async (
  file: File,
  allowWarnings: boolean = false
): Promise<ImportResultDto> => {
  const formData = new FormData();
  formData.append('file', file);

  // Step 1: Dry-run (validation only)
  const dryRunResponse = await apiService.post<ImportResultDto>(
    '/acs/fcc-config/import/dry-run',
    formData,
    {
      headers: {'Content-Type': 'multipart/form-data'},
    }
  );

  if (dryRunResponse.data.ok && dryRunResponse.data.errors.length === 0) {
    // Step 2: Apply import
    const importResponse = await apiService.post<ImportResultDto>(
      `/acs/fcc-config/import?allowWarnings=${allowWarnings}`,
      formData,
      {
        headers: {'Content-Type': 'multipart/form-data'},
      }
    );
    return importResponse.data;
  }

  return dryRunResponse.data;
};

// Unified error extraction
import {extractUnifiedError} from '@/lib/error-utils';
import {useI18n} from '@/hooks/use-i18n';

const {t} = useI18n();

try {
  await apiService.post('/acs/fcc-config', data);
} catch (error) {
  const unified = extractUnifiedError(error, t);

  console.error('Error details:', {
    type: unified.type,        // 'server' | 'network' | 'validation' | ...
    message: unified.message,   // Localized message
    description: unified.description, // Additional context
    code: unified.code,        // HTTP status or error code
  });
}

import {useErrorHandler} from '@/hooks/use-error-handler';
import {useToast} from '@/hooks/use-toast';

const {handleError} = useErrorHandler();
const {toast} = useToast();

try {
  const result = await apiService.post('/acs/fcc-config', data);

  toast({
    title: t('success'),
    description: t('acsFccConfig.notifications.saveSuccess'),
    variant: 'success',
  });

  return result.data;
} catch (error) {
  handleError(error, {
    title: t('acsFccConfig.notifications.saveError'),
  });
  throw error; // Re-throw if caller needs to handle
}

import {FrontendErrors} from '@/lib/error-utils';

// Validation error
if (!isValid(value)) {
  throw FrontendErrors.validation(
    'Value must be a positive integer',
    'threshold',
    value
  );
}

// Permission error
if (isReadOnly) {
  throw FrontendErrors.permission(
    'Read-only access: editing is disabled',
    'write',
    'configuration'
  );
}

// Missing data error
if (!requiredField) {
  throw FrontendErrors.missingData(
    'Client type must be selected',
    'clientType'
  );
}

const [error, setError] = useState<string | null>(null);

const loadData = async () => {
  setError(null);
  setLoading(true);
  try {
    const data = await apiService.get('/acs/dashboard');
    setSnapshot(data.data);
  } catch (err) {
    handleError(err, {title: t('dashboard.fetchError')});
    setError(t('dashboard.fetchError'));
  } finally {
    setLoading(false);
  }
};

// Retry on user action
const handleRetry = () => {
  void loadData();
};