'use client';
import React, { useEffect, useState, useRef } from 'react';
import { Table, Space, notification, Tag, Select, Input, DatePicker, Tooltip, Button, Modal } from 'antd';
import type { ColumnsType } from 'antd/es/table';
import { PlayCircleOutlined, PauseCircleOutlined, PhoneOutlined } from '@ant-design/icons';
import type { Dayjs } from 'dayjs';
import { getWebCallLogs } from './service';
import type { WebCallLog, Filters } from './interface';
import PageHeader from '@/components/pageHeader';
import { TablePaginationConfig } from 'antd/lib';
import { useDebounce } from 'use-debounce';

const { RangePicker } = DatePicker;

const STATUS_COLOR: Record<string, string> = {
  ANSWERED: 'green',
  COMPLETED: 'green',
  'NO ANSWER': 'orange',
  NOANSWER: 'orange',
  BUSY: 'gold',
  FAILED: 'red',
  CANCELLED: 'red',
  CANCELED: 'red',
};

const RECORDING_BASE_URL = 'https://housieypbx.callanywhere.co.in';
const ASTERISK_SPOOL_PREFIX = '/var/spool/asterisk';

// Turns the stored recording path into a playable link, e.g.
//   /var/spool/asterisk/monitor/2026/09/21/x.wav -> https://housieypbx.callanywhere.co.in/monitor/2026/09/21/x.wav
// A path that already contains the PBX host is used as it is.
const getPlayableRecordingUrl = (path?: string | null): string => {
  const value = (path || '').trim();
  if (!value) return '';
  if (value.includes(`${RECORDING_BASE_URL}/`)) return value;
  const withoutSpool = value.split(ASTERISK_SPOOL_PREFIX).join('');
  return `${RECORDING_BASE_URL}/${withoutSpool.replace(/^\/+/, '')}`;
};

const formatDuration = (seconds?: number | null): string => {
  if (!seconds || seconds <= 0) return '00:00';
  const mins = Math.floor(seconds / 60);
  const secs = seconds % 60;
  return `${String(mins).padStart(2, '0')}:${String(secs).padStart(2, '0')}`;
};

