Platform Integration Layers

// Components
export { FormEmbed } from './FormEmbed';
export { FormSelector } from './FormSelector';
export { FormRenderer } from './FormRenderer';
export { ModuleFormsPage } from './ModuleFormsPage'; // NEW v1.1.0

// Hooks
export { useFormList } from './useFormList';
export { useFormDefinition } from './useFormDefinition';
export { useFormSubmission } from './useFormSubmission';

// Types
export type { FormMetadata, FormDefinition, FormSubmission, CoreCode } from './types';

// ✅ CORRECT: Import from platform
import { FormEmbed, useFormList } from '@/platform/forms';

// Filter forms by owning core
const { forms } = useFormList({ owningCore: 'hr' });

// ❌ WRONG: Direct import from core
import { FormEmbed } from '@/cores/fw/forms';

// Example: HR Forms Page
import { ModuleFormsPage } from '@/platform/forms';

export default function HRFormsPage() {
  return (
    <ModuleFormsPage 
      owningCore="hr" 
      moduleDisplayName="HR"
      createFormPath="/hr/forms/new"
    />
  );
}

// Admin Components (internal use)
export { PortalConfigPanel } from '@/cores/fw/components/portal';
export { PortalUrlDisplay } from '@/cores/fw/components/portal';
export { PortalBrandingPreview } from '@/cores/fw/components/portal';
export { PortalLogoUpload } from '@/cores/fw/components/portal';
export { PortalQrCode, PortalQrCodeDialog } from '@/cores/fw/components/portal';

// Public Components (no auth required)
export { PortalFormRenderer } from '@/cores/fw/components/portal';
export { CaptchaWidget } from '@/cores/fw/components/portal';
export { SubmissionSuccess } from '@/cores/fw/components/portal';
export { VerificationPending } from '@/cores/fw/components/portal';

// Hooks
export { usePortalConfig } from '@/cores/fw/hooks';
export { usePortalConfigMutation } from '@/cores/fw/hooks';
export { usePortalLogoUpload } from '@/cores/fw/hooks';
export { usePublicPortal } from '@/cores/fw/hooks';
export { usePortalSubmission } from '@/cores/fw/hooks';

// Types
export type { PortalConfig, PortalSubmission, PortalConfigFormValues } from '@/cores/fw/types';

// Admin: Configure portal in FormEditor
<PortalConfigPanel
  formId={formId}
  organizationId={orgId}
  formName="Application Form"
/>

// Public: Access form via portal URL
// User visits: /p/abc123-token-uuid
// PublicFormPage renders with portal branding

// Components
export { EmployeeSelector } from './EmployeeSelector';
export { CredentialBadge } from './CredentialBadge';

// Hooks
export { useEmployeeLookup } from './useEmployeeLookup';
export { useCredentialCheck } from './useCredentialCheck';

// Types
export type {
  EmployeeLookupResult,
  CredentialCheckResult,
  EmployeeSelectorProps,
  CredentialBadgeProps,
} from './types';

// ✅ CORRECT: Import from platform
import { EmployeeSelector, useCredentialCheck } from '@/platform/workforce';

// Lookup and select employees
<EmployeeSelector 
  onSelect={(emp) => assignToCase(emp.id)} 
  requireCredentials={['RN_LICENSE']}
/>

// Verify credentials
const { checkCredentials } = useCredentialCheck();
const result = await checkCredentials(employeeId, 'BLS_CERT');
if (!result.isValid) {
  alert('Missing required credential');
}

// Hooks
export { useTableLookup } from './useTableLookup';

// Configuration
export { 
  LOOKUP_TABLES,
  getLookupTableConfig,
  getAvailableLookupTables,
  isTableAllowed,
} from './lookupTables';

// Types
export type {
  LookupTableConfig,
  LookupFieldSettings,
  LookupOption,
  UseTableLookupOptions,
  UseTableLookupReturn,
} from './types';

import { useTableLookup } from '@/platform/data-lookup';

