package main

import (
	"context"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io/fs"
	"os"
	"os/exec"
	"os/user"
	"path/filepath"
	"runtime"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/charmbracelet/bubbles/table"
	"github.com/charmbracelet/bubbles/textinput"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
)

const Version = "v0.1.0"

var (
	videoExtensions = map[string]struct{}{
		".mp4": {},
		".mkv": {},
		".mov": {},
		".avi": {},
		".wmv": {},
		".m4v": {},
	}
	tableStyle     = lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(lipgloss.Color("63")).Padding(0, 1)
	headerStyle    = lipgloss.NewStyle().Foreground(lipgloss.Color("99")).Bold(true)
	filterStyle    = lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(lipgloss.Color("105")).Padding(1, 2)
	statusStyle    = lipgloss.NewStyle().Foreground(lipgloss.Color("244"))
	highlightStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("212")).Bold(true)
)

type video struct {
	Name     string
	Path     string
	Duration time.Duration
	ModTime  time.Time
	Size     int64
	Err      error
}

type videosLoadedMsg struct {
	videos   []video
	err      error
	cacheErr error
	pending  []string
	cache    *durationCache
}

type playVideoMsg struct {
	path string
	err  error
}

type progressUpdateMsg struct {
	processed int
	total     int
	done      bool
}

type durationUpdateMsg struct {
	path     string
	duration time.Duration
	err      error
}

type loadProgress struct {
	mu        sync.Mutex
	total     int
	processed int
	done      bool
}

func (p *loadProgress) Reset() {
	if p == nil {
		return
	}
	p.mu.Lock()
	defer p.mu.Unlock()
	p.total = 0
	p.processed = 0
	p.done = false
}

func (p *loadProgress) SetTotal(total int) {
	if p == nil {
		return
	}
	p.mu.Lock()
	p.total = total
	p.mu.Unlock()
}

func (p *loadProgress) Increment() {
	if p == nil {
		return
	}
	p.mu.Lock()
	p.processed++
	p.mu.Unlock()
}

func (p *loadProgress) MarkDone() {
	if p == nil {
		return
	}
	p.mu.Lock()
	p.done = true
	p.mu.Unlock()
}

func (p *loadProgress) Snapshot() (processed, total int, done bool) {
	if p == nil {
		return 0, 0, true
	}
	p.mu.Lock()
	defer p.mu.Unlock()
	return p.processed, p.total, p.done
}

type cacheEntry struct {
	DurationSeconds float64 `json:"duration_seconds"`
	ModTimeUnix     int64   `json:"mod_time_unix"`
	Size            int64   `json:"size"`
}

type durationCache struct {
	path    string
	entries map[string]cacheEntry
	mu      sync.Mutex
	dirty   bool
}

func newDurationCache(path string) *durationCache {
	return &durationCache{
		path:    path,
		entries: make(map[string]cacheEntry),
	}
}

func loadDurationCache(path string) (*durationCache, error) {
	cache := newDurationCache(path)
	data, err := os.ReadFile(path)
	if err != nil {
		if errors.Is(err, fs.ErrNotExist) {
			return cache, nil
		}
		return cache, err
	}
	if len(data) == 0 {
		return cache, nil
	}
	if err := json.Unmarshal(data, &cache.entries); err != nil {
		cache.entries = make(map[string]cacheEntry)
		return cache, err
	}
	return cache, nil
}

func (c *durationCache) Lookup(path string, info os.FileInfo) (time.Duration, bool) {
	c.mu.Lock()
	defer c.mu.Unlock()
	entry, ok := c.entries[path]
	if !ok {
		return 0, false
	}
	if entry.ModTimeUnix != info.ModTime().Unix() || entry.Size != info.Size() {
		delete(c.entries, path)
		c.dirty = true
		return 0, false
	}
	if entry.DurationSeconds <= 0 {
		return 0, false
	}
	return time.Duration(entry.DurationSeconds * float64(time.Second)), true
}