const CallLogList: React.FC = () => {
  const [data, setData] = useState<WebCallLog[]>([]);
  const [total, setTotal] = useState(0);
  const [loading, setLoading] = useState(false);

  const [searchTerm, setSearchTerm] = useState('');
  const [debouncedSearch] = useDebounce(searchTerm, 500);
  const isFirstMount = useRef(true);

  const [dateRange, setDateRange] = useState<[Dayjs | null, Dayjs | null] | null>(null);

  const [recordingModal, setRecordingModal] = useState<{ visible: boolean; url: string | null }>({
    visible: false,
    url: null,
  });
  const [isPlaying, setIsPlaying] = useState(false);
  const audioRef = useRef<HTMLAudioElement | null>(null);

  const openRecordingModal = (url: string): void => {
    setRecordingModal({ visible: true, url });
    setIsPlaying(false);
  };

  const closeRecordingModal = (): void => {
    if (audioRef.current) {
      audioRef.current.pause();
    }
    setRecordingModal({ visible: false, url: null });
    setIsPlaying(false);
  };

  const togglePlayPause = (): void => {
    const audio = audioRef.current;
    if (!audio) return;
    if (isPlaying) {
      audio.pause();
    } else {
      audio.play();
    }
  };

  const [filters, setFilters] = useState<Filters>({
    page: 1,
    limit: 10,
    search: '',
    status: undefined,
    call_type: undefined,
    sortColumn: 'created_at',
    sortOrder: 'desc',
  });

  const fetchLogs = (currentFilters: Filters): void => {
    setLoading(true);
    getWebCallLogs(currentFilters)
      .then((response) => {
        const result = response?.data || {};
        setData(result.data || []);
        setTotal(result.meta?.total || 0);
      })
      .catch((error) => {
        const { message } = error?.response?.data || {};
        notification.error({
          message: 'Error',
          description: message || 'Failed to fetch call logs.',
        });
      })
      .finally(() => {
        setLoading(false);
      });
  };

  useEffect(() => {
    fetchLogs(filters);
  }, [filters]);

  useEffect(() => {
    if (isFirstMount.current) {
      isFirstMount.current = false;
      return;
    }
    setFilters((prev) => ({
      ...prev,
      page: 1,
      search: debouncedSearch,
    }));
  }, [debouncedSearch]);

  const onTableChange = (pagination: TablePaginationConfig, _tableFilters: any, sorter: any): void => {
    setFilters((prev) => ({
      ...prev,
      page: pagination.current,
      limit: pagination.pageSize,
      sortColumn: sorter?.field || prev.sortColumn,
      sortOrder: sorter?.order ? (sorter.order === 'ascend' ? 'asc' : 'desc') : prev.sortOrder,
    }));
  };

  const onDateRangeChange = (dates: [Dayjs | null, Dayjs | null] | null): void => {
    setDateRange(dates);
    setFilters((prev) => ({
      ...prev,
      page: 1,
      start_date: dates && dates[0] ? dates[0].format('YYYY-MM-DD') : undefined,
      end_date: dates && dates[1] ? dates[1].format('YYYY-MM-DD') : undefined,
    }));
  };

  const columns: ColumnsType<WebCallLog> = [
    {
      title: 'Call ID',
      dataIndex: 'call_id',
      key: 'call_id',
      width: 160,
      ellipsis: true,
      render: (value) => value || <span style={{ color: '#bfbfbf' }}>N/A</span>,
    },
    {
      title: 'Customer Number',
      dataIndex: 'customer_number',
      key: 'customer_number',
      width: 160,
      render: (value) =>
        value ? (
          <Space size={4}>
            <PhoneOutlined style={{ color: '#2e7d32' }} />
            {value}
          </Space>
        ) : (
          <span style={{ color: '#bfbfbf' }}>N/A</span>
        ),
    },
    {
      title: 'Agent Number',
      dataIndex: 'internal_agent',
      key: 'internal_agent',
      width: 140,
      render: (value) => value || <span style={{ color: '#bfbfbf' }}>N/A</span>,
    },
    {
      title: 'Caller ID',
      dataIndex: 'outbound_callerid',
      key: 'outbound_callerid',
      width: 140,
      render: (value) => value || <span style={{ color: '#bfbfbf' }}>N/A</span>,
    },
    {
      title: 'Call Type',
      dataIndex: 'call_type',
      key: 'call_type',
      width: 110,
      render: (value) => value || <span style={{ color: '#bfbfbf' }}>N/A</span>,
    },
    {
      title: 'Event Type',
      dataIndex: 'event_type',
      key: 'event_type',
      width: 140,
      render: (value) => value || <span style={{ color: '#bfbfbf' }}>N/A</span>,
    },
    {
      title: 'Status',
      dataIndex: 'status',
      key: 'status',
      width: 130,
      render: (value: string) =>
        value ? (
          <Tag color={STATUS_COLOR[value?.toUpperCase()] || 'blue'}>{value}</Tag>
        ) : (
          <span style={{ color: '#bfbfbf' }}>N/A</span>
        ),
    },
    {
      title: 'Duration',
      dataIndex: 'duration',
      key: 'duration',
      width: 100,
      sorter: true,
      render: (value: number) => formatDuration(value),
    },
    {
      title: 'Recording',
      dataIndex: 'recording_path',
      key: 'recording_path',
      width: 100,
      align: 'center',
      render: (value: string) =>
        value ? (
          <Tooltip title="Play recording">
            <Button
              type="primary"
              shape="circle"
              size="small"
              icon={<PlayCircleOutlined />}
              onClick={() => openRecordingModal(value)}
            />
          </Tooltip>
        ) : (
          <span style={{ color: '#bfbfbf' }}>N/A</span>
        ),
    },
    {
      title: 'Created At',
      dataIndex: 'created_at',
      key: 'created_at',
      width: 180,
      sorter: true,
      render: (date: string) => (date ? new Date(date).toLocaleString() : '-'),
    },
  ];

  return (
    <div>
      <PageHeader
        title="Call Log"
        isBack={false}
        extra={
          <Space size="middle" align="center" wrap>
            <Input
              placeholder="Search by Call ID/Number/Agent"
              allowClear
              value={searchTerm}
              onChange={(e) => setSearchTerm(e.target.value)}
              style={{ width: 240 }}
            />
            <Select
              placeholder="Filter status"
              allowClear
              style={{ width: 160 }}
              value={filters.status}
              onChange={(value) => {
                setFilters((prev) => ({
                  ...prev,
                  page: 1,
                  status: value,
                }));
              }}
              options={[
                { value: 'ANSWERED', label: 'Answered' },
                { value: 'NO ANSWER', label: 'No Answer' },
                { value: 'BUSY', label: 'Busy' },
                { value: 'FAILED', label: 'Failed' },
              ]}
            />
            <Select
              placeholder="Filter call type"
              allowClear
              style={{ width: 150 }}
              value={filters.call_type}
              onChange={(value) => {
                setFilters((prev) => ({
                  ...prev,
                  page: 1,
                  call_type: value,
                }));
              }}
              options={[
                { value: 'mobile', label: 'Mobile' },
                { value: 'agent', label: 'Agent' },
              ]}
            />
            <RangePicker
              value={dateRange}
              onChange={(dates) => onDateRangeChange(dates as [Dayjs | null, Dayjs | null] | null)}
              allowClear
            />
          </Space>
        }
      />

      <div style={{ marginTop: 16 }}>
        <Table
          loading={loading}
          rowKey="id"
          columns={columns}
          bordered
          dataSource={data}
          onChange={onTableChange}
          scroll={{ x: true }}
          pagination={{
            pageSize: filters.limit,
            current: filters.page,
            total: total,
            showSizeChanger: true,
            pageSizeOptions: ['10', '20', '50', '100'],
            defaultPageSize: 10,
            showTotal: (total, range) => `${range[0]}-${range[1]} of ${total} entries`,
          }}
        />
      </div>

      <Modal
        title="Call Recording"
        open={recordingModal.visible}
        onCancel={closeRecordingModal}
        footer={null}
        className="custom-new-modal"
        destroyOnClose>
        {recordingModal.url && (
          <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', gap: 16, padding: '16px 0' }}>
            <Button
              type="primary"
              shape="circle"
              size="large"
              icon={isPlaying ? <PauseCircleOutlined /> : <PlayCircleOutlined />}
              onClick={togglePlayPause}
            />
            <audio
              ref={audioRef}
              src={getPlayableRecordingUrl(recordingModal.url)}
              style={{ width: '100%' }}
              controls
              onPlay={() => setIsPlaying(true)}
              onPause={() => setIsPlaying(false)}
              onEnded={() => setIsPlaying(false)}
            />
          </div>
        )}
      </Modal>
    </div>
  );
};

export default CallLogList;
