'use client';

import React, { useState, useRef, useEffect } from 'react';
import { Input, Tooltip, Drawer, Modal, message, notification } from 'antd';
import {
  CheckOutlined,
  CloseOutlined,
  DownloadOutlined,
  EnvironmentOutlined,
  FileOutlined,
  FilePdfOutlined,
  LoadingOutlined,
  SearchOutlined,
  SendOutlined,
  UnorderedListOutlined,
} from '@ant-design/icons';
import { useSession } from 'next-auth/react';
import { Message } from '../types';
import { downloadWhatsAppMedia, getConversationMessages, getMyWhatsAppNumber, getWhatsAppTemplates, sendProjectDetails, sendWhatsAppMessage, uploadWhatsAppMedia } from '../service';
import { getProjects, getProject } from '@/app/launches/service';
import { getLeadData } from '@/app/enquiries/service';
import { useLeadCall } from '@/hooks/useLeadCall';
import CallIcon from '@/components/CallIcon';
import { useChatLogic, mergeMessages, formatTimeStr } from './useChatLogic';
import { useWhatsAppSocket } from './useWhatsAppSocket';
import { useDebounce } from 'use-debounce';
import SendLocationModal, { LocationPayload } from './SendLocationModal';

// TEMPORARY (location testing): always show and enable the message box, even with no WhatsApp number assigned,
// outside the 24-hour window, on a lead assigned to someone else, or before any message exists.
// Set to false to restore the normal rules.
const ALWAYS_SHOW_COMPOSER = false;

// WhatsApp rejects a text body longer than this; the backend enforces the same limit
const MAX_TEXT_LENGTH = 4096;
const countChars = (value: string): number => Array.from(value).length;

const formatWhatsAppStyle = (text: string): string => {
  if (!text) return '';
  // Replace *bold* with <strong>bold</strong>
  let formatted = text.replace(/\*(.*?)\*/g, '<strong>$1</strong>');
  // Replace newlines with <br />
  formatted = formatted.replace(/\n/g, '<br />');
  return formatted;
};

const linkify = (text: string): string => {
  if (!text) return '';
  const parts = text.split(/(<[^>]*>)/g);
  const urlRegex = /(https?:\/\/[^\s<]+)/g;
  const processed = parts.map((part) => {
    if (part.startsWith('<')) {
      return part;
    }
    return part.replace(urlRegex, (url) => {
      return `<a href="${url}" target="_blank" rel="noopener noreferrer" style="color: #008a3d; text-decoration: underline;">${url}</a>`;
    });
  });
  return processed.join('');
};

const formatMessageText = (text: string): string => {
  if (!text) return '';
  const linkified = linkify(text);
  const parts = linkified.split(/(<[^>]*>)/g);
  const boldProcessed = parts.map((part) => {
    if (part.startsWith('<')) {
      return part;
    }
    return part.replace(/\*(.*?)\*/g, '<strong>$1</strong>');
  });
  return boldProcessed.join('');
};

const IMAGE_EXT_REGEX = /\.(jpe?g|png|gif|webp|bmp|svg)(\?.*)?$/i;
const PDF_EXT_REGEX = /\.pdf(\?.*)?$/i;
const ALLOWED_DOCUMENT_EXT_REGEX = /\.(pdf|docx?|xlsx?|txt)$/i;
const URL_REGEX = /^https?:\/\/\S+$/i;

type MediaKind = 'image' | 'document' | 'text';

const getMediaUrl = (text: string): string => {
  const attachmentMatch = text.match(/\[Attachment URL:\s*(https?:\/\/[^\]\s]+)\]/i);
  return attachmentMatch?.[1] || text.trim();
};

const isWhatsAppMediaUrl = (value: string): boolean => {
  try {
    const url = new URL(value.trim());
    return url.hostname.toLowerCase() === 'housiey-crm.blr1.digitaloceanspaces.com'
      && url.pathname.toLowerCase().startsWith('/whatsapp-media/');
  } catch {
    return false;
  }
};