function MyComponent() {
  const { options, isLoading, error } = useTableLookup({
    table: 'hr_departments',
    organizationId: currentOrgId,
    filters: { is_active: true }
  });

  return (
    <Select>
      {options.map(opt => (
        <SelectItem key={opt.value} value={opt.value}>
          {opt.label}
        </SelectItem>
      ))}
    </Select>
  );
}

// Types
export * from './types';

// Hooks
export { useCustomFieldDefinitions } from './hooks/useCustomFieldDefinitions';
export { useCustomFieldDefinition } from './hooks/useCustomFieldDefinition';
export { useCustomFieldMutation } from './hooks/useCustomFieldMutation';
export { useCustomFieldValidation } from './hooks/useCustomFieldValidation';

// Utils
export * from './utils';

// Components
export { CustomFieldDefinitionsTable } from './components/CustomFieldDefinitionsTable';
export { CustomFieldDefinitionForm } from './components/CustomFieldDefinitionForm';
export { CustomFieldInput } from './components/CustomFieldInput';
export { CustomFieldRenderer } from './components/CustomFieldRenderer';
export { CustomFieldsSection } from './components/CustomFieldsSection';

import { CustomFieldsSection } from '@/platform/custom-fields';

<Form>
  {/* Standard fields */}
  <FormField name="first_name" />
  <FormField name="last_name" />
  
  {/* Custom fields section */}
  <CustomFieldsSection
    entityType="hr_employees"
    control={form.control}
    title="Additional Information"
  />
</Form>

// Types
export * from './types';

// Field Type Registry
export { 
  FIELD_TYPE_REGISTRY,
  getFWFieldTypes,
  getAllFieldTypes,
  getOptionFieldTypes,
  supportsDataSource,
} from './fieldTypes';

// Hooks
export { useEntityFieldConfigs } from './hooks/useEntityFieldConfigs';
export { useEntityFieldConfig } from './hooks/useEntityFieldConfig';
export { useFieldConfigMutation } from './hooks/useFieldConfigMutation';
export { useFieldVisibility } from './hooks/useFieldVisibility';
export { useConditionalVisibility } from './hooks/useConditionalVisibility';

// Utils
export * from './utils';

// Components
export { FieldConfigTable } from './components/FieldConfigTable';
export { FieldConfigForm } from './components/FieldConfigForm';
export { ConditionalRuleBuilder } from './components/ConditionalRuleBuilder';
export { FieldConfigLayoutEditor } from './components/FieldConfigLayoutEditor';
export { DynamicFormRenderer } from './components/DynamicFormRenderer';
export { ConfigurableForm } from './components/ConfigurableForm';
export { ConfigurableDetailView } from './components/ConfigurableDetailView';

import { ConfigurableForm } from '@/platform/field-config';

// Replace hardcoded forms with configurable forms
<ConfigurableForm
  entityType="hr_employees"
  viewContext="edit_form"
  initialData={employee}
  onSubmit={handleSubmit}
/>

// Service
export { uploadFile, deleteFile } from './service';
export type { UploadOptions, UploadResult, DeleteOptions } from './types';

// Validation
export { validateFile, validateFileType, validateFileSize, getOrganizationUploadSettings } from './validation';

// Image Processing
export { resizeImage, compressImage, generateThumbnail, processImage } from './image-utils';
export type { ImageProcessingOptions, ProcessedImageResult } from './types';

// Hooks
export { useFileUpload } from './hooks';
export type { UseFileUploadOptions, UseFileUploadReturn } from './hooks';
export { useOrganizationUploadSettings } from './hooks';

// Components
export { FileUploadDialog, FileUploadButton, DropZone } from './components';
export type { FileUploadDialogProps, FileUploadButtonProps, DropZoneProps } from './components';

// ✅ CORRECT: Import from platform
import { useFileUpload, FileUploadDialog } from '@/platform/upload';