func (c *durationCache) Record(path string, info os.FileInfo, dur time.Duration) error {
	if c == nil || dur <= 0 {
		return nil
	}
	c.mu.Lock()
	defer c.mu.Unlock()
	if c.entries == nil {
		c.entries = make(map[string]cacheEntry)
	}
	c.entries[path] = cacheEntry{
		DurationSeconds: dur.Seconds(),
		ModTimeUnix:     info.ModTime().Unix(),
		Size:            info.Size(),
	}
	c.dirty = true
	return nil
}

func (c *durationCache) Flush() error {
	if c == nil {
		return nil
	}
	c.mu.Lock()
	if !c.dirty {
		c.mu.Unlock()
		return nil
	}
	snapshot := make(map[string]cacheEntry, len(c.entries))
	for k, v := range c.entries {
		snapshot[k] = v
	}
	c.dirty = false
	c.mu.Unlock()

	data, err := json.MarshalIndent(snapshot, "", "  ")
	if err != nil {
		return err
	}
	tmp := c.path + ".tmp"
	if err := os.WriteFile(tmp, data, 0o644); err != nil {
		return err
	}
	return os.Rename(tmp, c.path)
}

type sortField int

const (
	sortByName sortField = iota
	sortByDuration
	sortByAge
)

type filterState struct {
	name       string
	minEnabled bool
	minMinutes int
	maxEnabled bool
	maxMinutes int
}

type filterInputs struct {
	fields []textinput.Model
	focus  int
}

type model struct {
	table            table.Model
	videos           []video
	filtered         []video
	filters          filterState
	inputs           filterInputs
	showFilters      bool
	sortField        sortField
	sortAscending    bool
	statusMessage    string
	loading          bool
	err              error
	root             string
	progress         *loadProgress
	cachePath        string
	cache            *durationCache
	pendingDurations []string
	durationTotal    int
	durationDone     int
	durationInFlight int
	cropValue        string
	cropEnabled      bool
}

func main() {
	rootFlag := flag.String("root", "", "Directory containing yoga videos (default ~/Yoga)")
	crop := flag.String("crop", "", "Optional crop aspect for VLC (e.g. 5:4)")
	printVersion := flag.Bool("version", false, "Print version and exit")
	flag.Parse()

	if *printVersion {
		fmt.Println("Yoga version", Version)
		os.Exit(0)
	}

	root, err := resolveRootPath(*rootFlag)
	if err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		os.Exit(1)
	}

	m := newModel(root, strings.TrimSpace(*crop))
	if err := tea.NewProgram(m, tea.WithAltScreen()).Start(); err != nil {
		fmt.Fprintf(os.Stderr, "error: %v\n", err)
		os.Exit(1)
	}
}

func resolveRootPath(flagValue string) (string, error) {
	value := strings.TrimSpace(flagValue)
	isDefault := value == ""
	if isDefault {
		value = "~/Yoga"
	}
	expanded, err := expandPath(value)
	if err != nil {
		return "", fmt.Errorf("cannot expand root path %q: %w", value, err)
	}
	abs, err := filepath.Abs(expanded)
	if err != nil {
		return "", fmt.Errorf("cannot resolve root path %q: %w", expanded, err)
	}
	info, statErr := os.Stat(abs)
	if statErr != nil {
		if errors.Is(statErr, fs.ErrNotExist) {
			if isDefault {
				if mkErr := os.MkdirAll(abs, 0o755); mkErr != nil {
					return "", fmt.Errorf("cannot create default directory %q: %w", abs, mkErr)
				}
				info, statErr = os.Stat(abs)
				if statErr != nil {
					return "", fmt.Errorf("cannot stat default directory %q: %w", abs, statErr)
				}
			} else {
				return "", fmt.Errorf("root path does not exist: %s", abs)
			}
		} else {
			return "", fmt.Errorf("cannot access root path %q: %w", abs, statErr)
		}
	}
	if info.IsDir() || info.Mode().IsRegular() {
		return abs, nil
	}
	return "", fmt.Errorf("root path %q is not a file or directory", abs)
}

