package internal

import (
	"io"
	"testing"

	"github.com/schollz/progressbar/v3"

	"github.com/ivuorinen/gh-action-readme/testutil"
)

func TestProgressBarManagerCreateProgressBar(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name        string
		quiet       bool
		description string
		total       int
		expectNil   bool
	}{
		{
			name:        "normal progress bar",
			quiet:       false,
			description: testutil.TestProgressDescription,
			total:       10,
			expectNil:   false,
		},
		{
			name:        "quiet mode returns nil",
			quiet:       true,
			description: testutil.TestProgressDescription,
			total:       10,
			expectNil:   true,
		},
		{
			name:        "single item returns nil",
			quiet:       false,
			description: testutil.TestProgressDescription,
			total:       1,
			expectNil:   true,
		},
		{
			name:        "zero items returns nil",
			quiet:       false,
			description: testutil.TestProgressDescription,
			total:       0,
			expectNil:   true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			pm := NewProgressBarManager(tt.quiet)
			bar := pm.CreateProgressBar(tt.description, tt.total)

			if tt.expectNil {
				if bar != nil {
					t.Errorf("expected nil progress bar, got %v", bar)
				}
			} else {
				if bar == nil {
					t.Error("expected progress bar, got nil")
				}
			}
		})
	}
}

func TestProgressBarManagerCreateProgressBarForFiles(t *testing.T) {
	t.Parallel()
	pm := NewProgressBarManager(false)
	files := []string{"file1.yml", "file2.yml", "file3.yml"}

	bar := pm.CreateProgressBarForFiles("Processing files", files)

	if bar == nil {
		t.Error("expected progress bar for multiple files, got nil")
	}
}

func TestProgressBarManagerNilSafeOperations(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name      string
		operation func(*ProgressBarManager, *progressbar.ProgressBar)
	}{
		{
			name: "FinishProgressBar handles nil",
			operation: func(pm *ProgressBarManager, bar *progressbar.ProgressBar) {
				pm.FinishProgressBar(bar)
			},
		},
		{
			name: "UpdateProgressBar handles nil",
			operation: func(pm *ProgressBarManager, bar *progressbar.ProgressBar) {
				pm.UpdateProgressBar(bar)
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			// Use quiet mode to avoid cluttering test output
			pm := NewProgressBarManager(true)

			// Should not panic with nil
			tt.operation(pm, nil)

			// Should not panic with actual bar (will be nil in quiet mode)
			bar := pm.CreateProgressBar("Test", 5)
			tt.operation(pm, bar)
		})
	}
}

func TestProgressBarManagerProcessWithProgressBar(t *testing.T) {
	t.Parallel()
	// Use NullProgressManager to avoid cluttering test output
	pm := NewNullProgressManager()
	items := []string{"item1", "item2", "item3"}

	processedItems := make([]string, 0)
	processFunc := func(item string, _ *progressbar.ProgressBar) {
		processedItems = append(processedItems, item)
	}

	pm.ProcessWithProgressBar("Processing items", items, processFunc)

	if len(processedItems) != len(items) {
		t.Errorf("expected %d processed items, got %d", len(items), len(processedItems))
	}

	for i, item := range items {
		if processedItems[i] != item {
			t.Errorf("expected item %s at position %d, got %s", item, i, processedItems[i])
		}
	}
}

func TestProgressBarManagerProcessWithProgressBarQuietMode(t *testing.T) {
	t.Parallel()
	pm := NewProgressBarManager(true) // quiet mode
	items := []string{"item1", "item2"}

	processedItems := make([]string, 0)
	processFunc := func(item string, bar *progressbar.ProgressBar) {
		processedItems = append(processedItems, item)
		// In quiet mode, bar should be nil
		if bar != nil {
			t.Error("expected nil progress bar in quiet mode")
		}
	}

	pm.ProcessWithProgressBar("Processing items", items, processFunc)

	if len(processedItems) != len(items) {
		t.Errorf("expected %d processed items, got %d", len(items), len(processedItems))
	}
}

// TestProgressBarManagerFinishProgressBarWithNewline tests finishing with newline.
func TestProgressBarManagerFinishProgressBarWithNewline(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name string
		bar  *progressbar.ProgressBar
	}{
		{
			name: "with valid progress bar",
			bar:  progressbar.NewOptions(10, progressbar.OptionSetWriter(io.Discard)),
		},
		{
			name: "with nil progress bar",
			bar:  nil,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			pm := NewProgressBarManager(false)
			// Should not panic
			pm.FinishProgressBarWithNewline(tt.bar)
		})
	}
}