function DocumentUpload({ organizationId, userId }) {
  const { upload, progress, isLoading, error } = useFileUpload({
    bucket: 'documents',
    organizationId,
    userId,
    entityType: 'documents',
    onSuccess: (result) => console.log('Uploaded:', result.url),
  });

  return (
    <FileUploadDialog
      bucket="documents"
      organizationId={organizationId}
      userId={userId}
      onUploadComplete={(result) => handleUpload(result)}
    />
  );
}

// ❌ WRONG: Direct Supabase storage calls
const { error } = await supabase.storage.from('documents').upload(path, file);

import { uploadFile } from '@/platform/upload';

const result = await uploadFile(file, {
  bucket: 'avatars',
  organizationId,
  userId,
  entityType: 'avatars',
  imageOptions: {
    resize: true,
    maxDimensions: { width: 256, height: 256 },
    compress: true,
    quality: 0.9,
    generateThumbnail: true,
    thumbnailSize: { width: 48, height: 48 },
  },
});

console.log(result.url);          // Full-size image URL
console.log(result.thumbnailUrl); // Thumbnail URL (48x48)

import { parseCsvLine, parseCsv, formatCsvValue, BULK_IMPORT_CHUNK_SIZE } from '@/platform/csv';
const { headers, rows, errors } = parseCsv(csvText);

import { useConditionAttributes } from '@/cores/fw/hooks/useConditionAttributes';

const { attributes, isLoading, search } = useConditionAttributes(organizationId, {
  entityFilter: ['hr_employees'],
  includeCustomFields: true,
  eventPayload: eventSchema, // Optional: for event triggers
});

// Components
export { VariablePanel } from '@/cores/fw/components/variables/VariablePanel';
export { VariablePicker } from '@/cores/fw/components/variables/VariablePicker';
export { ExpressionInput } from '@/cores/fw/components/variables/ExpressionInput';
export { VariableValidationPanel } from '@/cores/fw/components/variables/VariableValidationPanel';
export { VariablePreviewPanel } from '@/cores/fw/components/variables/VariablePreviewPanel';
export { SampleDataProvider } from '@/cores/fw/components/variables/SampleDataProvider';

// Hooks
export { useWorkflowVariables } from '@/cores/fw/hooks/useWorkflowVariables';
export { useVariablePreview } from '@/cores/fw/hooks/useVariablePreview';
export { useExecutionVariables } from '@/cores/fw/hooks/useExecutionVariables';

// Utils
export { workflowVariableValidator } from '@/cores/fw/utils/workflowVariableValidator';

// Edge function shared code
// Location: supabase/functions/_shared/expressionEvaluator.ts

interface ExpressionEvaluator {
  evaluate(expression: string, context: ExecutionContext): ExpressionResult;
  resolveTemplate(template: string, context: ExecutionContext): string;
}

// Using VariablePicker in action configuration
import { VariablePicker } from '@/cores/fw/components/variables/VariablePicker';

<FormField
  control={form.control}
  name="email.subject"
  render={({ field }) => (
    <div className="relative">
      <Input {...field} />
      <VariablePicker
        onInsert={(ref) => {
          const newValue = field.value + `{{${ref}}}`;
          field.onChange(newValue);
        }}
        triggerType={triggerType}
      />
    </div>
  )}
/>

// Functions
export { publishEvent } from './publishEvent';

// Hooks
export { usePublishEvent } from './usePublishEvent';

// Types
export type { KnownEventName, DomainEventInsert, PublishEventParams } from './types';

import { publishEvent, usePublishEvent } from '@/platform/events';

// Direct function call
await publishEvent({
  event_name: 'hr_employee_hired',
  organization_id: employee.organization_id,
  payload: { employee_id: employee.id, department_id: employee.department_id },
});

// React hook (with loading state)
const { publish, isPublishing } = usePublishEvent();
await publish({
  event_name: 'rh_resident_admitted',
  organization_id: episode.organization_id,
  site_id: episode.site_id,
  payload: { episode_id: episode.id, resident_id: episode.resident_id },
});

// Form Field Component
export { SignatureField } from '@/cores/fw/components/fields/SignatureField';

// Hooks
export { useFormSignature } from '@/cores/fw/hooks/useFormSignature';
export { useSignedPDF } from '@/cores/fw/hooks/useSignedPDF';

