preview.go

package main

import (
	"bufio"
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"github.com/alecthomas/chroma/v2"
	"github.com/alecthomas/chroma/v2/formatters"
	"github.com/alecthomas/chroma/v2/lexers"
	"github.com/alecthomas/chroma/v2/styles"
	tea "github.com/charmbracelet/bubbletea"
)

// PreviewService generates file previews.
type PreviewService struct {
	maxLines  int
	style     *chroma.Style
	formatter chroma.Formatter
}

// NewPreviewService creates a new PreviewService.
func NewPreviewService(maxLines int) *PreviewService {
	if maxLines <= 0 {
		maxLines = 500
	}

	style := styles.Get("monokai")
	if style == nil {
		style = styles.Fallback
	}

	formatter := formatters.Get("terminal256")
	if formatter == nil {
		formatter = formatters.Fallback
	}

	return &PreviewService{
		maxLines:  maxLines,
		style:     style,
		formatter: formatter,
	}
}

// Supported languages for MVP.
var supportedLangs = map[string]bool{
	".go":   true,
	".py":   true,
	".js":   true,
	".ts":   true,
	".rs":   true,
	".c":    true,
	".cpp":  true,
	".h":    true,
	".hpp":  true,
	".java": true,
	".md":   true,
}

// Generate generates a preview for the given file.
func (p *PreviewService) Generate(path string, width int) (string, error) {
	ext := filepath.Ext(path)

	// Check if it's a text file
	if !IsTextFile(ext) {
		return "[Binary file - no preview]", nil
	}

	// Read file with line limit to avoid OOM on large files
	lines, truncated, err := readLinesLimited(path, p.maxLines)
	if err != nil {
		return fmt.Sprintf("[Error reading file: %v]", err), nil
	}

	text := strings.Join(lines, "\n")

	var result string
	if supportedLangs[ext] || ext == ".json" || ext == ".yaml" || ext == ".yml" {
		result, err = p.highlight(text, path, width)
		if err != nil {
			result = text // fallback to plain text
		}
	} else {
		result = text
	}

	if truncated {
		result += fmt.Sprintf("\n\n... (truncated, showing first %d lines)", p.maxLines)
	}

	return result, nil
}

// GenerateAsync returns a tea.Cmd that generates a preview asynchronously.
func (p *PreviewService) GenerateAsync(path string, width int) tea.Cmd {
	return func() tea.Msg {
		content, err := p.Generate(path, width)
		return PreviewResultMsg{
			path:    path,
			content: content,
			err:     err,
		}
	}
}

// readLinesLimited reads up to maxLines from a file using a buffered scanner.
// Returns the lines, whether it was truncated, and any error.
func readLinesLimited(path string, maxLines int) ([]string, bool, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, false, err
	}
	defer f.Close()

	var lines []string
	scanner := bufio.NewScanner(f)
	scanner.Buffer(make([]byte, 64*1024), 64*1024) // 64KB buffer

	for scanner.Scan() {
		lines = append(lines, scanner.Text())
		if len(lines) >= maxLines {
			return lines, true, nil
		}
	}

	if err := scanner.Err(); err != nil {
		// Return what we have so far with the error
		return lines, false, err
	}

	return lines, false, nil
}

// highlight applies syntax highlighting to the content.
func (p *PreviewService) highlight(content, path string, width int) (string, error) {
	lexer := lexers.Match(path)
	if lexer == nil {
		lexer = lexers.Fallback
	}

	iterator, err := lexer.Tokenise(nil, content)
	if err != nil {
		return content, err
	}

	var buf strings.Builder
	err = p.formatter.Format(&buf, p.style, iterator)
	if err != nil {
		return content, err
	}

	return buf.String(), nil
}