func expandPath(p string) (string, error) {
	if p == "" || p[0] != '~' {
		return p, nil
	}
	if len(p) == 1 {
		home, err := os.UserHomeDir()
		if err != nil {
			return "", err
		}
		return home, nil
	}
	if p[1] == '/' {
		home, err := os.UserHomeDir()
		if err != nil {
			return "", err
		}
		return filepath.Join(home, p[2:]), nil
	}
	sep := strings.IndexRune(p, '/')
	var username, rest string
	if sep == -1 {
		username = p[1:]
	} else {
		username = p[1:sep]
		rest = p[sep:]
	}
	usr, err := user.Lookup(username)
	if err != nil {
		return "", err
	}
	if rest == "" {
		return usr.HomeDir, nil
	}
	return filepath.Join(usr.HomeDir, rest), nil
}

func newModel(root, vlcCrop string) model {
	columns := []table.Column{
		{Title: headerStyle.Render("Name"), Width: 50},
		{Title: headerStyle.Render("Duration"), Width: 12},
		{Title: headerStyle.Render("Age"), Width: 14},
		{Title: headerStyle.Render("Path"), Width: 40},
	}

	tbl := table.New(
		table.WithColumns(columns),
		table.WithFocused(true),
		table.WithHeight(15),
	)
	tbl.SetStyles(table.DefaultStyles())

	nameInput := textinput.New()
	nameInput.Placeholder = "substring"
	nameInput.Prompt = "Name: "
	nameInput.CharLimit = 256

	minInput := textinput.New()
	minInput.Placeholder = "min minutes"
	minInput.Prompt = "Min minutes: "
	minInput.CharLimit = 4
	minInput.SetValue("")

	maxInput := textinput.New()
	maxInput.Placeholder = "max minutes"
	maxInput.Prompt = "Max minutes: "
	maxInput.CharLimit = 4
	maxInput.SetValue("")

	inputs := filterInputs{
		fields: []textinput.Model{nameInput, minInput, maxInput},
		focus:  0,
	}
	inputs.fields[0].Focus()

	progress := &loadProgress{}
	cachePath := filepath.Join(root, ".video_duration_cache.json")

	return model{
		table:         tbl,
		inputs:        inputs,
		sortField:     sortByName,
		sortAscending: true,
		statusMessage: "Scanning for videos...",
		loading:       true,
		root:          root,
		progress:      progress,
		cachePath:     cachePath,
		cropValue:     vlcCrop,
		cropEnabled:   vlcCrop != "",
	}
}

func (m model) Init() tea.Cmd {
	if m.progress != nil {
		m.progress.Reset()
	}
	loadCmd := loadVideosCmd(m.root, m.cachePath, m.progress)
	if m.progress != nil {
		return tea.Batch(loadCmd, progressTickerCmd(m.progress))
	}
	return loadCmd
}

func loadVideosCmd(root, cachePath string, progress *loadProgress) tea.Cmd {
	return func() tea.Msg {
		cache, cacheErr := loadDurationCache(cachePath)
		vids, pending, err := loadVideos(root, cache, progress)
		if progress != nil {
			progress.MarkDone()
		}
		return videosLoadedMsg{videos: vids, err: err, cacheErr: cacheErr, pending: pending, cache: cache}
	}
}

func progressTickerCmd(progress *loadProgress) tea.Cmd {
	if progress == nil {
		return nil
	}
	return tea.Tick(200*time.Millisecond, func(time.Time) tea.Msg {
		processed, total, done := progress.Snapshot()
		return progressUpdateMsg{processed: processed, total: total, done: done}
	})
}

func collectVideoPaths(root string) ([]string, error) {
	info, err := os.Stat(root)
	if err != nil {
		return nil, err
	}
	if !info.IsDir() {
		if isVideo(root) {
			return []string{root}, nil
		}
		return nil, nil
	}
	visited := make(map[string]struct{})
	var paths []string
	if err := traverseVideoPaths(root, root, visited, &paths); err != nil {
		return nil, err
	}
	sort.Strings(paths)
	return paths, nil
}