// Components
export { WorkflowNotificationRulesEditor } from '@/cores/fw/components/notifications/WorkflowNotificationRulesEditor';
export { AlertRulesManager } from '@/cores/fw/components/notifications/AlertRulesManager';
export { AlertsDashboard } from '@/cores/fw/components/notifications/AlertsDashboard';
export { NotificationPreferencesPanel } from '@/cores/fw/components/notifications/NotificationPreferencesPanel';

// Hooks
export { useWorkflowNotifications } from '@/cores/fw/hooks/useWorkflowNotifications';
export { useWorkflowAlertRules } from '@/cores/fw/hooks/useWorkflowAlertRules';
export { useWorkflowAlerts } from '@/cores/fw/hooks/useWorkflowAlerts';
export { useWorkflowNotificationPreferences } from '@/cores/fw/hooks/useWorkflowNotificationPreferences';
export { useUnreadAlertCount } from '@/cores/fw/hooks/useUnreadAlertCount';

// Hooks
export { useQueryWhitelist } from '@/cores/fw/hooks/useQueryWhitelist';
export { useApiConnections } from '@/cores/fw/hooks/useApiConnections';
export { useApiConnectionMutation } from '@/cores/fw/hooks/useApiConnectionMutation';

// Components
export { QueryActionConfig } from '@/cores/fw/components/actions/QueryActionConfig';
export { APIActionConfig } from '@/cores/fw/components/actions/APIActionConfig';
export { ConnectionManager } from '@/cores/fw/components/integrations/ConnectionManager';
export { WhitelistManager } from '@/cores/fw/components/integrations/WhitelistManager';

// Hooks
export { useSandboxExecution } from '@/cores/fw/hooks/useSandboxExecution';
export { useTestDatasets } from '@/cores/fw/hooks/useTestDatasets';
export { useTestScenarios } from '@/cores/fw/hooks/useTestScenarios';
export { useTestCases } from '@/cores/fw/hooks/useTestCases';
export { useTestCoverage } from '@/cores/fw/hooks/useTestCoverage';

// Components
export { SandboxExecutionPanel } from '@/cores/fw/components/testing/SandboxExecutionPanel';
export { TestDatasetManager } from '@/cores/fw/components/testing/TestDatasetManager';
export { TestCaseEditor } from '@/cores/fw/components/testing/TestCaseEditor';
export { TestCoverageVisualization } from '@/cores/fw/components/testing/TestCoverageVisualization';

// Components
export { ExecutionDashboard } from '@/cores/fw/components/monitoring/ExecutionDashboard';
export { ExecutionTrace } from '@/cores/fw/components/monitoring/ExecutionTrace';
export { DebugControls } from '@/cores/fw/components/monitoring/DebugControls';
export { ExecutionReplay } from '@/cores/fw/components/monitoring/ExecutionReplay';
export { ExecutionLogs } from '@/cores/fw/components/monitoring/ExecutionLogs';

// Hooks
export { useExecutionLogs } from '@/cores/fw/hooks/useExecutionLogs';
export { useDebugSession } from '@/cores/fw/hooks/useDebugSession';
export { usePerformanceProfile } from '@/cores/fw/hooks/usePerformanceProfile';
export { useRealtimeExecutions } from '@/cores/fw/hooks/useRealtimeExecutions';

// Real-time execution monitoring
import { useRealtimeExecutions } from '@/cores/fw/hooks/useRealtimeExecutions';

function ExecutionDashboard({ organizationId }) {
  const { executions, isLoading } = useRealtimeExecutions(organizationId);
  
  return (
    <div>
      {executions.map(exec => (
        <ExecutionCard 
          key={exec.id}
          execution={exec}
          onDebug={() => startDebugSession(exec.id)}
        />
      ))}
    </div>
  );
}

// Debug session management
import { useDebugSession } from '@/cores/fw/hooks/useDebugSession';

