import { createContext, useContext, useState, useCallback, ReactNode } from "react";

interface Message {
  id: string;
  text: string;
  sender: "user" | "agent";
  timestamp: Date;
}

interface ChatContextType {
  messages: Message[];
  chatId: string | null;
  isLoading: boolean;
  addMessage: (message: Message) => void;
  setChatId: (id: string) => void;
  setLoading: (loading: boolean) => void;
  clearChat: () => void;
}

const ChatContext = createContext<ChatContextType | undefined>(undefined);

interface ChatProviderProps {
  children: ReactNode;
  initialMessage?: string;
}

export function ChatProvider({ children, initialMessage }: ChatProviderProps) {
  const [messages, setMessages] = useState<Message[]>(() => {
    // Add initial message if provided
    if (initialMessage) {
      return [
        {
          id: "initial-message",
          text: initialMessage,
          sender: "agent",
          timestamp: new Date(),
        },
      ];
    }
    return [];
  });
  const [chatId, setChatIdState] = useState<string | null>(null);
  const [isLoading, setIsLoading] = useState(false);

  const addMessage = useCallback((message: Message) => {
    setMessages((prev) => [...prev, message]);
  }, []);

  const setChatId = useCallback((id: string) => {
    setChatIdState(id);
  }, []);

  const setLoading = useCallback((loading: boolean) => {
    setIsLoading(loading);
  }, []);

  const clearChat = useCallback(() => {
    setMessages([]);
    setChatIdState(null);
    setIsLoading(false);
  }, []);

  return (
    <ChatContext.Provider
      value={{
        messages,
        chatId,
        isLoading,
        addMessage,
        setChatId,
        setLoading,
        clearChat,
      }}
    >
      {children}
    </ChatContext.Provider>
  );
}

export function useChatContext() {
  const context = useContext(ChatContext);
  if (context === undefined) {
    throw new Error("useChatContext must be used within a ChatProvider");
  }
  return context;
}