func traverseVideoPaths(displayPath, realPath string, visited map[string]struct{}, acc *[]string) error {
	resolved, err := filepath.EvalSymlinks(realPath)
	if err != nil {
		resolved = realPath
	}
	resolved = filepath.Clean(resolved)
	if _, seen := visited[resolved]; seen {
		return nil
	}
	visited[resolved] = struct{}{}

	entries, err := os.ReadDir(resolved)
	if err != nil {
		return err
	}
	for _, entry := range entries {
		displayChild := filepath.Join(displayPath, entry.Name())
		realChild := filepath.Join(resolved, entry.Name())
		mode := entry.Type()
		var info os.FileInfo
		if mode == fs.FileMode(0) {
			var err error
			info, err = entry.Info()
			if err != nil {
				return err
			}
			mode = info.Mode()
		}
		if mode&os.ModeSymlink != 0 {
			targetPath, err := filepath.EvalSymlinks(realChild)
			if err != nil {
				if isVideo(displayChild) {
					*acc = append(*acc, displayChild)
				}
				continue
			}
			targetInfo, err := os.Stat(targetPath)
			if err != nil {
				if isVideo(displayChild) {
					*acc = append(*acc, displayChild)
				}
				continue
			}
			if targetInfo.IsDir() {
				if err := traverseVideoPaths(displayChild, targetPath, visited, acc); err != nil {
					return err
				}
				continue
			}
			if isVideo(displayChild) || isVideo(targetPath) {
				*acc = append(*acc, displayChild)
			}
			continue
		}
		if mode.IsDir() {
			if err := traverseVideoPaths(displayChild, realChild, visited, acc); err != nil {
				return err
			}
			continue
		}
		if isVideo(displayChild) {
			*acc = append(*acc, displayChild)
		}
	}
	return nil
}

func loadVideos(root string, cache *durationCache, progress *loadProgress) ([]video, []string, error) {
	paths, err := collectVideoPaths(root)
	if err != nil {
		return nil, nil, err
	}
	if progress != nil {
		progress.SetTotal(len(paths))
	}

	videos := make([]video, 0, len(paths))
	pending := make([]string, 0)
	for _, path := range paths {
		info, statErr := os.Stat(path)
		if statErr != nil {
			videos = append(videos, video{Name: filepath.Base(path), Path: path, Err: statErr})
			if progress != nil {
				progress.Increment()
			}
			continue
		}
		var dur time.Duration
		if cache != nil {
			if cached, ok := cache.Lookup(path, info); ok {
				dur = cached
			} else {
				pending = append(pending, path)
			}
		} else {
			pending = append(pending, path)
		}
		videos = append(videos, video{
			Name:     filepath.Base(path),
			Path:     path,
			Duration: dur,
			ModTime:  info.ModTime(),
			Size:     info.Size(),
			Err:      nil,
		})
		if progress != nil {
			progress.Increment()
		}
	}

	return videos, pending, nil
}

func playVideoCmd(path, crop string) tea.Cmd {
	return func() tea.Msg {
		args := []string{}
		if crop != "" {
			args = append(args, "--crop", crop)
		}
		args = append(args, path)
		cmd := exec.Command("vlc", args...)
		if err := cmd.Start(); err != nil {
			return playVideoMsg{path: path, err: err}
		}
		go func() {
			_ = cmd.Wait()
		}()
		return playVideoMsg{path: path}
	}
}

func probeDurationsCmd(path string, cache *durationCache) tea.Cmd {
	return func() tea.Msg {
		dur, err := probeDuration(path)
		if err == nil && cache != nil {
			if info, statErr := os.Stat(path); statErr == nil {
				_ = cache.Record(path, info, dur)
			}
		}
		return durationUpdateMsg{path: path, duration: dur, err: err}
	}
}

func probeDuration(path string) (time.Duration, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()

	cmd := exec.CommandContext(ctx, "ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", path)
	out, err := cmd.Output()
	if err != nil {
		return 0, err
	}
	raw := strings.TrimSpace(string(out))
	if raw == "" {
		return 0, errors.New("empty duration")
	}
	f, err := strconv.ParseFloat(raw, 64)
	if err != nil {
		return 0, err
	}
	return time.Duration(f * float64(time.Second)), nil
}

