ember-market-frontend/components/dashboard/ChatList.tsx

"use client"

import React, { useState, useEffect } from "react";
import { useRouter } from "next/navigation";
import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
import { Badge } from "@/components/ui/badge";
import { Button } from "@/components/ui/button";
import { Avatar, AvatarFallback } from "@/components/ui/avatar";
import { formatDistanceToNow } from "date-fns";
import axios from "axios";
import { toast } from "sonner";
import { getCookie } from "@/lib/client-utils";

interface Chat {
  _id: string;
  buyerId: string;
  vendorId: string;
  storeId: string;
  lastUpdated: string;
  orderId?: string;
}

interface UnreadCounts {
  totalUnread: number;
  chatCounts: Record<string, number>;
}

export default function ChatList() {
  const router = useRouter();
  const [chats, setChats] = useState<Chat[]>([]);
  const [loading, setLoading] = useState(true);
  const [unreadCounts, setUnreadCounts] = useState<UnreadCounts>({ totalUnread: 0, chatCounts: {} });
  const [selectedStore, setSelectedStore] = useState<string>("");
  const [vendorStores, setVendorStores] = useState<{ _id: string, name: string }[]>([]);
  
  // Fetch vendor ID and stores
  useEffect(() => {
    const fetchVendorData = async () => {
      try {
        // Get auth token from cookies
        const authToken = getCookie("Authorization");
        
        if (!authToken) {
          toast.error("You need to be logged in to view chats");
          router.push("/auth/login");
          return;
        }
        
        // Set up axios with the auth token
        const authAxios = axios.create({
          baseURL: process.env.NEXT_PUBLIC_API_URL,
          headers: {
            Authorization: `Bearer ${authToken}`
          }
        });

        // First, get vendor info using the /api/auth/me endpoint
        const vendorResponse = await authAxios.get('/auth/me');
        const vendorId = vendorResponse.data._id;
        
        // Fetch vendor's stores using storefront endpoint
        const storesResponse = await authAxios.get(`/storefront`);
        setVendorStores(storesResponse.data);
        
        if (storesResponse.data.length > 0) {
          setSelectedStore(storesResponse.data[0]._id);
        }
      } catch (error) {
        console.error("Error fetching vendor data:", error);
        toast.error("Failed to load vendor data");
      }
    };
    
    fetchVendorData();
  }, [router]);
  
  // Fetch chats and unread counts when store is selected
  useEffect(() => {
    const fetchChats = async () => {
      if (!selectedStore) return;
      
      setLoading(true);
      try {
        // Get auth token from cookies
        const authToken = getCookie("Authorization");
        
        if (!authToken) {
          toast.error("You need to be logged in");
          router.push("/auth/login");
          return;
        }
        
        // Set up axios with the auth token
        const authAxios = axios.create({
          baseURL: process.env.NEXT_PUBLIC_API_URL,
          headers: {
            Authorization: `Bearer ${authToken}`
          }
        });
        
        // Get vendor ID from profile
        const vendorResponse = await authAxios.get('/api/auth/me');
        const vendorId = vendorResponse.data._id;
        
        // Fetch chats
        const chatsResponse = await authAxios.get(`/api/chats/vendor/${vendorId}`);
        
        // Filter chats by selected store
        const filteredChats = chatsResponse.data.filter(
          (chat: Chat) => chat.storeId === selectedStore
        );
        
        setChats(filteredChats);
        
        // Fetch unread counts
        const unreadResponse = await authAxios.get(`/api/chats/vendor/${vendorId}/unread`);
        setUnreadCounts(unreadResponse.data);
      } catch (error) {
        console.error("Error fetching chats:", error);
        toast.error("Failed to load chats");
      } finally {
        setLoading(false);
      }
    };
    
    fetchChats();
    
    // Set up polling for updates every 30 seconds
    const intervalId = setInterval(fetchChats, 30000);
    
    return () => clearInterval(intervalId);
  }, [selectedStore]);
  
  // Handle chat selection
  const handleChatClick = (chatId: string) => {
    router.push(`/dashboard/chats/${chatId}`);
  };
  
  // Handle store change
  const handleStoreChange = (e: React.ChangeEvent<HTMLSelectElement>) => {
    setSelectedStore(e.target.value);
  };
  
  // Create a new chat
  const handleCreateChat = () => {
    router.push("/dashboard/chats/new");
  };
  
  if (loading) {
    return (
      <Card className="w-full">
        <CardHeader>
          <CardTitle className="flex justify-between items-center">
            <span>Loading chats...</span>
          </CardTitle>
        </CardHeader>
        <CardContent>
          <div className="animate-pulse space-y-4">
            {[1, 2, 3].map((n) => (
              <div key={n} className="h-16 bg-muted rounded-md"></div>
            ))}
          </div>
        </CardContent>
      </Card>
    );
  }
  
  return (
    <Card className="w-full">
      <CardHeader>
        <CardTitle className="flex justify-between items-center">
          <span>Customer Chats</span>
          <Button onClick={handleCreateChat}>New Chat</Button>
        </CardTitle>
        <div className="flex items-center space-x-2">
          <label htmlFor="store-select" className="text-sm font-medium">
            Store:
          </label>
          <select
            id="store-select"
            value={selectedStore}
            onChange={handleStoreChange}
            className="rounded-md border border-input bg-background px-3 py-2 text-sm"
          >
            {vendorStores.map((store) => (
              <option key={store._id} value={store._id}>
                {store.name}
              </option>
            ))}
          </select>
        </div>
      </CardHeader>
      <CardContent>
        {chats.length === 0 ? (
          <div className="text-center py-8 text-muted-foreground">
            <p>No conversations yet</p>
            <Button
              variant="outline"
              className="mt-4"
              onClick={handleCreateChat}
            >
              Start a new conversation
            </Button>
          </div>
        ) : (
          <div className="space-y-4">
            {chats.map((chat) => (
              <div
                key={chat._id}
                className="flex items-center justify-between p-4 rounded-lg border cursor-pointer hover:bg-muted/50 transition-colors"
                onClick={() => handleChatClick(chat._id)}
              >
                <div className="flex items-center space-x-4">
                  <Avatar>
                    <AvatarFallback>
                      {chat.buyerId.slice(0, 2).toUpperCase()}
                    </AvatarFallback>
                  </Avatar>
                  <div>
                    <h4 className="font-medium">Customer {chat.buyerId.slice(-4)}</h4>
                    <p className="text-sm text-muted-foreground">
                      {formatDistanceToNow(new Date(chat.lastUpdated), { addSuffix: true })}
                    </p>
                  </div>
                </div>
                {unreadCounts.chatCounts[chat._id] > 0 && (
                  <Badge variant="destructive">
                    {unreadCounts.chatCounts[chat._id]} unread
                  </Badge>
                )}
              </div>
            ))}
          </div>
        )}
      </CardContent>
    </Card>
  );
}