function DebugPanel({ executionId }) {
  const { 
    session, 
    start, 
    pause, 
    step, 
    resume, 
    variables 
  } = useDebugSession(executionId);
  
  return (
    <div>
      <DebugControls 
        onPause={pause}
        onStep={step}
        onResume={resume}
        status={session?.status}
      />
      <VariableInspector variables={variables} />
    </div>
  );
}

// Components
export { AIAssistantPanel } from './components/AIAssistantPanel';
export { AISuggestionCard } from './components/AISuggestionCard';
export { AILoadingState } from './components/AILoadingState';
export { AIMessageBubble } from './components/AIMessageBubble';

// Hooks
export { useAIChat } from './hooks/useAIChat';
export { useAISuggestions } from './hooks/useAISuggestions';
// PF-62: AI Skills System (extended API)
export { useAISkills } from './hooks/useAISkills';
export { useAISkill } from './hooks/useAISkill';
export { useAISkillChat } from './hooks/useAISkillChat';
export { useCreateAISkill } from './hooks/useCreateAISkill';
export { useUpdateSkillOverride } from './hooks/useUpdateSkillOverride';
export { useModuleDefaultSkill } from './hooks/useModuleDefaultSkill';

// Utils
export { buildPrompt, buildSystemPrompt } from './utils/aiPromptBuilder';

// Types
export type { AIMessage, AIChatOptions, AIModuleContext, AISuggestion } from './types';
// PF-62: AI Skills System (extended types)
export type { AISkill, EffectiveSkill, CreateSkillInput, SkillOverrideInput } from './types';

import { useAIChat, AIAssistantPanel } from '@/platform/ai';

function MyFeature() {
  const { messages, sendMessage, isLoading, error } = useAIChat({
    moduleContext: { module: 'hr', feature: 'onboarding' }
  });
  
  return <AIAssistantPanel />;
}

// Components
export { NotificationCenter } from './NotificationCenter';
export { NotificationItem } from './NotificationItem';
export { NotificationsPage } from './NotificationsPage';
export { NotificationPreferencesPage } from './NotificationPreferencesPage';
export { NotificationDeliveryStatus } from './components/NotificationDeliveryStatus';

// Hooks
export { useNotifications, useUnreadCount } from './useNotifications';
export { useNotificationMutation } from './useNotificationMutation';
export { useNotificationPreferences } from './useNotificationPreferences';
export { useNotificationDelivery } from './hooks/useNotificationDelivery';

import { useNotifications, useNotificationMutation } from '@/platform/notifications';

// Fetch notifications
const { data: notifications, isLoading } = useNotifications(20);
const { markAsRead, markAllAsRead } = useNotificationMutation();

// Mark notification as read
markAsRead.mutate(notificationId);

// Hooks
export { useDocumentUpload } from './useDocumentUpload';
export { useDocumentSearch } from './useDocumentSearch';
export { useDocumentPreview } from './useDocumentPreview';
export { useDocumentVersions } from './useDocumentVersions';
export { useDocumentDownload } from './useDocumentDownload';
export { useDocumentDetail } from './useDocumentDetail';
export { useDocumentMutation } from './useDocumentMutation';
export { useDocumentPermissions } from './useDocumentPermissions';
export { useUserSearch } from './useUserSearch';
export { useDocumentApprovals } from './hooks/useDocumentApprovals';

// Components
export { DocumentLibrary } from './DocumentLibrary';
export { DocumentCard } from './DocumentCard';
export { DocumentUploadDialog } from './DocumentUploadDialog';
export { UploadVersionDialog } from './UploadVersionDialog';
export { DocumentPreview } from './DocumentPreview';
export { DocumentPreviewModal } from './DocumentPreviewModal';
export { ImageViewer } from './ImageViewer';
export { TextViewer } from './TextViewer';
export { DocumentDetailPage } from './DocumentDetailPage';
export { PermissionsManager } from './PermissionsManager';

import { useDocumentUpload, DocumentLibrary } from '@/platform/documents';