func isVideo(path string) bool {
	ext := strings.ToLower(filepath.Ext(path))
	_, ok := videoExtensions[ext]
	return ok
}

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		return m.handleKeyMsg(msg)
	case progressUpdateMsg:
		if m.loading {
			if msg.total > 0 && !msg.done {
				m.statusMessage = fmt.Sprintf("Loading videos %d/%d...", msg.processed, msg.total)
			} else if msg.done {
				if msg.total == 0 {
					m.statusMessage = "No videos found"
				} else {
					m.statusMessage = fmt.Sprintf("Loaded %d videos", msg.total)
				}
			}
		}
		if msg.done {
			return m, nil
		}
		return m, progressTickerCmd(m.progress)
	case durationUpdateMsg:
		if msg.path != "" {
			m.updateVideoDuration(msg.path, msg.duration, msg.err)
			m.durationDone++
			if msg.err != nil {
				m.statusMessage = fmt.Sprintf("Duration error for %s: %v", filepath.Base(msg.path), msg.err)
			} else if m.durationTotal > 0 {
				m.statusMessage = fmt.Sprintf("Probing durations %d/%d...", m.durationDone, m.durationTotal)
			}
		}
		if m.durationInFlight > 0 {
			m.durationInFlight--
		}
		selectedPath := ""
		if idx := m.table.Cursor(); idx >= 0 && idx < len(m.filtered) {
			selectedPath = m.filtered[idx].Path
		}
		m.applyFiltersAndSort()
		if selectedPath != "" {
			m.restoreSelection(selectedPath)
		}
		if m.durationDone >= m.durationTotal && m.durationInFlight == 0 {
			if m.cache != nil {
				if err := m.cache.Flush(); err != nil {
					m.statusMessage = fmt.Sprintf("Duration cache flush error: %v", err)
				} else {
					m.statusMessage = fmt.Sprintf("Durations ready (%d videos)", len(m.filtered))
				}
			} else {
				m.statusMessage = fmt.Sprintf("Durations ready (%d videos)", len(m.filtered))
			}
			m.pendingDurations = nil
			m.durationTotal = 0
			m.durationDone = 0
			m.durationInFlight = 0
			return m, nil
		}
		if cmd := m.dequeueDurationCmd(); cmd != nil {
			return m, cmd
		}
		return m, nil
	case videosLoadedMsg:
		m.loading = false
		if msg.err != nil {
			m.err = msg.err
			m.statusMessage = fmt.Sprintf("error: %v", msg.err)
		}
		m.videos = msg.videos
		m.cache = msg.cache
		m.pendingDurations = msg.pending
		m.durationTotal = len(msg.pending)
		m.durationDone = 0
		m.applyFiltersAndSort()
		if len(m.filtered) == 0 {
			m.statusMessage = "No videos found"
		} else {
			if len(msg.pending) > 0 {
				if msg.cacheErr != nil {
					m.statusMessage = fmt.Sprintf("Loaded %d videos (cache warning: %v), probing durations...", len(m.filtered), msg.cacheErr)
				} else {
					m.statusMessage = fmt.Sprintf("Loaded %d videos, probing durations...", len(m.filtered))
				}
			} else if msg.cacheErr != nil {
				m.statusMessage = fmt.Sprintf("Loaded %d videos (cache warning: %v)", len(m.filtered), msg.cacheErr)
			} else {
				m.statusMessage = fmt.Sprintf("Loaded %d videos", len(m.filtered))
			}
		}
		m.durationInFlight = 0
		if len(msg.pending) == 0 {
			return m, nil
		}
		cmd := m.startDurationWorkers()
		if cmd == nil {
			return m, nil
		}
		return m, cmd
	case playVideoMsg:
		if msg.err != nil {
			m.statusMessage = fmt.Sprintf("Failed to launch VLC: %v", msg.err)
			return m, nil
		}
		m.statusMessage = fmt.Sprintf("Playing via VLC: %s", trimPath(msg.path))
		return m, nil
	}

	if m.showFilters {
		updated, cmd := m.updateFilterInputs(msg)
		m.inputs = updated
		return m, cmd
	}

	tbl, cmd := m.table.Update(msg)
	m.table = tbl
	return m, cmd
}