const getMediaKind = (msg: Message): MediaKind => {
  console.log("msg  ", msg);
  const text = getMediaUrl(msg.text || '');
  const type = (msg.message_type || '').toLowerCase();
  const isUrl = URL_REGEX.test(text);
  const isHostedMedia = isWhatsAppMediaUrl(text);

  if (isUrl && !isHostedMedia) return 'text';
  if (type === 'image' || IMAGE_EXT_REGEX.test(text)) return 'image';
  if (type && !['text', 'template', 'interactive', 'location'].includes(type)) return 'document';
  if (isHostedMedia || /\[Attachment URL:/i.test(msg.text || '')) return 'document';
  return 'text';
};

// Location messages are stored as "📍 Name\nAddress\nhttps://www.google.com/maps?q=lat,lng"
const parseLocationText = (text: string): { title: string; address: string; url: string } => {
  const lines = (text || '').split('\n').map((line) => line.trim()).filter(Boolean);
  const url = lines.length && URL_REGEX.test(lines[lines.length - 1]) ? lines.pop()! : '';
  const title = (lines.shift() || '').replace(/^📍\s*/, '') || 'Location';
  return { title, address: lines.join(', '), url };
};

const getFileNameFromMessage = (msg: Message, mediaUrl = getMediaUrl(msg.text)): string => {
  if (msg.fileName) return msg.fileName;
  try {
    const url = new URL(mediaUrl);
    const last = url.pathname.split('/').filter(Boolean).pop();
    if (last) return decodeURIComponent(last);
  } catch {
    // not a valid URL, fall through
  }
  return 'Attachment';
};

const formatFileName = (fileName: string): string => {
  const extensionIndex = fileName.lastIndexOf('.');
  const hasExtension = extensionIndex > 0;
  const baseName = hasExtension ? fileName.slice(0, extensionIndex) : fileName;
  const extension = hasExtension ? fileName.slice(extensionIndex) : '';
  return baseName.length > 20 ? `${baseName.slice(0, 20)}...${extension}` : fileName;
};

const FileNameLabel: React.FC<{ fileName: string; style?: React.CSSProperties }> = ({ fileName, style }) => (
  <Tooltip title={fileName}>
    <span className="wa-bubble-file-name" style={style}>{formatFileName(fileName)}</span>
  </Tooltip>
);

const buildProjectTemplate = (proj: any): string => {
  if (!proj) return '';

  const name = proj.name ? `*${proj.name}*` : '';
  const builder = proj.builder_name ? ` By *${proj.builder_name}*` : '';

  let text = '';
  if (name || builder) {
    text += `Project: ${name}${builder}\n\n`;
  }
  const city = proj?.city_name || "";
  const location = proj?.location ? `${proj?.location}, ${city}` : city;
  text += `*Location*\n${location || "-"}\n\n`;

  // Overview
  let overview = proj.overview || '';
  if (!overview) {
    const parts = [];
    if (proj.land_parcel !== undefined && proj.land_parcel !== null && proj.land_parcel !== '') {
      parts.push(`${proj.land_parcel} Acres`);
    }
    if (proj.no_of_towers !== undefined && proj.no_of_towers !== null && proj.no_of_towers !== '') {
      parts.push(`${proj.no_of_towers} Towers`);
    }
    if (proj.no_of_floors !== undefined && proj.no_of_floors !== null && proj.no_of_floors !== '') {
      parts.push(`${proj.no_of_floors} Floors`);
    }
    overview = parts.join(' - ');
  }
  if (overview) {
    text += `*Overview*\n${overview}\n\n`;
  }

  // Apartments
  const apartments = proj.config || '';
  if (apartments) {
    text += `*Apartments*\n${apartments}\n\n`;
  }

  // Pricing
  const pricingStr = proj.overall_price_range || '';
  if (pricingStr) {
    text += `*Pricing*\n${pricingStr}\n\n`;
  }

  // Possession
  const possessionParts = [];
  if (proj.rera_possession) {
    possessionParts.push(`RERA Possession - ${proj.rera_possession}`);
  }
  if (proj.target_possession) {
    possessionParts.push(`Target Possession - ${proj.target_possession}`);
  }
  const possession = possessionParts.join('\n');
  if (possession) {
    text += `*Possession*\n${possession}\n\n`;
  }

  // For In Depth details
  text += `For In Depth details including -\n`;
  text += `♦ All Inc Pricing/Down payment Info.\n`;
  text += `♦ 360° Actual Location Tour\n`;
  text += `♦ Sample Flat Video.\n`;
  text += `♦ Pros & Cons.\n`;
  text += `♦ Brochures/Plankit etc..\n\n`;

  // Visit
  const slug = proj.slug || '';
  text += `*Visit* - <a href="https://housiey.com/projects/${slug}" target="_blank">https://housiey.com/projects/${slug}</a> for more details.`;

  return text;
};

interface ChatViewProps {
  leadId: string | null;
  conversationName?: string;
  onCloseMobile?: () => void;
  onMessageSent?: (conversationId: string, msg: Message) => void;
}

const ChatView: React.FC<ChatViewProps> = ({
  leadId,
  conversationName,
  onCloseMobile,
  onMessageSent,
}) => {
  const { data: session } = useSession();
  const { callLead, callingNumber, callFailedModal } = useLeadCall();
  const [loadingCall, setLoadingCall] = useState(false);
  // Same roles that get the Call button on the lead details page
  const canCallLead = ['team_lead', 'field_sales', 'pre_sales'].includes(session?.user?.role?.name || '');
  const [messages, setMessages] = useState<Message[]>([]);
  const [loadingMediaIds, setLoadingMediaIds] = useState<Set<string>>(new Set());
  // True when the lead was assigned to another user: the history stays visible but nothing can be sent
  const [readOnly, setReadOnly] = useState(false);
  // True when the logged-in user has no WhatsApp number assigned (checked once; a failed check never blocks chat)
  const [noWhatsappNumber, setNoWhatsappNumber] = useState(false);
  useEffect(() => {
    let cancelled = false;
    getMyWhatsAppNumber()
      .then((res) => {
        if (!cancelled && res?.success && res?.data?.assigned === false) setNoWhatsappNumber(true);
      })
      .catch(() => {
        // Could not verify: leave chat enabled
      });
    return () => {
      cancelled = true;
    };
  }, []);

  const {
    hasMoreMessages,
    isLoadingMore,
    fetchMessages,
    loadMoreMessages: handleLoadMore,
    handleSendMessage: sendChatMessage,
    resetPagination,
  } = useChatLogic({
    leadId,
    onMessagesLoaded: (loadedLeadId, incoming, page) => {
      setMessages((prev) => mergeMessages(prev, incoming, page));
    },
    sessionUserId: session?.user?.id,
    onReadOnlyChange: setReadOnly,
  });

  // Fetch when leadId changes
  useEffect(() => {
    if (!leadId) {
      setMessages([]);
      return;
    }
    setMessages([]); // clear old messages before loading new
    setReadOnly(false);
    resetPagination();
    fetchMessages(1);
  }, [leadId, session?.user?.id]);

  // Socket for real-time updates for THIS chat
  useWhatsAppSocket({
    sessionUserId: session?.user?.id,
    onMessageReceived: (convId, leadIdFromSocket, newMsg, log) => {
      if (String(leadIdFromSocket) !== String(leadId)) return;
      setMessages((prev) => {
        const messageExists = prev.some((m) => m.id === newMsg.id);
        console.log(`Received new message via socket for leadId ${leadId}:`, newMsg, 'Already exists in state:', messageExists);
        return messageExists ? prev : [...prev, newMsg];
      });
      // The message arrived while this chat is open and on screen, so it counts as read. The backend only marks
      // messages read when a chat's history is fetched, so ask for the latest message to save that (and send the
      // read receipt). Without it the message stays unread in the database and the count returns after a refresh.
      if (newMsg.type === 'received' && typeof document !== 'undefined' && document.visibilityState === 'visible') {
        getConversationMessages(Number(leadId), 1, 1).catch(() => {
          // not critical: the next time the chat is opened it is marked read anyway
        });
      }
    },
    onStatusUpdated: (conversation_id, message_id, status) => {
      setMessages((prev) =>
        prev.map((m) =>
          m.id === message_id ? { ...m, message_status: status as any } : m
        )
      );
    },
  });
  const [messageText, setMessageText] = useState('');
  const [selectedFile, setSelectedFile] = useState<File | null>(null);
  const [filePreviewUrl, setFilePreviewUrl] = useState('');
  const [sendingAttachment, setSendingAttachment] = useState(false);
  const [showLocationModal, setShowLocationModal] = useState(false);
  const [sendingLocation, setSendingLocation] = useState(false);
  const fileInputRef = useRef<HTMLInputElement>(null);
  const [showTemplates, setShowTemplates] = useState(false);
  const [templates, setTemplates] = useState<any[]>([]);
  const [showProjectsDrawer, setShowProjectsDrawer] = useState(false);
  const [projectSearchQuery, setProjectSearchQuery] = useState('');
  const [projectLocationQuery, setProjectLocationQuery] = useState('');
  const [debouncedProjectSearchQuery] = useDebounce(projectSearchQuery, 500);
  const [debouncedProjectLocationQuery] = useDebounce(projectLocationQuery, 500);
  const [projects, setProjects] = useState<any[]>([]);
  const [loadingProjects, setLoadingProjects] = useState(false);
  const [projectPage, setProjectPage] = useState(1);
  const [hasMoreProjects, setHasMoreProjects] = useState(true);
  const [loadingMoreProjects, setLoadingMoreProjects] = useState(false);
  const [selectedProjectObj, setSelectedProjectObj] = useState<any | null>(null);
  const [showPreviewModal, setShowPreviewModal] = useState(false);
  const [loadingProjectDetail, setLoadingProjectDetail] = useState(false);
  const [detailedProjectObj, setDetailedProjectObj] = useState<any | null>(null);

  useEffect(() => {
    if (!selectedFile) {
      setFilePreviewUrl('');
      return;
    }
    const previewUrl = URL.createObjectURL(selectedFile);
    setFilePreviewUrl(previewUrl);
    return () => URL.revokeObjectURL(previewUrl);
  }, [selectedFile]);

  const handleFileSelection = (event: React.ChangeEvent<HTMLInputElement>) => {
    const file = event.target.files?.[0];
    event.target.value = '';
    if (!file) return;
    const isAllowedDocument = ALLOWED_DOCUMENT_EXT_REGEX.test(file.name);
    if (!file.type.startsWith('image/') && !isAllowedDocument) {
      notification.error({ message: 'Only image, PDF, DOC, DOCX, XLS, XLSX and TXT files can be attached.' });
      return;
    }
    setSelectedFile(file);
  };

  const handleSendAttachment = async () => {
    if (!selectedFile || !leadId || sendingAttachment) return;

    setSendingAttachment(true);
    try {
      const formData = new FormData();
      formData.append('file', selectedFile);
      const uploadData = await uploadWhatsAppMedia(formData);
      const mediaUrl = [
        uploadData?.url,
        uploadData?.media_url,
        uploadData?.mediaUrl,
        uploadData?.file_url,
        uploadData?.fileUrl,
        uploadData?.data?.url,
        uploadData?.data?.media_url,
        uploadData?.data?.mediaUrl,
        uploadData?.data?.file_url,
        uploadData?.data?.fileUrl,
        uploadData?.data?.file?.url,
        uploadData?.data?.media?.url,
      ].find((value) => typeof value === 'string' && value.trim());

      if (!mediaUrl) throw new Error('The upload response did not include a media URL.');

      const messageType = selectedFile.type.startsWith('image/') ? 'image' : 'document';
      const sendResponse = await sendWhatsAppMessage({
        lead_id: Number(leadId),
        message: mediaUrl,
        message_type: messageType,
      });

      if (sendResponse?.success === false) {
        throw new Error(sendResponse.message || 'Failed to send attachment.');
      }

      const now = new Date();
      const timeStr = formatTimeStr(now);
      const sentMessage: Message = {
        id: sendResponse?.message_id || sendResponse?.data?.messageId || sendResponse?.data?.id || `gb_${Date.now()}`,
        text: mediaUrl,
        timestamp: `TODAY, ${timeStr}`,
        type: 'sent',
        message_status: 'sent',
        createdAt: now.toISOString(),
        message_type: messageType,
        fileName: selectedFile.name,
      };
      setMessages((prev) => prev.some((msg) => msg.id === sentMessage.id) ? prev : [...prev, sentMessage]);
      onMessageSent?.(leadId, sentMessage);
      setSelectedFile(null);
      setFilePreviewUrl('');
      message.success('Attachment sent.');
    } catch (error: any) {
      notification.error({ message: error?.response?.data?.message || error?.message || 'Failed to send attachment. Please try again.' });
    } finally {
      setSendingAttachment(false);
    }
  };

  // Call the lead from the chat: loads the lead's number (encrypted for sales roles, the backend resolves it)
  // and starts the same call as the Call button on the lead details page
  const handleCallLead = async () => {
    if (!leadId || loadingCall || callingNumber) return;
    setLoadingCall(true);
    try {
      const lead = await getLeadData(Number(leadId));
      const meta = lead?.data?.meta_data;
      callLead(meta?.phone_number || meta?.whatsApp_number, 'agent');
    } catch {
      notification.error({ message: 'Could not start the call', description: "Failed to load the lead's number." });
    } finally {
      setLoadingCall(false);
    }
  };

  const handleSendLocation = async (location: LocationPayload) => {
    if (!leadId || sendingLocation) return;

    setSendingLocation(true);
    try {
      const sendResponse = await sendWhatsAppMessage({
        lead_id: Number(leadId),
        message_type: 'location',
        location,
      });

      if (sendResponse?.success === false) {
        throw new Error(sendResponse.message || 'Failed to send location.');
      }

      const now = new Date();
      const timeStr = formatTimeStr(now);
      // Same readable text the backend stores in the log (place + Maps link)
      const text = [
        location.name ? `📍 ${location.name}` : null,
        location.address || null,
        `https://www.google.com/maps?q=${location.latitude},${location.longitude}`,
      ].filter(Boolean).join('\n');
      const sentMessage: Message = {
        id: sendResponse?.message_id || `loc_${Date.now()}`,
        text,
        timestamp: `TODAY, ${timeStr}`,
        type: 'sent',
        message_status: 'sent',
        createdAt: now.toISOString(),
        message_type: 'location',
      };
      setMessages((prev) => prev.some((msg) => msg.id === sentMessage.id) ? prev : [...prev, sentMessage]);
      onMessageSent?.(leadId, sentMessage);
      setShowLocationModal(false);
      message.success('Location sent.');
    } catch (error: any) {
      notification.error({ message: error?.response?.data?.message || error?.message || 'Failed to send location. Please try again.' });
    } finally {
      setSendingLocation(false);
    }
  };

  const handleLoadIncomingMedia = async (msg: Message) => {
    if (!msg.logId || !msg.whatsappMessageId || loadingMediaIds.has(msg.id)) {
      if (!msg.logId || !msg.whatsappMessageId) {
        notification.error({ message: 'Attachment identifiers are missing. Please refresh the conversation.' });
      }
      return;
    }

    setLoadingMediaIds((prev) => new Set(prev).add(msg.id));
    try {
      const response = await downloadWhatsAppMedia({
        log_id: msg.logId,
        whatsapp_message_id: msg.whatsappMessageId,
      });
      if (response?.success === false) {
        throw new Error(response?.message || 'Failed to download attachment.');
      }
      const mediaUrl = [
        response?.url,
        response?.media_url,
        response?.mediaUrl,
        response?.file_url,
        response?.fileUrl,
        response?.download_url,
        response?.downloadUrl,
        response?.data?.url,
        response?.data?.media_url,
        response?.data?.mediaUrl,
        response?.data?.file_url,
        response?.data?.fileUrl,
        response?.data?.download_url,
        response?.data?.downloadUrl,
        response?.data?.media?.url,
      ].find((value) => typeof value === 'string' && value.trim());

      if (!mediaUrl) throw new Error('The media response did not include a URL.');
      const fileName = [
        response?.file_name,
        response?.filename,
        response?.fileName,
        response?.name,
        response?.data?.file_name,
        response?.data?.filename,
        response?.data?.fileName,
        response?.data?.name,
        response?.data?.file?.name,
        response?.data?.media?.file_name,
        response?.data?.media?.filename,
      ].find((value) => typeof value === 'string' && value.trim());
      setMessages((prev) => prev.map((item) =>
        item.id === msg.id
          ? { ...item, downloadedMediaUrl: mediaUrl, fileName: fileName || item.fileName }
          : item
      ));
    } catch (error: any) {
      notification.error({ message: error?.response?.data?.message || error?.message || 'Failed to download attachment. Please try again.' });
    } finally {
      setLoadingMediaIds((prev) => {
        const next = new Set(prev);
        next.delete(msg.id);
        return next;
      });
    }
  };

  const fetchProjectsList = async (searchVal: string, locationVal: string, pageNum: number, append: boolean = false) => {
    if (pageNum === 1) {
      setLoadingProjects(true);
    } else {
      setLoadingMoreProjects(true);
    }
    try {
      const response = await getProjects({
        search: searchVal,
        location: locationVal,
        page: pageNum,
        pageSize: 20,
        projectTemplate: true,
      });
      let newProjects: any[] = [];
      let totalCount = 0;

      if (response) {
        if (Array.isArray(response.data)) {
          newProjects = response.data;
          totalCount = response.meta?.total || 0;
        } else if (Array.isArray(response)) {
          newProjects = response;
          totalCount = response.length;
        }
      }

      setProjects((prev) => {
        if (!append) return newProjects;
        const existingIds = new Set(prev.map((p) => p.id));
        const filteredNew = newProjects.filter((p) => !existingIds.has(p.id));
        return [...prev, ...filteredNew];
      });

      if (response && response.meta) {
        const totalPages = response.meta.total_pages || Math.ceil(totalCount / 20);
        const currentPage = response.meta.current_page || response.meta.current || pageNum;
        setHasMoreProjects(currentPage < totalPages && newProjects.length > 0);
      } else {
        setHasMoreProjects(newProjects.length === 20);
      }

      setProjectPage(pageNum);
    } catch (error) {
      console.error('Failed to fetch projects in ChatView:', error);
      if (!append) {
        setProjects([]);
      }
    } finally {
      setLoadingProjects(false);
      setLoadingMoreProjects(false);
    }
  };

  useEffect(() => {
    if (showProjectsDrawer) {
      fetchProjectsList(debouncedProjectSearchQuery, debouncedProjectLocationQuery, 1, false);
    } else {
      setProjects([]);
      setProjectPage(1);
      setHasMoreProjects(true);
      setSelectedProjectObj(null);
      setDetailedProjectObj(null);
    }
  }, [debouncedProjectSearchQuery, debouncedProjectLocationQuery, showProjectsDrawer]);

  const loadMoreProjects = () => {
    const nextPage = projectPage + 1;
    fetchProjectsList(debouncedProjectSearchQuery, debouncedProjectLocationQuery, nextPage, true);
  };

  const handleProjectsScroll = (e: React.UIEvent<HTMLDivElement>) => {
    const target = e.currentTarget;
    if (
      target.scrollHeight - target.scrollTop <= target.clientHeight + 50 &&
      hasMoreProjects &&
      !loadingProjects &&
      !loadingMoreProjects
    ) {
      loadMoreProjects();
    }
  };

  const fetchDetailedProjectObj = async (selectedProject: any) => {
    if (detailedProjectObj && detailedProjectObj.id === selectedProject.id) {
      return detailedProjectObj;
    }
    setDetailedProjectObj(selectedProject);
    return selectedProject;
  };

  const handlePreviewClick = async () => {
    fetchDetailedProjectObj(selectedProjectObj);
    setShowPreviewModal(true);
  };

  const handleSendProjectMessage = async () => {
    const targetProj = selectedProjectObj;
    if (!targetProj?.id || !leadId) return;
    setLoadingProjectDetail(true);
    try {
      const target = await fetchDetailedProjectObj(targetProj);
      if (!target) return;

      const projectMsg = buildProjectTemplate(target);

      const now = new Date();
      const timeStr = formatTimeStr(now);
      const tempId = `m${Date.now()}`;

      const optimisticMsg: Message = {
        id: tempId,
        text: projectMsg,
        message_type: 'template',
        timestamp: `TODAY, ${timeStr}`,
        type: 'sent',
        message_status: 'sent',
        createdAt: now.toISOString(),
      };

      setMessages((prev) => [...prev, optimisticMsg]);

      setSelectedProjectObj(null);
      setDetailedProjectObj(null);
      setShowProjectsDrawer(false);

      sendProjectDetails(Number(leadId), Number(targetProj.id))
        .then((responseData) => {
          if (responseData?.success) {
            const realId = responseData.message_id || responseData.data?.messageId || responseData.data?.id || `gb_${Date.now()}`;
            setMessages((prev) =>
              prev.map((m) =>
                m.id === tempId ? { ...m, id: realId, message_status: 'sent' as const } : m
              )
            );
            if (onMessageSent) {
              onMessageSent(leadId, {
                id: realId,
                text: projectMsg,
                message_type: 'template',
                timestamp: `TODAY, ${timeStr}`,
                type: 'sent',
                message_status: 'sent',
                createdAt: now.toISOString(),
              });
            }
          } else {
            setMessages((prev) => prev.filter((m) => m.id !== tempId));
          }
        })
        .catch((err) => {
          message.error('Failed to send. Please try again.');
          setMessages((prev) => prev.filter((m) => m.id !== tempId));
        });
    } catch (error) {
      console.error("Failed to load project details for sending:", error);
      message.error("Failed to load project details. Please try again.");
    } finally {
      setLoadingProjectDetail(false);
    }
  };
  const [selectedTemplate, setSelectedTemplate] = useState<number | null>(null);
  const [selectedTemplateObj, setSelectedTemplateObj] = useState<any | null>(null);
  const [loadingTemplates, setLoadingTemplates] = useState(false);
  const messagesEndRef = useRef<HTMLDivElement>(null);
  const messagesContainerRef = useRef<HTMLDivElement>(null);
  const prevConversationIdRef = useRef<string | null>(null);
  const prevMessagesLengthRef = useRef<number>(0);
  const hasLoadedHistoryRef = useRef<boolean>(false);

  useEffect(() => {
    setMessageText('');
    setSelectedTemplate(null);
    setSelectedTemplateObj(null);
    setShowTemplates(false);
  }, [leadId]);

  useEffect(() => {
    let active = true;
    const fetchTemplates = async () => {
      if (!leadId) {
        setTemplates([]);
        return;
      }
      setLoadingTemplates(true);
      try {
        const res = await getWhatsAppTemplates(leadId);
        if (active && res?.success && Array.isArray(res.data)) {
          setTemplates(res.data);
        }
      } catch (error) {
        console.error('Failed to load WhatsApp templates:', error);
      } finally {
        if (active) setLoadingTemplates(false);
      }
    };
    fetchTemplates();
    return () => {
      active = false;
    };
  }, [leadId]);

  const lastMessageId = messages.length
    ? messages[messages.length - 1].id
    : null;

  useEffect(() => {
    if (!leadId) return;

    const isSameConversation = prevConversationIdRef.current === leadId;
    prevConversationIdRef.current = leadId;

    if (!isSameConversation) {
      hasLoadedHistoryRef.current = false;
    }

    const messagesLength = messages.length;
    const isSingleMessageAppended = isSameConversation && (messagesLength === prevMessagesLengthRef.current + 1);
    prevMessagesLengthRef.current = messagesLength;

    const scrollToBottom = (behavior: ScrollBehavior = 'smooth') => {
      if (messagesContainerRef.current) {
        messagesContainerRef.current.scrollTo({
          top: messagesContainerRef.current.scrollHeight,
          behavior
        });
      } else {
        messagesEndRef.current?.scrollIntoView({ behavior });
      }
    };

    if (lastMessageId) {
      if (isSingleMessageAppended) {
        scrollToBottom('smooth');
      } else if (!isSameConversation || (!hasLoadedHistoryRef.current && messagesLength > 1)) {
        if (messagesLength > 1) {
          hasLoadedHistoryRef.current = true;
        }
        scrollToBottom('auto');
        // Retry with timeouts to guarantee scroll position after browser layout/paint completes
        const t1 = setTimeout(() => scrollToBottom('auto'), 50);
        const t2 = setTimeout(() => scrollToBottom('auto'), 150);
        const t3 = setTimeout(() => scrollToBottom('auto'), 300);
        return () => {
          clearTimeout(t1);
          clearTimeout(t2);
          clearTimeout(t3);
        };
      }
    }
  }, [leadId, lastMessageId, messages.length]);

  const handleScroll = (e: React.UIEvent<HTMLDivElement>) => {
    const target = e.currentTarget;

    if (target.scrollTop === 0 && handleLoadMore && hasMoreMessages && !isLoadingMore) {
      const previousScrollHeight = target.scrollHeight;

      const result = handleLoadMore();
      const adjustScroll = () => {
        setTimeout(() => {
          const newScrollHeight = target.scrollHeight;
          target.scrollTop = newScrollHeight - previousScrollHeight;
        }, 50);
      };

      if (result instanceof Promise) {
        result.then(adjustScroll);
      } else {
        adjustScroll();
      }
    }
  };
  const lastReceivedMessage = messages.length
    ? [...messages].reverse().find((m) => m.type === 'received')
    : null;
  console.log("conversation  ", lastReceivedMessage)

  const isPast24Hours = (() => {
    if (!lastReceivedMessage) return false;

    // Primary check: use the ISO createdAt from the API (most accurate)
    if (lastReceivedMessage.createdAt) {
      const lastTime = new Date(lastReceivedMessage.createdAt).getTime();
      if (!isNaN(lastTime)) {
        return Date.now() - lastTime > 24 * 60 * 60 * 1000;
      }
    }

    // Fallback: the timestamp label encodes the date category.
    // formatDisplayDate() uses 'TODAY' / 'YESTERDAY' for recent messages and an
    // explicit locale date string (e.g. "16 June 2026") for anything older.
    // If neither TODAY nor YESTERDAY prefix is present, the message is at least
    // 2 calendar days old → definitely past 24 hours.
    const ts = lastReceivedMessage.timestamp || '';
    if (!ts.startsWith('TODAY') && !ts.startsWith('YESTERDAY')) {
      return true;
    }

    return false;
  })();

  // The 24-hour rule only locks the message box when the temporary override above is off

  // After the customer's 24-hour window has closed only a template can be sent, and WhatsApp allows one before the
  // customer replies. Once a template has been sent, everything stays locked until 24 hours after it.
  const TEMPLATE_COOLDOWN_MS = 24 * 60 * 60 * 1000;
  const [, setCooldownTick] = useState(0);
  const lastSentTemplateAt = (() => {
    for (let i = messages.length - 1; i >= 0; i--) {
      const m = messages[i];
      if (m.type === 'sent' && (m.message_type || '').toLowerCase() === 'template') {
        const time = new Date(m.createdAt || '').getTime();
        return Number.isNaN(time) ? null : time;
      }
    }
    return null;
  })();
  const customerWindowOpen = !!lastReceivedMessage && !isPast24Hours;
  const templateCooldownEndsAt = lastSentTemplateAt !== null ? lastSentTemplateAt + TEMPLATE_COOLDOWN_MS : null;
  const isTemplateCooldown = !customerWindowOpen && templateCooldownEndsAt !== null && Date.now() < templateCooldownEndsAt;
  const templateCooldownEndsLabel = templateCooldownEndsAt
    ? new Date(templateCooldownEndsAt).toLocaleString('en-IN', { day: 'numeric', month: 'short', hour: 'numeric', minute: '2-digit', hour12: true })
    : '';
  // Re-check when the cooldown runs out so the chat unlocks without a refresh
  useEffect(() => {
    if (templateCooldownEndsAt === null) return;
    const remaining = templateCooldownEndsAt - Date.now();
    if (remaining <= 0) return;
    const timer = setTimeout(() => setCooldownTick((n) => n + 1), Math.min(remaining + 1000, 2147483647));
    return () => clearTimeout(timer);
  }, [templateCooldownEndsAt]);
  // Locks the Templates / Projects buttons; the message box is locked with it
  const actionsLocked = !ALWAYS_SHOW_COMPOSER && isTemplateCooldown;
  const isComposerLocked = !ALWAYS_SHOW_COMPOSER && (isPast24Hours || isTemplateCooldown);

  const handleMessageTextChange = (val: string) => {
    if (isComposerLocked) return;
    if (countChars(val) > MAX_TEXT_LENGTH) {
      // Typing or pasting past the limit: keep the first MAX_TEXT_LENGTH characters
      setMessageText(Array.from(val).slice(0, MAX_TEXT_LENGTH).join(''));
      notification.warning({ message: `A message can have at most ${MAX_TEXT_LENGTH} characters.` });
      return;
    }
    setMessageText(val);
  };

  const handleSendDrawerTemplate = () => {
    if (!selectedTemplateObj || !leadId) return;

    const components: any[] = [];
    if (selectedTemplateObj.placeholders && selectedTemplateObj.placeholders.length > 0) {
      const sortedPlaceholders = [...selectedTemplateObj.placeholders].sort(
        (a, b) => a.position - b.position
      );

      const parameters = sortedPlaceholders.map((p: any) => {
        let textVal = p.value || '';
        if (textVal.includes('<a href=')) {
          const match = textVal.match(/href="([^"]+)"/);
          if (match && match[1]) {
            textVal = match[1];
          }
        }
        return {
          type: 'text',
          text: textVal,
        };
      });

      components.push({
        type: 'body',
        parameters: parameters,
      });
    }

    sendChatMessage(
      leadId,
      selectedTemplateObj.bodyText,
      'template',
      // Optimistic update
      (optimisticMsg) => {
        setMessages((prev) => [...prev, optimisticMsg]);
      },
      // Confirmed with real message_id
      (tempId, realId) => {
        setMessages((prev) =>
          prev.map((m) =>
            m.id === tempId ? { ...m, id: realId, message_status: 'sent' as const } : m
          )
        );
        if (onMessageSent) {
          const now = new Date();
          const timeStr = formatTimeStr(now);
          onMessageSent(leadId, {
            id: realId,
            text: selectedTemplateObj.bodyText,
            message_type: 'template',
            timestamp: `TODAY, ${timeStr}`,
            type: 'sent',
            message_status: 'sent',
            createdAt: now.toISOString(),
          });
        }
      },
      {
        templateName: selectedTemplateObj.name,
        languageCode: selectedTemplateObj.language || 'en_US',
        components,
      }
    );

    setSelectedTemplate(null);
    setSelectedTemplateObj(null);
    setShowTemplates(false);
  };

  const handleSend = () => {
    if (isComposerLocked) return;
    if (!messageText.trim() || !leadId) return;
    if (countChars(messageText.trim()) > MAX_TEXT_LENGTH) {
      notification.warning({ message: `A message can have at most ${MAX_TEXT_LENGTH} characters.` });
      return;
    }

    sendChatMessage(
      leadId,
      messageText.trim(),
      'text',
      // Optimistic update
      (optimisticMsg) => {
        setMessages((prev) => [...prev, optimisticMsg]);
      },
      // Confirmed with real message_id
      (tempId, realId) => {
        setMessages((prev) =>
          prev.map((m) =>
            m.id === tempId ? { ...m, id: realId, message_status: 'sent' as const } : m
          )
        );
        if (onMessageSent) {
          const now = new Date();
          const timeStr = formatTimeStr(now);
          onMessageSent(leadId, {
            id: realId,
            text: messageText.trim(),
            timestamp: `TODAY, ${timeStr}`,
            type: 'sent',
            message_status: 'sent',
            createdAt: now.toISOString(),
          });
        }
      }
    );

    setMessageText('');
    setSelectedTemplate(null);
    setSelectedTemplateObj(null);
    setShowTemplates(false);
  };

  const handleKeyDown = (e: React.KeyboardEvent) => {
    if (isComposerLocked) {
      e.preventDefault();
      return;
    }
    if (e.key === 'Enter' && !e.shiftKey) {
      e.preventDefault();
      handleSend();
    }
  };

  const handleTemplateSelect = (idx: number) => {
    const tpl = templates[idx];
    if (tpl) {
      setSelectedTemplate(idx);
      setSelectedTemplateObj(tpl);
    }
  };

  const renderTicks = (status?: Message['message_status']) => {
    if (!status) return null;
    if (status === 'read') {
      return (
        <span className="wa-tick-read">
          <img src="/svg/check-active.svg" />
        </span>
      );
    }
    if (status === 'delivered') {
      return (
        <span className="wa-tick-status wa-tick-status--delivered">
          <img src="/svg/check.svg" />
        </span>
      );
    }
    return (
      <span className="wa-tick-status">
        <CheckOutlined />
      </span>
    );
  };

  // Group messages by date separator
  const renderMessages = () => {
    if (!leadId) return null;

    let currentDateGroup = '';
    return messages.map((msg, idx) => {
      // Extract date label from timestamp (e.g., "YESTERDAY, 2:00 PM" or "16 June 2026, 2:00 PM")
      let dateLabel = '';
      if (msg.timestamp.includes(',')) {
        const parts = msg.timestamp.split(',');
        dateLabel = parts[0].trim();
      }

      const showSeparator = dateLabel && dateLabel !== currentDateGroup;
      if (showSeparator) currentDateGroup = dateLabel;

      // Extract time from timestamp
      const timeDisplay = msg.timestamp.includes(',')
        ? msg.timestamp.split(',')[1]?.trim()
        : msg.timestamp;

      const mediaKind = getMediaKind(msg);
      const mediaUrl = msg.downloadedMediaUrl || getMediaUrl(msg.text);
      const attachmentName = getFileNameFromMessage(msg, mediaUrl);
      const hasValidMediaUrl = URL_REGEX.test(mediaUrl.trim());
      const requiresMediaDownload = msg.type === 'received' && mediaKind !== 'text' && !hasValidMediaUrl;
      const isLoadingMedia = loadingMediaIds.has(msg.id);
      console.log("msg  ", msg);
      return (
        <React.Fragment key={msg.id}>
          {showSeparator && (
            <div className="wa-date-separator">
              <span>{dateLabel}</span>
            </div>
          )}
          <div className={`wa-message-row wa-message-row--${msg.type}`}>
            <div className={`wa-bubble wa-bubble--${msg.type}${mediaKind !== 'text' ? ' wa-bubble--media' : ''}`}>
              {requiresMediaDownload && mediaKind === 'image' ? (
                <button
                  type="button"
                  onClick={() => handleLoadIncomingMedia(msg)}
                  disabled={isLoadingMedia}
                  aria-label={isLoadingMedia ? 'Loading image attachment' : 'Load image attachment'}
                  style={{ display: 'block', padding: 0, border: 0, background: 'transparent', cursor: isLoadingMedia ? 'wait' : 'pointer' }}
                >
                  {hasValidMediaUrl ? (
                    <>
                      <img src={mediaUrl} alt={attachmentName} className="wa-bubble-image" />
                      <FileNameLabel fileName={attachmentName} style={{ display: 'block', marginTop: '4px' }} />
                    </>
                  ) : (
                    <span className="wa-bubble-file">
                      <span className="wa-bubble-file-icon">
                        {isLoadingMedia ? <LoadingOutlined /> : <FileOutlined />}
                      </span>
                      {isLoadingMedia ? <span className="wa-bubble-file-name">Loading...</span> : <FileNameLabel fileName={attachmentName} />}
                      {!isLoadingMedia && <span className="wa-bubble-file-download"><DownloadOutlined /></span>}
                    </span>
                  )}
                </button>
              ) : requiresMediaDownload ? (
                <button
                  type="button"
                  onClick={() => handleLoadIncomingMedia(msg)}
                  disabled={isLoadingMedia}
                  className="wa-bubble-file"
                  style={{ border: 0, cursor: isLoadingMedia ? 'wait' : 'pointer', width: '100%', textAlign: 'left' }}
                >
                  <span className="wa-bubble-file-icon">
                    {isLoadingMedia ? <LoadingOutlined /> : mediaKind === 'image' ? <FileOutlined /> : <FilePdfOutlined />}
                  </span>
                  {isLoadingMedia ? <span className="wa-bubble-file-name">Loading...</span> : <FileNameLabel fileName={attachmentName} />}
                  {!isLoadingMedia && !hasValidMediaUrl && <span className="wa-bubble-file-download"><DownloadOutlined /></span>}
                </button>
              ) : mediaKind === 'image' ? (
                <div>
                  <a href={mediaUrl} target="_blank" rel="noopener noreferrer">
                    <img src={mediaUrl} alt={attachmentName} className="wa-bubble-image" />
                  </a>
                  <FileNameLabel fileName={attachmentName} style={{ display: 'block', marginTop: '4px' }} />
                </div>
              ) : mediaKind === 'document' ? (
                <a
                  href={mediaUrl}
                  target="_blank"
                  rel="noopener noreferrer"
                  className="wa-bubble-file"
                >
                  <span className="wa-bubble-file-icon">
                    <FilePdfOutlined />
                  </span>
                  <FileNameLabel fileName={attachmentName} />
                  {!hasValidMediaUrl && (
                    <span className="wa-bubble-file-download">
                      <DownloadOutlined />
                    </span>
                  )}
                </a>
              ) : (msg.message_type || '').toLowerCase() === 'location' ? (
                (() => {
                  const loc = parseLocationText(msg.text);
                  return (
                    <div style={{ display: 'flex', alignItems: 'center', gap: 10 }}>
                      <EnvironmentOutlined style={{ fontSize: 20, color: '#54656f' }} />
                      {loc.url ? (
                        <a href={loc.url} target="_blank" rel="noopener noreferrer">
                          View on map
                        </a>
                      ) : (
                        // Older location messages saved without a map link: show the place name instead
                        <span style={{ wordBreak: 'break-word' }}>{loc.title}</span>
                      )}
                    </div>
                  );
                })()
              ) : (
                <p className="wa-bubble-text" style={{ whiteSpace: 'pre-wrap' }} dangerouslySetInnerHTML={{ __html: formatMessageText(msg.text) }} />
              )}
              <div className="wa-bubble-meta">
                <span className="wa-bubble-time">{timeDisplay}</span>
                <span>
                  {
                    msg.type === 'sent' && renderTicks(msg.message_status)
                  }
                </span>
              </div>
            </div>
          </div>
        </React.Fragment>
      );
    });
  };

  // ─── Render ───────────────────────────────────────────────────────────────

  if (!leadId) {
    return (
      <div className="wa-chat-empty">
        <div className="wa-chat-empty-icon">💬</div>
        <h3>Select a conversation</h3>
        <p>Choose a contact from the list to start messaging</p>
      </div>
    );
  }

  return (
    <div className="wa-chat-view">
      {/* Chat Header */}
      <div className="wa-chat-header">
        <div className="wa-chat-header-info">
          <div className="wa-chat-header-details">
            <span className="wa-chat-header-name">{conversationName || 'Chat'}</span>
          </div>
        </div>
        <div className="wa-chat-header-actions">
          {canCallLead && !readOnly && (
            <Tooltip title="Call lead">
              <button
                className="wa-header-btn"
                onClick={handleCallLead}
                disabled={loadingCall || !!callingNumber}
                aria-label="Call lead">
                {loadingCall || callingNumber ? <LoadingOutlined /> : <CallIcon size={18} />}
              </button>
            </Tooltip>
          )}
          {onCloseMobile && (
            <button className="wa-chat-close-btn" onClick={onCloseMobile}>
              <CloseOutlined />
            </button>
          )}
        </div>
      </div>
      {callFailedModal}

      {/* Warning banners — sticky at the top of the chat area */}
      {!readOnly && noWhatsappNumber ? (
        // No number assigned: the user can't send anything, so this replaces the 24-hour banner
        <div className="wa-top-warnings-wrapper">
          <div id="wa-no-number-notice">
            No WhatsApp number is assigned to you. Please contact admin.
          </div>
        </div>
      ) : actionsLocked ? (
        <div className="wa-top-warnings-wrapper">
          <div id="wa-24h-warning">
            A template was already sent. You can send another template after 24 hours (from {templateCooldownEndsLabel}).
          </div>
        </div>
      ) : isPast24Hours ? (
        <div className="wa-top-warnings-wrapper">
          <div id="wa-24h-warning">
            24 hours have passed since the customer last replied to this number. Send a template to re-engage with lead
          </div>
        </div>
      ) : null}

      {/* Messages Area */}
      <div ref={messagesContainerRef} className="wa-messages-area" onScroll={handleScroll}>
        {isLoadingMore && (
          <div style={{ textAlign: 'center', padding: '10px', color: '#888', fontSize: '12px' }}>
            Loading older messages...
          </div>
        )}
        {renderMessages()}


        <div ref={messagesEndRef} />
      </div>

      {/* Default Templates Drawer */}
      <Drawer
        title={
          <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', width: '100%' }}>
            <span>Templates</span>
            <button
              onClick={handleSendDrawerTemplate}
              disabled={selectedTemplateObj === null}
              className="wa-drawer-send-btn"
              style={{
                background: selectedTemplateObj === null ? '#f5f5f5' : '#008a3d',
                color: selectedTemplateObj === null ? '#bfbfbf' : '#fff',
                border: 'none',
                borderRadius: '6px',
                padding: '6px 16px',
                fontSize: '13px',
                fontWeight: 500,
                cursor: selectedTemplateObj === null ? 'not-allowed' : 'pointer',
                transition: 'all 0.2s',
                marginRight: '24px'
              }}
            >
              Send
            </button>
          </div>
        }
        placement="right"
        onClose={() => {
          setShowTemplates(false);
          setSelectedTemplate(null);
          setSelectedTemplateObj(null);
        }}
        open={showTemplates}
        width={380}
        bodyStyle={{ padding: '16px', overflowY: 'auto' }}
        className="wa-templates-drawer"
      >
        <div className="wa-templates-list" style={{ display: 'flex', flexDirection: 'column', gap: '12px' }}>
          {loadingTemplates ? (
            <div style={{ textAlign: 'center', padding: '20px', color: '#888' }}>
              Loading templates...
            </div>
          ) : templates.length === 0 ? (
            <div style={{ textAlign: 'center', padding: '20px', color: '#888' }}>
              No templates available
            </div>
          ) : (
            templates.map((tpl: any, idx: number) => (
              <div
                key={idx}
                className="wa-template-card"
                onClick={() => {
                  handleTemplateSelect(idx);
                }}
                id={`wa-template-${idx}`}
              >
                <div className="wa-template-card-header">
                  <h4>{tpl.label || tpl.name}</h4>
                  <div className={`wa-template-radio ${selectedTemplate === idx ? 'checked' : ''}`}>
                    {selectedTemplate === idx && <CheckOutlined />}
                  </div>
                </div>
                <p className="wa-template-card-body" style={{ whiteSpace: 'pre-wrap', wordBreak: 'break-word', overflowWrap: 'break-word' }} dangerouslySetInnerHTML={{ __html: tpl.bodyText }} />
              </div>
            ))
          )}
        </div>
      </Drawer>

      {/* Projects Drawer */}
      <Drawer
        title={
          <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', width: '100%' }}>
            <span>Projects</span>
            <div style={{ display: 'flex', gap: '8px', marginRight: '24px' }}>
              <button
                onClick={handlePreviewClick}
                disabled={selectedProjectObj === null || loadingProjectDetail}
                className="wa-drawer-preview-btn"
                style={{
                  background: (selectedProjectObj === null || loadingProjectDetail) ? '#f5f5f5' : '#fff',
                  color: (selectedProjectObj === null || loadingProjectDetail) ? '#bfbfbf' : '#555',
                  border: '1px solid ' + ((selectedProjectObj === null || loadingProjectDetail) ? '#e8e8e8' : '#d9d9d9'),
                  borderRadius: '6px',
                  padding: '6px 12px',
                  fontSize: '13px',
                  fontWeight: 500,
                  cursor: (selectedProjectObj === null || loadingProjectDetail) ? 'not-allowed' : 'pointer',
                  transition: 'all 0.2s'
                }}
              >
                {loadingProjectDetail ? 'Loading...' : 'Preview'}
              </button>
              <button
                onClick={handleSendProjectMessage}
                disabled={selectedProjectObj === null || loadingProjectDetail}
                className="wa-drawer-send-btn"
                style={{
                  background: (selectedProjectObj === null || loadingProjectDetail) ? '#f5f5f5' : '#008a3d',
                  color: (selectedProjectObj === null || loadingProjectDetail) ? '#bfbfbf' : '#fff',
                  border: 'none',
                  borderRadius: '6px',
                  padding: '6px 16px',
                  fontSize: '13px',
                  fontWeight: 500,
                  cursor: (selectedProjectObj === null || loadingProjectDetail) ? 'not-allowed' : 'pointer',
                  transition: 'all 0.2s'
                }}
              >
                Send
              </button>
            </div>
          </div>
        }
        placement="right"
        onClose={() => {
          setShowProjectsDrawer(false);
          setProjectSearchQuery('');
          setProjectLocationQuery('');
          setProjects([]);
          setSelectedProjectObj(null);
        }}
        open={showProjectsDrawer}
        width={380}
        bodyStyle={{ padding: '16px' }}
        className="wa-projects-drawer"
      >
        <div style={{ display: 'flex', flexDirection: 'column', gap: '16px' }}>
          <div style={{ display: 'flex', flexDirection: 'column', gap: '8px' }}>
            <Input
              prefix={<SearchOutlined style={{ color: '#bfbfbf' }} />}
              placeholder="search by name"
              value={projectSearchQuery}
              onChange={(e) => setProjectSearchQuery(e.target.value)}
              allowClear
            />
            <Input
              prefix={<SearchOutlined style={{ color: '#bfbfbf' }} />}
              placeholder="search by location"
              value={projectLocationQuery}
              onChange={(e) => setProjectLocationQuery(e.target.value)}
              allowClear
            />
          </div>

          <div className="wa-projects-list" onScroll={handleProjectsScroll} style={{ display: 'flex', flexDirection: 'column', gap: '12px', marginTop: '8px', maxHeight: 'calc(100vh - 220px)', overflowY: 'auto' }}>
            {loadingProjects ? (
              <div style={{ textAlign: 'center', padding: '20px', color: '#888' }}>
                Loading projects...
              </div>
            ) : projects.length === 0 ? (
              <div style={{ textAlign: 'center', padding: '20px', color: '#888' }}>
                No projects found
              </div>
            ) : (
              <>
                {projects.map((proj: any) => (
                  <div
                    key={proj.id}
                    onClick={() => {
                      if (selectedProjectObj?.id === proj.id) {
                        setSelectedProjectObj(null);
                      } else {
                        setSelectedProjectObj(proj);
                      }
                    }}
                    style={{
                      background: '#F5F5F5',
                      borderRadius: '8px',
                      padding: '12px 16px',
                      border: selectedProjectObj?.id === proj.id ? '1.5px solid #008a3d' : '1px solid #e0e0e0',
                      display: 'flex',
                      alignItems: 'flex-start',
                      justifyContent: 'space-between',
                      cursor: 'pointer',
                      gap: '12px',
                      transition: 'all 0.2s',
                    }}
                  >
                    <div style={{ display: 'flex', flexDirection: 'column', gap: '4px', flex: 1 }}>
                      <h4 style={{ margin: 0, fontSize: '14px', fontWeight: 600, color: '#333' }}>
                        {proj.name}
                      </h4>
                      {/* {proj.launch_name && (
                        <span style={{ fontSize: '11px', color: '#888' }}>
                          Launch: {proj.launch_name}
                        </span>
                      )}
                      {proj.location && (
                        <span style={{ fontSize: '11px', color: '#888' }}>
                          Location: {proj.location}
                        </span>
                      )} */}
                    </div>
                    <div className={`wa-template-radio ${selectedProjectObj?.id === proj.id ? 'checked' : ''}`}>
                      {selectedProjectObj?.id === proj.id && <CheckOutlined />}
                    </div>
                  </div>
                ))}
                {loadingMoreProjects && (
                  <div style={{ textAlign: 'center', padding: '12px', color: '#888', fontSize: '13px' }}>
                    Loading more projects...
                  </div>
                )}
              </>
            )}
          </div>
        </div>
      </Drawer>

      <Modal
        title="Template Preview"
        open={showPreviewModal}
        onCancel={() => setShowPreviewModal(false)}
        footer={[
          <button
            key="close"
            onClick={() => setShowPreviewModal(false)}
            style={{
              background: '#fff',
              color: '#555',
              border: '1px solid #d9d9d9',
              borderRadius: '6px',
              padding: '6px 16px',
              cursor: 'pointer',
              marginRight: '8px',
              fontSize: '13px',
              fontWeight: 500
            }}
          >
            Close
          </button>,
          <button
            key="send"
            onClick={() => {
              handleSendProjectMessage();
              setShowPreviewModal(false);
            }}
            style={{
              background: '#008a3d',
              color: '#fff',
              border: 'none',
              borderRadius: '6px',
              padding: '6px 16px',
              cursor: 'pointer',
              fontSize: '13px',
              fontWeight: 500
            }}
          >
            Send
          </button>
        ]}
      >
        <div style={{ padding: '16px 0' }} className='wa-template-project'>
          <div className="flex justify-center">
            <div className="wa-bubble wa-bubble--sent" style={{ maxWidth: '85%', padding: '8px 12px', borderRadius: '8px', border: '1px solid #c2ebbb', boxShadow: '0 1px 0.5px rgba(0,0,0,0.13)' }}>
              <p
                className="wa-bubble-text"
                style={{ margin: 0, whiteSpace: 'pre-wrap', color: '#303030', fontSize: '14.2px', lineHeight: 1.4 }}
                dangerouslySetInnerHTML={{
                  __html: (detailedProjectObj || selectedProjectObj) ? formatWhatsAppStyle(
                    buildProjectTemplate(detailedProjectObj || selectedProjectObj)
                  ) : ''
                }}
              />
            </div>
          </div>
        </div>
      </Modal>

      <input
        ref={fileInputRef}
        type="file"
        accept="image/*,.pdf,.doc,.docx,.xls,.xlsx,.txt"
        hidden
        onChange={handleFileSelection}
      />
      <Modal
        title="Attachment Preview"
        open={!!selectedFile}
        onCancel={() => {
          if (!sendingAttachment) setSelectedFile(null);
        }}
        closable={!sendingAttachment}
        maskClosable={!sendingAttachment}
        footer={[
          <button
            key="cancel"
            type="button"
            onClick={() => setSelectedFile(null)}
            disabled={sendingAttachment}
            style={{
              background: '#fff',
              color: '#555',
              border: '1px solid #d9d9d9',
              borderRadius: '6px',
              padding: '7px 14px',
              cursor: sendingAttachment ? 'not-allowed' : 'pointer',
            }}
          >
            Cancel
          </button>,
          <button
            key="send"
            type="button"
            className="ml-2"
            onClick={handleSendAttachment}
            disabled={sendingAttachment || !selectedFile}
            aria-label="Send attachment"
            style={{
              background: sendingAttachment ? '#83c99e' : '#008a3d',
              color: '#fff',
              border: 'none',
              borderRadius: '6px',
              padding: '7px 14px',
              cursor: sendingAttachment ? 'not-allowed' : 'pointer',
            }}
          >
            {sendingAttachment ? <LoadingOutlined /> : <SendOutlined />}
            <span style={{ marginLeft: '7px' }}>{sendingAttachment ? 'Sending...' : 'Send'}</span>
          </button>,
        ]}
      >
        {selectedFile && (
          <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', gap: '12px', padding: '12px 0' }}>
            {filePreviewUrl && selectedFile.type.startsWith('image/') ? (
              <img
                src={filePreviewUrl}
                alt={selectedFile.name}
                style={{ maxWidth: '100%', maxHeight: '320px', objectFit: 'contain' }}
              />
            ) : filePreviewUrl && (selectedFile.type === 'application/pdf' || selectedFile.name.toLowerCase().endsWith('.pdf')) ? (
              <iframe
                src={filePreviewUrl}
                title={`Preview of ${selectedFile.name}`}
                style={{ width: '100%', height: '60vh', minHeight: '360px', border: '1px solid #e5e5e5' }}
              />
            ) : (
              <FileOutlined style={{ fontSize: '48px', color: '#008a3d' }} />
            )}
            <div style={{ textAlign: 'center', wordBreak: 'break-word' }}>
              <div style={{ fontWeight: 600, color: '#333' }}>{selectedFile.name}</div>
              <div style={{ marginTop: '4px', color: '#888', fontSize: '12px' }}>
                {selectedFile.type || 'File'} · {(selectedFile.size / (1024 * 1024)).toFixed(2)} MB
              </div>
            </div>
          </div>
        )}
      </Modal>

      <SendLocationModal
        open={showLocationModal}
        sending={sendingLocation}
        onCancel={() => setShowLocationModal(false)}
        onSend={handleSendLocation}
      />

      {/* Empty chat warning — sticky at the bottom just above composer */}
      {!readOnly && !noWhatsappNumber && !isPast24Hours && messages.length === 0 && (
        <div style={{ background: '#fff', padding: '12px 16px', flexShrink: 0, borderTop: '1px solid #e8e8e8' }}>
          <div id="wa-no-chat-warning" style={{ margin: 0 }}>
            Send a template to start a conversation with Lead
          </div>
        </div>
      )}

      {/* Lead assigned to another user: history only, no templates, projects or message input */}
      {readOnly && (
        <div style={{ background: '#fff', padding: '12px 16px', flexShrink: 0, borderTop: '1px solid #e8e8e8' }}>
          <div id="wa-read-only-notice" style={{ margin: 0 }}>
            This lead is now assigned to another user. You can view your earlier conversation but can no longer send messages.
          </div>
        </div>
      )}

      {/* Message Composer (hidden when the user has no WhatsApp number; the notice is under the header) */}
      {(ALWAYS_SHOW_COMPOSER || (!readOnly && !noWhatsappNumber)) && (
      <div className="wa-composer-container">

        <div style={{ marginBottom: '8px', display: 'flex', gap: '8px' }}>
          <Tooltip title="Templates">
            <button
              className="wa-pill-btn"
              disabled={actionsLocked}
              onClick={() => setShowTemplates(!showTemplates)}
              style={{
                display: 'flex',
                alignItems: 'center',
                gap: '6px',
                background: '#fff',
                border: '1px solid #e0e0e0',
                borderRadius: '16px',
                padding: '4px 12px',
                cursor: 'pointer',
                fontSize: '12px',
                fontWeight: 500,
                color: '#555',
                boxShadow: '0 1px 2px rgba(0,0,0,0.02)',
                transition: 'all 0.2s'
              }}
              onMouseOver={(e) => {
                e.currentTarget.style.borderColor = '#008a3d';
                e.currentTarget.style.color = '#008a3d';
              }}
              onMouseOut={(e) => {
                e.currentTarget.style.borderColor = '#e0e0e0';
                e.currentTarget.style.color = '#555';
              }}
            >
              {/* <img src="/svg/add.svg" style={{ width: '14px', height: '14px' }} /> */}
              <UnorderedListOutlined style={{ fontSize: '14px' }} />
              <span>Templates</span>
            </button>
          </Tooltip>

          <Tooltip title="Projects">
            <button
              className="wa-pill-btn"
              disabled={actionsLocked}
              onClick={() => setShowProjectsDrawer(true)}
              style={{
                display: 'flex',
                alignItems: 'center',
                gap: '6px',
                background: '#fff',
                border: '1px solid #e0e0e0',
                borderRadius: '16px',
                padding: '4px 12px',
                cursor: 'pointer',
                fontSize: '12px',
                fontWeight: 500,
                color: '#555',
                boxShadow: '0 1px 2px rgba(0,0,0,0.02)',
                transition: 'all 0.2s'
              }}
              onMouseOver={(e) => {
                e.currentTarget.style.borderColor = '#008a3d';
                e.currentTarget.style.color = '#008a3d';
              }}
              onMouseOut={(e) => {
                e.currentTarget.style.borderColor = '#e0e0e0';
                e.currentTarget.style.color = '#555';
              }}
            >
              <UnorderedListOutlined style={{ fontSize: '14px' }} />
              <span>Projects</span>
            </button>
          </Tooltip>
        </div>

        {(!ALWAYS_SHOW_COMPOSER && ((!isPast24Hours && messages.length === 0) || isPast24Hours || actionsLocked)) ? null :
          <div className='wa-composer-input-container'>
            {/* Desktop layout: single row */}
            <div className="wa-composer desktop-composer" style={isComposerLocked ? { opacity: 0.6, backgroundColor: '#f5f5f5' } : {}}>
              <Input.TextArea
                id="wa-message-input"
                className="wa-composer-input"
                placeholder={isComposerLocked ? "24 hours window expired. Send a template to start." : "Type a new message"}
                value={messageText}
                onChange={(e) => handleMessageTextChange(e.target.value)}
                onKeyDown={handleKeyDown}
                bordered={false}
                autoSize={{ minRows: 1, maxRows: 6 }}
                disabled={isComposerLocked}
              />
              <div className="wa-composer-actions">
                <Tooltip title={isComposerLocked ? "Templates required to chat" : "Attach file"}>
                  <button
                    className="wa-composer-icon"
                    onClick={() => fileInputRef.current?.click()}
                    disabled={isComposerLocked || sendingAttachment}
                    style={isComposerLocked ? { cursor: 'not-allowed' } : {}}
                  >
                    <img src="/svg/attach-icon.svg" />
                  </button>
                </Tooltip>
                <Tooltip title={isComposerLocked ? "Templates required to chat" : "Send location"}>
                  <button
                    className="wa-composer-icon"
                    onClick={() => setShowLocationModal(true)}
                    disabled={isComposerLocked || sendingLocation}
                    style={isComposerLocked ? { cursor: 'not-allowed' } : {}}
                  >
                    <EnvironmentOutlined style={{ fontSize: 20, color: '#54656f' }} />
                  </button>
                </Tooltip>
                <div className="wa-composer-divider"></div>
                <Tooltip title="Send">
                  <button
                    className="wa-composer-icon"
                    onClick={handleSend}
                    disabled={isComposerLocked || !messageText.trim()}
                    style={isComposerLocked ? { cursor: 'not-allowed' } : {}}
                  >
                    {messageText.trim() && !isComposerLocked ?
                      <img src="/svg/send-active.svg" /> :
                      <img src="/svg/send-icon.svg" />}
                  </button>
                </Tooltip>
              </div>
            </div>

            {/* Mobile layout: card style – input on top, buttons on bottom */}
            <div className="wa-composer mobile-composer" style={isComposerLocked ? { opacity: 0.6, backgroundColor: '#f5f5f5' } : {}}>
              <Input.TextArea
                id="wa-message-input-mobile"
                className="wa-composer-input-mobile"
                placeholder={isComposerLocked ? "24 hours window expired. Send a template to start." : "Type a new message"}
                value={messageText}
                onChange={(e) => handleMessageTextChange(e.target.value)}
                onKeyDown={handleKeyDown}
                bordered={false}
                autoSize={{ minRows: 1, maxRows: 2 }}
                disabled={isComposerLocked}
              />
              <div className="wa-mobile-actions-row">
                <div className="wa-mobile-actions-left">
                  <Tooltip title={isComposerLocked ? "Templates required to chat" : "Attach file"}>
                    <button
                      className="wa-composer-icon"
                      onClick={() => fileInputRef.current?.click()}
                      disabled={isComposerLocked || sendingAttachment}
                      style={isComposerLocked ? { cursor: 'not-allowed' } : {}}
                    >
                      <img src="/svg/attach-icon.svg" />
                    </button>
                  </Tooltip>
                  <Tooltip title={isComposerLocked ? "Templates required to chat" : "Send location"}>
                    <button
                      className="wa-composer-icon"
                      onClick={() => setShowLocationModal(true)}
                      disabled={isComposerLocked || sendingLocation}
                      style={isComposerLocked ? { cursor: 'not-allowed' } : {}}
                    >
                      <EnvironmentOutlined style={{ fontSize: 20, color: '#54656f' }} />
                    </button>
                  </Tooltip>
                </div>
                <Tooltip title="Send">
                  <button
                    className="wa-composer-icon"
                    onClick={handleSend}
                    disabled={isComposerLocked || !messageText.trim()}
                    style={isComposerLocked ? { cursor: 'not-allowed' } : {}}
                  >
                    {messageText.trim() && !isComposerLocked ?
                      <img src="/svg/send-active.svg" /> :
                      <img src="/svg/send-icon.svg" />}
                  </button>
                </Tooltip>
              </div>
            </div>
          </div>
        }
      </div>
      )}
    </div>
  );
};

export default ChatView;
