// Name: Smart Clipboard Archive
// Description: Archive clipboard content with AI-powered categorization and quick retrieval
// Author: CoffiDev
// GitHub: CoffiDev

import '@johnlindquist/kit'

interface ClipboardEntry {
  id: string
  content: string
  type: 'text' | 'image' | 'url'
  category: string
  timestamp: string
  preview: string
}

interface GroupedEntries {
  [category: string]: ClipboardEntry[]
}

// Constants for configuration
const MAX_ENTRIES = 100
const MIN_CONTENT_LENGTH = 5
const PREVIEW_LENGTH = 100
const CATEGORY_SAMPLE_LENGTH = 200
const ENTRIES_PER_CATEGORY = 10

// Initialize clipboard archive database
const archiveDb = await db('clipboard-archive', { entries: [] as ClipboardEntry[] })

// AI categorizer for smart organization
const categorizeContent = ai('Categorize this content into one of these categories: work, personal, code, reference, media, other. Return only the category name.')

/**
 * Determines content type based on content analysis
 */
function getContentType(content: string): ClipboardEntry['type'] {
  if (content.startsWith('http://') || content.startsWith('https://')) {
    return 'url'
  }
  // Could be extended to detect image data URLs, etc.
  return 'text'
}

/**
 * Creates a preview string for display purposes
 */
function createPreview(content: string): string {
  return content.length > PREVIEW_LENGTH 
    ? content.substring(0, PREVIEW_LENGTH) + '...'
    : content
}

/**
 * Archives new clipboard content if it meets criteria
 */
async function archiveClipboardContent(): Promise<void> {
  try {
    const currentClipboard = await clipboard.readText()
    
    // Validate clipboard content
    if (!currentClipboard || currentClipboard.length <= MIN_CONTENT_LENGTH) {
      return
    }

    const existingEntries = archiveDb.entries as ClipboardEntry[]
    
    // Check for duplicates to avoid redundant entries
    const isDuplicate = existingEntries.some(entry => entry.content === currentClipboard)
    if (isDuplicate) {
      return
    }

    // Categorize content using AI (with error handling)
    let category = 'other'
    try {
      const categoryResult = await categorizeContent(
        currentClipboard.substring(0, CATEGORY_SAMPLE_LENGTH)
      )
      category = categoryResult.toLowerCase().trim()
    } catch (error) {
      console.warn('Failed to categorize content, using default category:', error)
    }

    // Create new entry
    const newEntry: ClipboardEntry = {
      id: uuid(),
      content: currentClipboard,
      type: getContentType(currentClipboard),
      category,
      timestamp: new Date().toISOString(),
      preview: createPreview(currentClipboard)
    }
    
    // Add to beginning and maintain size limit
    archiveDb.entries.unshift(newEntry)
    if (archiveDb.entries.length > MAX_ENTRIES) {
      archiveDb.entries = archiveDb.entries.slice(0, MAX_ENTRIES)
    }
    
    await archiveDb.write()
  } catch (error) {
    console.error('Failed to archive clipboard content:', error)
  }
}

/**
 * Groups entries by category for organized display
 */
function groupEntriesByCategory(entries: ClipboardEntry[]): GroupedEntries {
  return entries.reduce((groups: GroupedEntries, entry) => {
    const category = entry.category || 'other'
    if (!groups[category]) {
      groups[category] = []
    }
    groups[category].push(entry)
    return groups
  }, {})
}

/**
 * Creates formatted choices for the selection interface
 */
function createChoicesFromGroups(groupedEntries: GroupedEntries) {
  const choices = []
  
  for (const [category, entries] of Object.entries(groupedEntries)) {
    // Add category header
    choices.push({
      name: `📁 ${category.toUpperCase()}`,
      group: category,
      info: true,
      miss: true
    })
    
    // Add entries for this category (limited per category)
    entries.slice(0, ENTRIES_PER_CATEGORY).forEach(entry => {
      choices.push({
        name: entry.preview,
        description: `${formatDateToNow(new Date(entry.timestamp))} • ${entry.type}`,
        value: entry,
        group: category,
        preview: () => md(`
### ${entry.type === 'url' ? 'URL' : 'Text'} Content
**Category:** ${entry.category}  
**Saved:** ${formatDate(new Date(entry.timestamp), 'PPpp')}

\`\`\`
${entry.content}
\`\`\`
        `)
      })
    })
  }
  
  return choices
}

/**
 * Handles entry deletion with proper cleanup
 */
async function deleteEntry(entryId: string): Promise<void> {
  try {
    archiveDb.entries = archiveDb.entries.filter(e => e.id !== entryId)
    await archiveDb.write()
    await toast('Entry deleted')
    // Refresh the interface
    await run('smart-clipboard-archive')
  } catch (error) {
    console.error('Failed to delete entry:', error)
    await toast('Failed to delete entry')
  }
}

// Main execution flow
async function main(): Promise<void> {
  // Archive current clipboard content
  await archiveClipboardContent()

  const existingEntries = archiveDb.entries as ClipboardEntry[]
  
  // Handle empty archive case
  if (existingEntries.length === 0) {
    await div(md('# Clipboard Archive Empty\nCopy some text to start building your archive!'))
    return
  }

  // Prepare organized choices
  const groupedEntries = groupEntriesByCategory(existingEntries)
  const choices = createChoicesFromGroups(groupedEntries)

  // Main interface with comprehensive actions
  const selectedEntry = await arg({
    placeholder: 'Search your clipboard archive...',
    enter: 'Paste Selected',
    actions: [
      {
        name: 'Copy to Clipboard',
        shortcut: 'cmd+c',
        onAction: async (input, { focused }) => {
          if (focused?.value?.content) {
            await clipboard.writeText(focused.value.content)
            await toast('Copied to clipboard!')
          }
        }
      },
      {
        name: 'Paste & Replace',
        shortcut: 'cmd+v',
        onAction: async (input, { focused }) => {
          if (focused?.value?.content) {
            await setSelectedText(focused.value.content)
            submit(focused.value)
          }
        }
      },
      {
        name: 'Delete Entry',
        shortcut: 'cmd+d',
        onAction: async (input, { focused }) => {
          if (focused?.value?.id) {
            await deleteEntry(focused.value.id)
          }
        }
      },
      {
        name: 'Open URL',
        shortcut: 'cmd+o',
        condition: (choice) => choice?.value?.type === 'url',
        onAction: async (input, { focused }) => {
          if (focused?.value?.type === 'url') {
            try {
              await browse(focused.value.content)
            } catch (error) {
              console.error('Failed to open URL:', error)
              await toast('Failed to open URL')
            }
          }
        }
      }
    ]
  }, choices)

  // Default action: paste the selected content
  if (selectedEntry?.content) {
    await setSelectedText(selectedEntry.content)
  }
}

// Execute main function with error handling
try {
  await main()
} catch (error) {
  console.error('Script execution failed:', error)
  await div(md('# Error\nSomething went wrong. Please try again.'))
}