package main

import (
	"fmt"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/davidroman0O/vtable"
)

// 1. Define your data and implement DataProvider[vtable.TableRow]
type MyProvider struct {
	data []Person
	selection map[int]bool
}

func (p *MyProvider) GetTotal() int { return len(p.data) }
func (p *MyProvider) GetSelectionMode() vtable.SelectionMode { return vtable.SelectionNone }
// ... implement other required DataProvider methods

func (p *MyProvider) GetItems(request vtable.DataRequest) ([]vtable.Data[vtable.TableRow], error) {
	// Return data as TableRow format
	result := make([]vtable.Data[vtable.TableRow], len(p.data))
	for i, person := range p.data {
		result[i] = vtable.Data[vtable.TableRow]{
			ID: fmt.Sprintf("person-%d", i),
			Item: vtable.TableRow{
				Cells: []string{person.Name, fmt.Sprintf("%d", person.Age)},
			},
			Metadata: vtable.NewTypedMetadata(),
		}
	}
	return result, nil
}

func main() {
	// 2. Configure table columns
	config := vtable.TableConfig{
		Columns: []vtable.TableColumn{
			{Title: "Name", Width: 20, Alignment: vtable.AlignLeft, Field: "name"},
			{Title: "Age", Width: 5, Alignment: vtable.AlignRight, Field: "age"},
		},
		ShowHeader:  true,
		ShowBorders: true,
		ViewportConfig: vtable.ViewportConfig{
			Height:               10,
			TopThresholdIndex:    2,
			BottomThresholdIndex: 7,
			ChunkSize:            50,
		},
	}

	// 3. Create table with theme
	provider := &MyProvider{data: loadPeople()}
	table, _ := vtable.NewTeaTable(config, provider, *vtable.DefaultTheme())
	
	// 4. Run
	p := tea.NewProgram(table)
	p.Run()
}

// 1. Implement DataProvider[YourType]
type StringProvider struct {
	items []string
	selection map[int]bool
}

func (p *StringProvider) GetItems(request vtable.DataRequest) ([]vtable.Data[string], error) {
	result := make([]vtable.Data[string], len(p.items))
	for i, item := range p.items {
		result[i] = vtable.Data[string]{
			ID: fmt.Sprintf("item-%d", i),
			Item: item,
			Metadata: vtable.NewTypedMetadata(),
		}
	}
	return result, nil
}
// ... implement other DataProvider methods

// 2. Create formatter
formatter := func(data vtable.Data[string], index int, ctx vtable.RenderContext, 
	isCursor bool, isTopThreshold bool, isBottomThreshold bool) string {
	prefix := "  "
	if isCursor {
		prefix = "> "
	}
	return fmt.Sprintf("%s%s", prefix, data.Item)
}

// 3. Create list
config := vtable.DefaultViewportConfig()
provider := &StringProvider{items: []string{"Item 1", "Item 2", "Item 3"}}
list, _ := vtable.NewTeaList(config, provider, vtable.DefaultStyleConfig(), formatter)

p := tea.NewProgram(list)
p.Run()

// Enable in your DataProvider
func (p *MyProvider) GetSelectionMode() vtable.SelectionMode {
	return vtable.SelectionMultiple // or SelectionSingle, SelectionNone
}

// Handle in Update()
switch msg.String() {
case " ":
	table.ToggleCurrentSelection()
case "ctrl+a":
	table.SelectAll()
case "escape":
	table.ClearSelection()
}

// Check selection
selectedIndices := table.GetSelectedIndices()
selectionCount := table.GetSelectionCount()

// Selection events
table.OnSelect(func(row vtable.TableRow, index int) {
	fmt.Printf("Selected row %d\n", index)
})

// Navigation events  
table.OnHighlight(func(row vtable.TableRow, index int) {
	// Update preview panel
})

// Scroll events
table.OnScroll(func(state vtable.ViewportState) {
	// Update scroll indicators
})

// Data change events
table.OnFiltersChanged(func(filters map[string]any) {
	// Update filter UI
})

table.OnSortChanged(func(field, direction string) {
	// Update sort indicators
})

// Available themes
table.SetTheme(*vtable.DefaultTheme())      // Light theme
table.SetTheme(*vtable.DarkTheme())         // Dark theme  
table.SetTheme(*vtable.HighContrastTheme()) // High contrast for accessibility

// Available border styles
theme.BorderChars = vtable.DefaultBorderCharacters()  // ┌─┐│└─┘
theme.BorderChars = vtable.RoundedBorderCharacters()  // ╭─╮│╰─╯
theme.BorderChars = vtable.ThickBorderCharacters()    // ┏━┓┃┗━┛
theme.BorderChars = vtable.DoubleBorderCharacters()   // ╔═╗║╚═╝
theme.BorderChars = vtable.AsciiBoxCharacters()       // +-+|+-+

// Create animated formatter
animatedFormatter := func(data vtable.Data[Task], index int, ctx vtable.RenderContext,
	animationState map[string]any, isCursor bool, isTopThreshold bool, isBottomThreshold bool) vtable.RenderResult {
	
	// Use delta time for smooth animations
	deltaMs := ctx.DeltaTime.Milliseconds()
	
	// Animated content
	counter, _ := animationState["counter"].(int)
	spinnerFrames := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
	spinner := spinnerFrames[counter%len(spinnerFrames)]
	
	return vtable.RenderResult{
		Content: fmt.Sprintf("%s %s", spinner, data.Item.Title),
		RefreshTriggers: []vtable.RefreshTrigger{{
			Type: vtable.TriggerTimer,
			Interval: 100 * time.Millisecond,
		}},
		AnimationState: map[string]any{
			"counter": counter + 1,
		},
	}
}

