package tui

import (
	"path/filepath"
	"slices"

	"github.com/dundee/gdu/v5/pkg/device"
	"github.com/dundee/gdu/v5/pkg/fs"
	"github.com/rivo/tview"
)

var (
	barFullRune  = "\u2588"
	barPartRunes = map[int]string{
		0: " ",
		1: "\u258F",
		2: "\u258E",
		3: "\u258D",
		4: "\u258C",
		5: "\u258B",
		6: "\u258A",
		7: "\u2589",
	}
)

func getDeviceUsagePart(item *device.Device, useOld bool) string {
	part := int(float64(item.Size-item.Free) / float64(item.Size) * 100.0)
	if useOld {
		return getUsageGraphOld(part)
	}
	return getUsageGraph(part)
}

func getUsageGraph(part int) string {
	graph := " "
	whole := part / 10
	for i := 0; i < whole; i++ {
		graph += barFullRune
	}
	partWidth := (part % 10) * 8 / 10
	if part < 100 {
		graph += barPartRunes[partWidth]
	}

	for i := 0; i < 10-whole-1; i++ {
		graph += " "
	}

	graph += "\u258F"
	return graph
}

func getUsageGraphOld(part int) string {
	part /= 10
	graph := "["
	for i := 0; i < 10; i++ {
		if part > i {
			graph += "#"
		} else {
			graph += " "
		}
	}
	graph += "]"
	return graph
}

func modal(p tview.Primitive, width, height int) tview.Primitive {
	return tview.NewFlex().
		AddItem(nil, 0, 1, false).
		AddItem(tview.NewFlex().SetDirection(tview.FlexRow).
			AddItem(nil, 0, 1, false).
			AddItem(p, height, 1, true).
			AddItem(nil, 0, 1, false), width, 1, true).
		AddItem(nil, 0, 1, false)
}

// CollapsedPath represents a directory chain that can be collapsed into a single display entry.
// For example, if directory "a" contains only directory "b", and "b" contains only "c",
// this represents the collapsed path "a/b/c" that allows direct navigation to the deepest directory.
type CollapsedPath struct {
	DisplayName string   // The display name shown in the UI (e.g., "a/b/c")
	DeepestDir  fs.Item  // The actual deepest directory item
	Segments    []string // Individual path segments of the collapsed chain
}

// findCollapsiblePath checks if the given directory item has a single subdirectory chain
// and returns a CollapsedPath if it can be collapsed
func findCollapsiblePath(item fs.Item) *CollapsedPath {
	if item == nil || !item.IsDir() {
		return nil
	}

	var segments []string
	current := item

	for {
		// Collect files to check count and types
		var files []fs.Item
		for file := range current.GetFiles(fs.SortByName, fs.SortAsc) {
			files = append(files, file)
		}

		if len(files) > 1 {
			break
		}

		// Count directories and files separately
		var subdirs []fs.Item
		var fileCount int
		for _, file := range files {
			if file.IsDir() {
				subdirs = append(subdirs, file)
			} else {
				fileCount++
			}
		}

		// Only collapse if there's exactly one subdirectory AND no files
		if len(subdirs) != 1 || fileCount > 0 {
			break
		}

		// Add this segment to the path
		// nolint:staticcheck // the result is used
		segments = append(segments, subdirs[0].GetName())
		current = subdirs[0]
	}

	// Only create collapsed path if we have at least one collapsible segment
	if len(segments) == 0 {
		return nil
	}

	return &CollapsedPath{
		DisplayName: filepath.Join(slices.Concat([]string{item.GetName()}, segments)...),
		DeepestDir:  current,
		Segments:    segments,
	}
}

// findCollapsedParent checks if the current directory is the deepest directory
// in a collapsed path, and returns the appropriate parent to navigate to
func findCollapsedParent(currentDir fs.Item) fs.Item {
	if currentDir == nil {
		return nil
	}
	if currentDir.GetParent() == nil {
		return nil
	}

	// Check if current directory is part of a single-child chain going up
	current := currentDir
	var chainParent fs.Item

	// Walk up the parent chain
	for current.GetParent() != nil {
		parent := current.GetParent()

		// Count files in parent
		fileCount := 0
		for range parent.GetFiles(fs.SortByName, fs.SortAsc) {
			fileCount++
			if fileCount > 1 {
				break
			}
		}

		// If parent has more than one item, this is where the collapsed chain starts
		if fileCount > 1 {
			chainParent = parent
			break
		}

		// Move up the chain
		current = parent
	}

	// If we found a chain parent (meaning current dir is part of a collapsed path),
	// return it, otherwise return the normal parent
	if chainParent != nil {
		return chainParent
	}

	return currentDir.GetParent()
}