func (m model) handleKeyMsg(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
	switch msg.String() {
	case "ctrl+c", "q":
		return m, tea.Quit
	}

	if m.loading {
		return m, nil
	}

	if m.showFilters {
		switch msg.String() {
		case "esc":
			m.showFilters = false
			m.statusMessage = "Filter closed"
			return m, nil
		case "enter":
			if err := m.applyFilterInputs(); err != nil {
				m.statusMessage = err.Error()
			} else {
				m.showFilters = false
				m.applyFiltersAndSort()
				m.statusMessage = fmt.Sprintf("Filters applied (%d videos)", len(m.filtered))
			}
			return m, nil
		case "tab":
			m.inputs.focus = (m.inputs.focus + 1) % len(m.inputs.fields)
		case "shift+tab":
			m.inputs.focus = (m.inputs.focus - 1 + len(m.inputs.fields)) % len(m.inputs.fields)
		default:
			// no-op; handled below
		}
		for i := range m.inputs.fields {
			if i == m.inputs.focus {
				m.inputs.fields[i].Focus()
			} else {
				m.inputs.fields[i].Blur()
			}
		}
		updated, cmd := m.updateFilterInputs(msg)
		m.inputs = updated
		return m, cmd
	}

	switch msg.String() {
	case "f":
		m.showFilters = true
		m.statusMessage = "Editing filters"
		return m, nil
	case "enter":
		if len(m.filtered) == 0 {
			return m, nil
		}
		idx := m.table.Cursor()
		if idx < 0 || idx >= len(m.filtered) {
			return m, nil
		}
		vid := m.filtered[idx]
		m.statusMessage = fmt.Sprintf("Launching VLC: %s", vid.Name)
		return m, playVideoCmd(vid.Path, m.activeCrop())
	case "n":
		m.toggleSort(sortByName)
	case "l":
		m.toggleSort(sortByDuration)
	case "a":
		m.toggleSort(sortByAge)
	case "c":
		if m.cropValue == "" {
			m.statusMessage = "No crop value set (start with --crop)"
			return m, nil
		}
		m.cropEnabled = !m.cropEnabled
		if m.cropEnabled {
			m.statusMessage = fmt.Sprintf("Crop enabled (%s)", m.cropValue)
		} else {
			m.statusMessage = "Crop disabled"
		}
		return m, nil
	case "r":
		m.resetFilters()
		m.applyFiltersAndSort()
		m.statusMessage = fmt.Sprintf("Filters cleared (%d videos)", len(m.filtered))
	default:
		tbl, cmd := m.table.Update(msg)
		m.table = tbl
		return m, cmd
	}

	m.applyFiltersAndSort()
	m.statusMessage = fmt.Sprintf("Sorted %d videos", len(m.filtered))
	return m, nil
}

func (m model) updateFilterInputs(msg tea.Msg) (filterInputs, tea.Cmd) {
	inputs := m.inputs
	var cmds []tea.Cmd
	for i := range inputs.fields {
		var cmd tea.Cmd
		inputs.fields[i], cmd = inputs.fields[i].Update(msg)
		cmds = append(cmds, cmd)
	}
	return inputs, tea.Batch(cmds...)
}

func (m *model) applyFilterInputs() error {
	name := strings.TrimSpace(m.inputs.fields[0].Value())
	minText := strings.TrimSpace(m.inputs.fields[1].Value())
	maxText := strings.TrimSpace(m.inputs.fields[2].Value())

	filters := filterState{name: name}

	if minText != "" {
		minVal, err := strconv.Atoi(minText)
		if err != nil {
			return fmt.Errorf("invalid min minutes: %q", minText)
		}
		if minVal < 0 {
			return fmt.Errorf("min minutes must be positive")
		}
		filters.minEnabled = true
		filters.minMinutes = minVal
	}

	if maxText != "" {
		maxVal, err := strconv.Atoi(maxText)
		if err != nil {
			return fmt.Errorf("invalid max minutes: %q", maxText)
		}
		if maxVal < 0 {
			return fmt.Errorf("max minutes must be positive")
		}
		filters.maxEnabled = true
		filters.maxMinutes = maxVal
	}

	if filters.minEnabled && filters.maxEnabled && filters.minMinutes > filters.maxMinutes {
		return errors.New("min minutes cannot exceed max minutes")
	}

	m.filters = filters
	return nil
}

func (m *model) resetFilters() {
	m.filters = filterState{}
	for i := range m.inputs.fields {
		m.inputs.fields[i].SetValue("")
	}
}

