interface UseChatOptions {
  chatbot?: {
    id?: string;
    prompt?: string;
    allowedDomains?: string[];
    strictDomain?: boolean;
  };
  baseUrl?: string;
  telemetry?: TelemetryProvider;
  errorTracker?: ErrorTracker;
  onReady?: (sessionId: string) => void;
}

interface ChatbotConfig {
  id?: string;
  prompt?: string;
  allowedDomains?: string[];
  strictDomain?: boolean;
}

interface TelemetryProvider {
  initializeSession: (data: SessionInitData) => void;
  trackEvent: (event: string, properties?: Record<string, any>) => void;
  trackError: (error: Error, context?: Record<string, any>) => void;
}

interface SessionInitData {
  chatbotId: string;
  sessionId: string;
  deviceInfo?: DeviceInfo;
  userPreferences?: UserPreferences;
}

interface DeviceInfo {
  userAgent: string;
  language: string;
  languages: string[];
  platform: string;
  cookieEnabled: boolean;
  onLine: boolean;
  screenWidth: number;
  screenHeight: number;
  timezone: string;
  timestamp: string;
}

interface UserPreferences {
  theme: "light" | "dark";
  language: string;
  timezone: string;
}

interface ErrorTracker {
  captureException: (error: Error, context?: Record<string, any>) => void;
  captureMessage: (message: string, level?: 'info' | 'warning' | 'error', context?: Record<string, any>) => void;
}

interface UseChatReturn {
  // Session management
  sessionId: string;
  isSessionReady: boolean;
  telemetryInitialized: boolean;
  initializeSession: (sessionId: string) => void;
  
  // Chat functionality
  messages: Message[];
  sendMessage: (message: string, body?: Record<string, any>) => void;
  handleSendMessage: (message: string, body?: Record<string, any>) => void;
  clearMessages: () => void;
  finishSession: () => void;
  
  // Status and control
  status: "idle" | "streaming" | "submitted" | "error";
  stop: () => void;
  setMessages: (messages: Message[]) => void;
  regenerate: () => void;
  onCancel: () => void;
  
  // Status flags
  isChatLoading: boolean;
  isError: boolean;
  errorMessage?: string;
}

initializeSession(sessionId: string): void

const { initializeSession, sessionId } = useChat(options);

// Manually initialize session
useEffect(() => {
  if (sessionId) {
    initializeSession(sessionId);
  }
}, [sessionId, initializeSession]);

sendMessage(message: string, body?: Record<string, any>): void

const { sendMessage } = useChat(options);

// Send a simple message
sendMessage("Hello, how are you?");

// Send a message with additional data
sendMessage("Hello", { 
  userId: "123", 
  context: "support" 
});

clearMessages(): void

const { clearMessages } = useChat(options);

// Clear messages and start fresh
const handleNewChat = () => {
  clearMessages();
};

finishSession(): void

const { finishSession } = useChat(options);

// Finish session when component unmounts
useEffect(() => {
  return () => {
    finishSession();
  };
}, [finishSession]);

onReady?: (sessionId: string) => void

const { sessionId } = useChat({
  // ... other options
  onReady: (sessionId) => {
    console.log(`Session ready: ${sessionId}`);
    // Perform any initialization that depends on the session
    initializeUserPreferences(sessionId);
    trackSessionStart(sessionId);
  },
});

// Error tracking integration
const errorTracker = {
  captureException: (error: Error, context?: Record<string, any>) => {
    // Send to your error tracking service
    console.error("Exception:", error, context);
  },
  captureMessage: (message: string, level?: string, context?: Record<string, any>) => {
    // Log important messages
    console.log(`[${level}] ${message}`, context);
  },
};