// Enable animations
list.SetAnimatedFormatter(animatedFormatter)
list.SetTickInterval(100 * time.Millisecond) // 10fps

// Toggle animations during runtime
func (m MyModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        switch msg.String() {
        case "a":
            // Toggle animations
            if table.IsAnimationEnabled() {
                table.DisableAnimations()
            } else {
                if cmd := table.EnableAnimations(); cmd != nil {
                    return m, cmd
                }
            }
        }
    }
    return m, nil
}

// Check animation status
isEnabled := table.IsAnimationEnabled()
isRunning := table.IsAnimationLoopRunning()

// Disable animations for large datasets
if dataSize > 10000 {
    table.DisableAnimations()
}

// Enable animations for real-time data
if isRealTimeData {
    if cmd := table.EnableAnimations(); cmd != nil {
        cmds = append(cmds, cmd)
    }
}

// Battery-saving mode
if lowPowerMode {
    table.DisableAnimations()
} else {
    table.SetTickInterval(50 * time.Millisecond) // Reduce frequency
}

// Control all animations globally
vtable.StopGlobalAnimationLoop()
running := vtable.IsGlobalAnimationLoopRunning()

// Update global animation settings
config := vtable.DefaultAnimationConfig()
config.Enabled = false
if cmd := vtable.SetGlobalAnimationConfig(config); cmd != nil {
    return m, cmd
}

// Single sort (replaces existing)
table.SetSort("lastName", "asc")

// Multi-sort (adds to existing)
table.AddSort("age", "desc") 

// Manage sorts
table.RemoveSort("age")
table.ClearSort()

// Check current sort
request := table.GetDataRequest()
fields := request.SortFields      // []string
directions := request.SortDirections // []string

// Apply filters
table.SetFilter("status", "active")
table.SetFilter("minAge", 18)

// Remove filters
table.RemoveFilter("status")
table.ClearFilters()

// Check current filters
request := table.GetDataRequest()
filters := request.Filters // map[string]any

type DataProvider[T any] interface {
	GetTotal() int
	GetItems(request DataRequest) ([]Data[T], error)
	GetSelectionMode() SelectionMode
	SetSelected(index int, selected bool) bool
	SetSelectedByIDs(ids []string, selected bool) bool
	SelectRange(startID, endID string) bool
	SelectAll() bool
	ClearSelection()
	GetSelectedIndices() []int
	GetSelectedIDs() []string
	GetItemID(item *T) string
}

// Optional: For search functionality
type SearchableDataProvider[T any] interface {
	DataProvider[T]
	FindItemIndex(key string, value any) (int, bool)
}

type PersonProvider struct {
	rawData      []Person
	filteredData []Person
	filters      map[string]any
	sortFields   []string
	sortDirs     []string
	selection    map[int]bool
	dirty        bool
}

func (p *PersonProvider) GetItems(request vtable.DataRequest) ([]vtable.Data[vtable.TableRow], error) {
	// Update internal state from request
	if !reflect.DeepEqual(p.filters, request.Filters) {
		p.filters = request.Filters
		p.dirty = true
	}
	
	// Rebuild filtered data if needed
	if p.dirty {
		p.rebuildFilteredData()
		p.dirty = false
	}
	
	// Return requested chunk
	start := request.Start
	count := min(request.Count, len(p.filteredData)-start)
	
	result := make([]vtable.Data[vtable.TableRow], count)
	for i := 0; i < count; i++ {
		person := p.filteredData[start+i]
		result[i] = vtable.Data[vtable.TableRow]{
			ID: fmt.Sprintf("person-%d", person.ID),
			Item: vtable.TableRow{
				Cells: []string{person.Name, fmt.Sprintf("%d", person.Age)},
			},
			Selected: p.selection[person.ID],
		}
	}
	return result, nil
}

// Automatic platform detection
keyMap := vtable.PlatformKeyMap() // Auto-detects macOS/Linux/Windows

// Or specify manually
keyMap := vtable.MacOSKeyMap()    // macOS optimized
keyMap := vtable.LinuxKeyMap()    // Linux optimized  
keyMap := vtable.WindowsKeyMap()  // Windows optimized

// Set custom keymap
table.SetKeyMap(keyMap)

config := vtable.ViewportConfig{
	Height:               10,  // Visible rows
	TopThresholdIndex:    2,   // Top scroll trigger (0-based)
	BottomThresholdIndex: 7,   // Bottom scroll trigger
	ChunkSize:            50,  // Items per chunk
	InitialIndex:         0,   // Starting cursor position
}

// Default animation configuration (animations are enabled but not running)
config := vtable.DefaultAnimationConfig()
// config.Enabled = true          // ✅ Animations are enabled by default
// config.TickInterval = 100ms    // 10fps default refresh rate
// config.MaxAnimations = 50      // Limit active animations for performance

// The animation loop only starts when you actually use animations:
// 1. Create table/list (no animation loop running yet)
table, _ := vtable.NewTeaTable(config, provider, theme)

// 2. Set animated formatter (animation loop starts automatically)
table.SetAnimatedFormatter(myAnimatedFormatter)

// 3. Clear animated formatter (animation loop stops automatically)  
table.ClearAnimatedFormatter()