func (m *model) updateVideoDuration(path string, dur time.Duration, err error) {
	for i := range m.videos {
		if m.videos[i].Path == path {
			m.videos[i].Duration = dur
			if err != nil {
				m.videos[i].Err = err
			} else {
				m.videos[i].Err = nil
			}
			break
		}
	}
}

func (m *model) restoreSelection(path string) {
	for i, v := range m.filtered {
		if v.Path == path {
			m.table.SetCursor(i)
			return
		}
	}
}

func (m model) activeCrop() string {
	if m.cropEnabled && m.cropValue != "" {
		return m.cropValue
	}
	return ""
}

func (m *model) dequeueDurationCmd() tea.Cmd {
	if len(m.pendingDurations) == 0 {
		return nil
	}
	path := m.pendingDurations[0]
	m.pendingDurations = m.pendingDurations[1:]
	m.durationInFlight++
	return probeDurationsCmd(path, m.cache)
}

func (m *model) startDurationWorkers() tea.Cmd {
	if len(m.pendingDurations) == 0 {
		return nil
	}
	workers := runtime.NumCPU()
	if workers < 1 {
		workers = 1
	}
	if workers > 6 {
		workers = 6
	}
	if workers > len(m.pendingDurations) {
		workers = len(m.pendingDurations)
	}
	cmds := make([]tea.Cmd, 0, workers)
	for i := 0; i < workers; i++ {
		if cmd := m.dequeueDurationCmd(); cmd != nil {
			cmds = append(cmds, cmd)
		}
	}
	if len(cmds) == 0 {
		return nil
	}
	return tea.Batch(cmds...)
}

func (m *model) toggleSort(target sortField) {
	if m.sortField == target {
		m.sortAscending = !m.sortAscending
	} else {
		m.sortField = target
		m.sortAscending = true
	}
}

func (m *model) applyFiltersAndSort() {
	filtered := make([]video, 0, len(m.videos))
	for _, v := range m.videos {
		if !m.passesFilters(v) {
			continue
		}
		filtered = append(filtered, v)
	}

	sort.Slice(filtered, func(i, j int) bool {
		a, b := filtered[i], filtered[j]
		less := false
		switch m.sortField {
		case sortByName:
			less = strings.ToLower(a.Name) < strings.ToLower(b.Name)
		case sortByDuration:
			less = a.Duration < b.Duration
		case sortByAge:
			less = a.ModTime.Before(b.ModTime)
		}
		if m.sortAscending {
			return less
		}
		return !less
	})

	m.filtered = filtered
	rows := make([]table.Row, 0, len(filtered))
	for _, v := range filtered {
		rows = append(rows, videoRow(v))
	}
	m.table.SetRows(rows)
	if len(rows) > 0 {
		m.table.SetCursor(0)
	}
}

func (m model) passesFilters(v video) bool {
	f := m.filters
	if f.name != "" && !strings.Contains(strings.ToLower(v.Name), strings.ToLower(f.name)) {
		return false
	}
	durMinutes := int(v.Duration.Round(time.Minute) / time.Minute)
	if f.minEnabled && (v.Duration == 0 || durMinutes < f.minMinutes) {
		return false
	}
	if f.maxEnabled && (v.Duration == 0 || durMinutes > f.maxMinutes) {
		return false
	}
	return true
}

func videoRow(v video) table.Row {
	duration := "(unknown)"
	if v.Duration > 0 {
		duration = formatDuration(v.Duration)
	}
	age := humanizeAge(v.ModTime)
	path := trimPath(v.Path)
	if v.Err != nil {
		duration = "!" + v.Err.Error()
	}
	return table.Row{v.Name, duration, age, path}
}

func renderProgressBar(done, total, width int) string {
	if width <= 0 || total <= 0 {
		return ""
	}
	if done < 0 {
		done = 0
	}
	if done > total {
		done = total
	}
	filled := int(float64(done) / float64(total) * float64(width))
	if filled > width {
		filled = width
	}
	bar := strings.Repeat("#", filled) + strings.Repeat("-", width-filled)
	return fmt.Sprintf("[%s]", bar)
}