// Upload document
const { mutate: uploadDocument } = useDocumentUpload();
uploadDocument({
  file: fileObject,
  title: 'Resident Agreement',
  category: 'legal',
  organizationId: orgId,
});

// Display document library
<DocumentLibrary organizationId={orgId} />

// Hooks
export { useReportList } from './useReportList';
export { useReportDefinition } from './useReportDefinition';
export { useReportExecution } from './useReportExecution';
export { useReportHistory } from './useReportHistory';
export { useCreateReport, useUpdateReport, useDeleteReport } from './useReportMutation';
export { useReportSchedules } from './hooks/useReportSchedules';

import { useReportList, useReportExecution } from '@/platform/reports';

// List available reports
const { data: reports } = useReportList({ organizationId: orgId });

// Execute report
const { execute, executing, result } = useReportExecution();
await execute({
  reportId: report.id,
  params: { startDate: '2025-01-01', endDate: '2025-12-31' },
  format: 'json'
});

// Components
export { AIAssistantPanel } from './components/AIAssistantPanel';
export { AISuggestionCard } from './components/AISuggestionCard';
export { AILoadingState } from './components/AILoadingState';
export { AIMessageBubble } from './components/AIMessageBubble';
export { AIFeedbackButtons } from './components/AIFeedbackButtons';

// Hooks
export { useAIChat } from './hooks/useAIChat';
export { useAISuggestions } from './hooks/useAISuggestions';
export { useAIModuleEnabled } from './hooks/useAIModuleEnabled';
export { useAIStructuredOutput } from './hooks/useAIStructuredOutput';
export { useAIUsageStats } from './hooks/useAIUsageStats';
export { useAIConversations } from './hooks/useAIConversations';
export { useAIConversation } from './hooks/useAIConversation';
export { useAIFeedback } from './hooks/useAIFeedback';
export { useAIReportNarrative } from './hooks/useAIReportNarrative';

// Utils
export { buildPrompt, buildSystemPrompt } from './utils/aiPromptBuilder';

// Types
export type {
  AIMessage, AIRole, AIChatOptions, AIStreamCallbacks,
  AISuggestion, AIContext, AIPromptConfig, AIModuleContext,
  AIUsageLog, AIUsageStats, PHIDetectionResult, AIStructuredOutputOptions,
} from './types';

// Phase 1 (Low Complexity)
export { AIQuickAction } from './AIQuickAction';      // Single-click AI action
export { AISummarizer } from './AISummarizer';        // Summarize text content

// Phase 2 (Medium Complexity)
export { AICategorizer } from './AICategorizer';      // Categorize with confidence

// Phase 3 (Higher Complexity)
export { AIDocumentAnalyzer } from './AIDocumentAnalyzer';  // Analyze documents
export { AIAssistantInline } from './AIAssistantInline';    // Compact inline assistant

// Hooks
export { useTasks } from './hooks/useTasks';
export { useTask } from './hooks/useTask';
export { useMyTasks } from './hooks/useMyTasks';
export { useTaskMutation } from './hooks/useTaskMutation';
export { useTaskComments } from './hooks/useTaskComments';
export { useTaskCommentMutation } from './hooks/useTaskCommentMutation';

// Components
export { TaskCard } from './components/TaskCard';
export { TaskFormDialog } from './components/TaskFormDialog';
export { TaskList } from './components/TaskList';
export { TaskDashboardWidget } from './components/TaskDashboardWidget';
export { SourceTasksPanel } from './components/SourceTasksPanel';
export { AddTaskButton } from './components/AddTaskButton';
export { TaskCommentThread } from './components/TaskCommentThread';

// Pages
export { MyTasksPage } from './pages/MyTasksPage';
export { TaskDetailPage } from './pages/TaskDetailPage';

// Types
export type {
  Task,
  TaskStatus,
  TaskPriority,
  TaskSourceType,
  TaskFilters,
  TaskFormData,
  TaskComment,
} from './types';

// ✅ CORRECT: Import from platform
import { SourceTasksPanel, useTasks } from '@/platform/tasks';

