import { useState, useEffect, useCallback, useMemo, useRef } from 'react';
import { dataService } from '../services/dataService';
import { IAuditLog } from '../types';

export const useAuditLogs = (options?: { enabled?: boolean }) => {
  const enabled = options?.enabled !== false;
  const enabledRef = useRef(enabled);
  enabledRef.current = enabled;

  const [logs, setLogs] = useState<IAuditLog[]>([]);
  const [loading, setLoading] = useState(false);
  const [currentPage, setCurrentPage] = useState(1);
  const [hasMore, setHasMore] = useState(true);
  const [filter, setFilter] = useState<{
    action?: string;
    userId?: string;
    targetCollection?: string;
    search?: string;
  }>({});

  const loadLogs = useCallback(async (page: number = 1, reset: boolean = false) => {
    if (!enabledRef.current) {
      setLoading(false);
      return;
    }
    try {
      setLoading(true);
      const response = await dataService.getLogs(undefined, page);
      
      if (reset) {
        setLogs(response.data);
      } else {
        setLogs(prev => {
          const existingIds = new Set(prev.map(p => p._id));
          const newLogs = response.data.filter(log => !existingIds.has(log._id));
          return [...prev, ...newLogs];
        });
      }
      
      setHasMore(response.pagination?.hasMore ?? false);
      setCurrentPage(page);
    } catch (error) {
      console.error('Error loading logs:', error);
    } finally {
      setLoading(false);
    }
  }, []);

  const loadMore = useCallback(() => {
    if (!loading && hasMore) {
      loadLogs(currentPage + 1, false);
    }
  }, [loading, hasMore, currentPage, loadLogs]);

  const applyFilter = useCallback((newFilter: typeof filter) => {
    setFilter(newFilter);
    setCurrentPage(1);
    setHasMore(true);
    // Note: Backend filtering would be implemented here
    // For now, we'll filter client-side
  }, []);

  const filteredLogs = useMemo(() => {
    return logs.filter(log => {
      if (filter.action && log.action !== filter.action) return false;
      if (filter.userId && log.userId !== filter.userId) return false;
      if (filter.targetCollection && log.targetCollection !== filter.targetCollection) return false;
      if (filter.search) {
        const searchLower = filter.search.toLowerCase();
        return (
          log.details.toLowerCase().includes(searchLower) ||
          log.userId.toLowerCase().includes(searchLower) ||
          log.action.toLowerCase().includes(searchLower)
        );
      }
      return true;
    });
  }, [logs, filter]);

  useEffect(() => {
    if (!enabled) {
      setLogs([]);
      setHasMore(true);
      setCurrentPage(1);
      setLoading(false);
      return;
    }
    loadLogs(1, true);
  }, [enabled, loadLogs]);

  return {
    logs: filteredLogs,
    loading,
    hasMore,
    currentPage,
    filter,
    loadMore,
    applyFilter,
    reload: () => loadLogs(1, true)
  };
};