func formatDuration(d time.Duration) string {
	if d <= 0 {
		return "--"
	}
	totalSeconds := int(d.Seconds() + 0.5)
	hours := totalSeconds / 3600
	minutes := (totalSeconds % 3600) / 60
	seconds := totalSeconds % 60
	if hours > 0 {
		return fmt.Sprintf("%d:%02d:%02d", hours, minutes, seconds)
	}
	return fmt.Sprintf("%02d:%02d", minutes, seconds)
}

func humanizeAge(t time.Time) string {
	if t.IsZero() {
		return "--"
	}
	now := time.Now()
	dur := now.Sub(t)
	if dur < time.Minute {
		return "just now"
	}
	if dur < time.Hour {
		return fmt.Sprintf("%dm ago", int(dur.Minutes()))
	}
	if dur < 24*time.Hour {
		return fmt.Sprintf("%dh ago", int(dur.Hours()))
	}
	return t.Format("2006-01-02")
}

func trimPath(path string) string {
	home, err := os.UserHomeDir()
	if err == nil {
		if strings.HasPrefix(path, home) {
			return "~" + strings.TrimPrefix(path, home)
		}
	}
	return path
}

func (m model) View() string {
	if m.loading {
		return statusStyle.Render("Loading videos, please wait...")
	}

	if m.err != nil && len(m.filtered) == 0 {
		return statusStyle.Render(fmt.Sprintf("Failed to load videos: %v", m.err))
	}

	cropHelp := "Crop: (no crop configured; start with --crop)"
	if m.cropValue != "" {
		state := "off"
		if m.cropEnabled {
			state = "on"
		}
		cropHelp = fmt.Sprintf("Crop: c=toggle (%s %s)", state, m.cropValue)
	}
	helpLines := []string{
		"Controls: ↑/↓ move • Enter selects (noop) • q quits",
		"Sorting: n=name • l=length • a=age • r=reset filters",
		"Filters: f=toggle filter editor (tab to navigate, enter to apply, esc to cancel)",
		cropHelp,
	}
	info := statusStyle.Render(m.statusMessage)

	progressLine := ""
	if m.durationTotal > 0 {
		bar := renderProgressBar(m.durationDone, m.durationTotal, 24)
		progressLine = statusStyle.Render(fmt.Sprintf("Duration scan %s %d/%d", bar, m.durationDone, m.durationTotal))
	}

	content := tableStyle.Render(m.table.View())
	help := strings.Join(helpLines, "\n")

	var parts []string
	parts = append(parts, content)
	if progressLine != "" {
		parts = append(parts, progressLine)
	}
	parts = append(parts, info, help)
	body := strings.Join(parts, "\n")

	if m.showFilters {
		return body + "\n\n" + m.renderFilterModal()
	}

	return body
}

func (m model) renderFilterModal() string {
	var b strings.Builder
	b.WriteString("Filter videos\n")
	b.WriteString("(Enter to apply, Esc to cancel)\n\n")
	labels := []string{"Name contains:", "Min length (minutes):", "Max length (minutes):"}
	for i, field := range m.inputs.fields {
		line := fmt.Sprintf("%s %s", labels[i], field.View())
		if i == m.inputs.focus {
			line = highlightStyle.Render(line)
		}
		b.WriteString(line)
		b.WriteString("\n")
	}
	if m.filters.minEnabled || m.filters.maxEnabled || m.filters.name != "" {
		b.WriteString("\nCurrent filter: ")
		b.WriteString(m.describeFilters())
		b.WriteString("\n")
	}
	return filterStyle.Render(b.String())
}

func (m model) describeFilters() string {
	parts := []string{}
	if m.filters.name != "" {
		parts = append(parts, fmt.Sprintf("name contains %q", m.filters.name))
	}
	if m.filters.minEnabled {
		parts = append(parts, fmt.Sprintf(">=%d min", m.filters.minMinutes))
	}
	if m.filters.maxEnabled {
		parts = append(parts, fmt.Sprintf("<=%d min", m.filters.maxMinutes))
	}
	if len(parts) == 0 {
		return "(none)"
	}
	return strings.Join(parts, ", ")
}