import {
  useBookmarks,
  useBookmarkMutations,
  useBookmarkCollections,
  useBookmarkCollectionMutations,
  useSavedMessages,
  useSavedMessageMutations,
  useBookmarkExport,
} from '@/hooks/use-bookmarks'

// Get bookmarks
function MyComponent() {
  const { bookmarks, loading } = useBookmarks(filter, sortBy)
  const { addBookmark, removeBookmark } = useBookmarkMutations()

  // Add bookmark
  const handleBookmark = async (messageId: string) => {
    await addBookmark({
      messageId,
      note: 'Important message',
      tags: ['important', 'follow-up'],
    })
  }

  // Remove bookmark
  const handleRemove = async (bookmarkId: string) => {
    await removeBookmark(bookmarkId)
  }
}

// Collections
function CollectionManager() {
  const { collections } = useBookmarkCollections()
  const { createCollection, updateCollection } = useBookmarkCollectionMutations()

  const handleCreate = async () => {
    await createCollection({
      name: 'Work Tasks',
      description: 'Important work-related messages',
      icon: 'briefcase',
      color: 'blue',
    })
  }
}

// Saved messages
function SavedMessagesView() {
  const { savedMessages } = useSavedMessages()
  const { saveMessage, deleteSavedMessage } = useSavedMessageMutations()

  const handleSave = async (content: string) => {
    await saveMessage({
      content,
      note: 'Reminder',
      tags: ['todo'],
    })
  }
}

// Export
function ExportButton() {
  const { exportBookmarks } = useBookmarkExport()

  const handleExport = async () => {
    await exportBookmarks('json', {
      includeContent: true,
      includeAttachments: true,
    })
  }
}

import { BookmarkList } from '@/components/bookmarks/BookmarkList'
import { SavedMessages } from '@/components/bookmarks/SavedMessages'

// Bookmark list
<BookmarkList
  showFilters={true}
  showStats={true}
  viewMode="list"
/>

// Saved messages
<SavedMessages />

import { Bookmark, BookmarkCheck } from 'lucide-react'
import { useBookmarkByMessage, useBookmarkMutations } from '@/hooks/use-bookmarks'

function MessageActions({ messageId }) {
  const { bookmark, isBookmarked } = useBookmarkByMessage(messageId)
  const { toggleBookmark } = useBookmarkMutations()

  return (
    <Button
      onClick={() => toggleBookmark(messageId, bookmark?.id)}
      variant="ghost"
    >
      {isBookmarked ? (
        <BookmarkCheck className="h-4 w-4 text-primary" />
      ) : (
        <Bookmark className="h-4 w-4" />
      )}
    </Button>
  )
}

import { Bookmark, Save } from 'lucide-react'

function Sidebar() {
  return (
    <div>
      <SidebarItem href="/bookmarks" icon={Bookmark}>
        Bookmarks
      </SidebarItem>
      <SidebarItem href="/saved" icon={Save}>
        Saved Messages
      </SidebarItem>
    </div>
  )
}

// Test bookmark mutations
describe('useBookmarkMutations', () => {
  it('should add a bookmark', async () => {
    const { result } = renderHook(() => useBookmarkMutations())
    await act(async () => {
      await result.current.addBookmark({
        messageId: 'msg-123',
        note: 'Test note',
      })
    })
    // Assert bookmark was added
  })

  it('should remove a bookmark', async () => {
    const { result } = renderHook(() => useBookmarkMutations())
    await act(async () => {
      await result.current.removeBookmark('bookmark-123')
    })
    // Assert bookmark was removed
  })
})

// Test bookmark list
describe('BookmarkList', () => {
  it('should display bookmarks', () => {
    render(<BookmarkList />)
    expect(screen.getByText('Bookmarks')).toBeInTheDocument()
  })

  it('should filter by channel', async () => {
    render(<BookmarkList />)
    const select = screen.getByRole('combobox')
    await userEvent.click(select)
    await userEvent.click(screen.getByText('general'))
    // Assert filtered results
  })
})

// Apollo Client caching
const client = new ApolloClient({
  cache: new InMemoryCache({
    typePolicies: {
      Query: {
        fields: {
          nchat_bookmarks: {
            keyArgs: ['userId'],
            merge(existing = [], incoming) {
              return [...existing, ...incoming]
            },
          },
        },
      },
    },
  }),
})

// GraphQL permissions
permissions: {
  nchat_bookmarks: {
    select: { user_id: { _eq: 'X-Hasura-User-Id' } },
    insert: { user_id: { _eq: 'X-Hasura-User-Id' } },
    update: { user_id: { _eq: 'X-Hasura-User-Id' } },
    delete: { user_id: { _eq: 'X-Hasura-User-Id' } },
  },
}