// Display tasks linked to a goal
<SourceTasksPanel
  sourceType="goal"
  sourceId={goalId}
  title="Goal Tasks"
/>

// Fetch tasks for a source
const { data: tasks } = useTasks({
  organizationId,
  sourceType: 'meeting',
  sourceId: meetingId,
});

// Hooks
export { useSwipeToDismiss } from './hooks/useSwipeToDismiss';
export { useSwipeActions } from './hooks/useSwipeActions';
export { usePullToRefresh } from './hooks/usePullToRefresh';
export { useEdgeSwipe } from './hooks/useEdgeSwipe';

// Components
export { SwipeableSheet } from './components/SwipeableSheet';
export { SwipeableListItem } from './components/SwipeableListItem';
export { PullToRefresh } from './components/PullToRefresh';

// Constants
export { GESTURE_THRESHOLDS, ANIMATION_CONFIG, ACTION_COLORS } from './constants';

// Types
export type { SwipeAction, SwipeDirection, GestureState } from './types';

// ✅ CORRECT: Import from platform
import { SwipeableListItem, PullToRefresh } from '@/platform/gestures';

// Swipeable list with actions
<SwipeableListItem
  leftActions={[{ id: 'delete', label: 'Delete', colorClass: 'destructive', onClick: handleDelete }]}
>
  <ItemContent />
</SwipeableListItem>

// Pull-to-refresh wrapper
<PullToRefresh onRefresh={async () => await refetch()}>
  <ScrollableList />
</PullToRefresh>

// Types
export type {
  WizardTemplate,
  WizardModule,
  WizardType,
  WizardConfig,
  WizardStep,
  ParsedWizardTemplate,
} from './types';

export { DEFAULT_WIZARD_CONFIG } from './types';

// Hooks
export { useWizardTemplates } from './hooks/useWizardTemplates';
export { useWizardTemplateDetail } from './hooks/useWizardTemplateDetail';
export { useWizardTemplateMutation } from './hooks/useWizardTemplateMutation';
export { useActiveWizard } from './hooks/useActiveWizard';

// Components (Phase 2+)
// export { WizardBuilder } from './components/WizardBuilder';
// export { ModuleWizardRenderer } from './components/ModuleWizardRenderer';

// ✅ CORRECT: Import from platform
import { useActiveWizard, useWizardTemplates } from '@/platform/wizards';

// Get the active wizard for HR onboarding
const { data: wizard } = useActiveWizard({
  module: 'hr',
  wizardType: 'onboarding',
});

// List all wizard templates
const { data: templates } = useWizardTemplates({ module: 'hr' });

// ❌ WRONG: Direct database queries
const { data } = supabase.from('pf_wizard_templates').select('*');

// Formatting Utilities
export { formatCurrency } from './utils';
export { formatDate, formatDateTime, formatTime } from './utils';
export { formatNumber } from './utils';
export { formatPercent } from './utils';
export { formatPhone } from './utils';

// Hooks
export { useFormattingPreferences } from './hooks';

// Components
export { FormattedCurrency } from './components';
export { FormattedDate } from './components';
export { FormattedNumber } from './components';

// Types
export type {
  CurrencyFormatOptions,
  NumberFormatOptions,
} from './types';

// ✅ CORRECT: Import from platform
import { 
  formatCurrency, 
  formatDate, 
  useFormattingPreferences 
} from '@/platform/formatting';

// Use with organization preferences
const { currency, locale, dateFormat } = useFormattingPreferences();
const formattedAmount = formatCurrency(1234.56, { currency, locale });
const formattedDate = formatDate(new Date(), dateFormat, locale);

// Use components
import { FormattedCurrency, FormattedDate } from '@/platform/formatting';

<FormattedCurrency value={1234.56} />
<FormattedDate value={new Date()} />

// Service
export { uploadFile, deleteFile } from './service';
export type { UploadOptions, UploadResult, UploadProgress, UploadError } from './service';

// Hooks
export { useFileUpload } from './hooks';
export { useOrganizationUploadSettings } from './hooks';

// Components
export { FileUploadDialog } from './components/FileUploadDialog';
export { FileUploadButton } from './components/FileUploadButton';
export { DropZone } from './components/DropZone';

// ✅ CORRECT: Import from platform
import { useFileUpload, FileUploadDialog } from '@/platform/upload';

// Use upload hook
const { upload, progress, isLoading, error } = useFileUpload({
  bucket: 'pf-documents',
  organizationId: orgId,
  userId: userId,
});

// Upload file
const result = await upload(file);

// Use upload dialog
<FileUploadDialog
  open={open}
  onClose={() => setOpen(false)}
  onUpload={(result) => handleUpload(result)}
  bucket="pf-documents"
  acceptedTypes={['image/jpeg', 'image/png', 'application/pdf']}
  maxSizeMb={25}
/>

// ❌ WRONG: Direct implementation or duplicate code
// Don't create custom upload logic in modules

{bucket}/{organization_id}/{entity_type}/{entity_id}/{filename}

// Search utilities
import { useSearch, escapeILikePattern, buildILikeOrConditions } from '@/platform/search';

// Filter utilities
import { applyFilters, createFilter, createFilterGroup, FilterError } from '@/platform/filter';

// Sort utilities
import { applySorting, createSortConfig, createMultiSortConfig, SortError } from '@/platform/sort';

// Pagination utilities
import { calculatePagination, calculateRange, usePagination, useControlledPagination } from '@/platform/pagination';

import { escapeILikePattern, buildILikeOrConditions } from '@/platform/search';
import { applySorting, createSortConfig } from '@/platform/sort';
import { calculateRange } from '@/platform/pagination';

// Build secure search query
const orConditions = buildILikeOrConditions(['name', 'email'], searchTerm);
query = query.or(orConditions);

// Apply sorting
query = applySorting(query, createSortConfig('created_at', 'desc'));

// Apply pagination
const [from, to] = calculateRange({ page, pageSize, total: 0 });
query = query.range(from, to);

// Main Component
export { DataTable } from './DataTable';

// Sub-Components (Phase 1)
export { TablePagination } from './components/TablePagination';
export { SortableHeader } from './components/SortableHeader';
export { TableFilters } from './components/TableFilters';
export { BulkActionsBar } from './components/BulkActionsBar';

// Sub-Components (Phase 2)
export { InlineEditCell } from './components/InlineEditCell';
export { ResizableHeader } from './components/ResizableHeader';
export { VirtualizedTableBody } from './components/VirtualizedTableBody';

// Sub-Components (Phase 3)
export { ColumnManagerPanel } from './components/ColumnManagerPanel';
export { DraggableColumnItem } from './components/DraggableColumnItem';
export { ExportMenu } from './components/ExportMenu';

// Sub-Components (Phase 4)
export { GroupedRows, GroupedRowsControls } from './components/GroupedRows';

// Hooks (Phase 1)
export { useDataTable } from './hooks/useDataTable';

// Hooks (Phase 2)
export { useInlineEdit } from './hooks/useInlineEdit';
export { useColumnResize } from './hooks/useColumnResize';
export { useStickyColumn } from './hooks/useStickyColumn';
export { useVirtualizedRows } from './hooks/useVirtualizedRows';

// Hooks (Phase 3)
export { useColumnManager } from './hooks/useColumnManager';
export { useTableExport } from './hooks/useTableExport';

// Hooks (Phase 4)
export { useRowGrouping } from './hooks/useRowGrouping';

// Types
export type {
  Column,
  ColumnType,
  InlineEditType,
  EditOption,
  BulkAction,
  DataTableProps,
  PaginationConfig,
  SortingConfig,
  FilteringConfig,
  SelectionConfig,
  BulkActionsConfig,
  EmptyStateConfig,
  FooterConfig,
  FooterRow,
  FooterColumn,
  AggregateFunction,
  AggregateConfig,
  GroupNode,
  ExportFormat,
  ExportColumn,
} from './types';

// Utilities
export { formatCellValue, sanitizeValue, sanitizeHeader } from './utils';