package rpm

import "errors"
import "io/fs"
import "os"
import "path/filepath"
import "sort"
import "strings"

type TreeEntry struct {
	Name      string `json:"name"`
	Path      string `json:"path"`
	Type      string `json:"type"`
	Size      int64  `json:"size"`
	IsRepoDir bool   `json:"is_repo_dir"`
	RepoMode  string `json:"repo_mode"`
}

var ErrPathNotFound = errors.New("path not found")

func ListTree(basePath string, relPath string) ([]TreeEntry, error) {
	var dirPath string
	var entries []fs.DirEntry
	var err error
	var result []TreeEntry
	var entry fs.DirEntry
	var info fs.FileInfo
	var kind string
	var entryPath string
	var i int
	dirPath = filepath.Join(basePath, filepath.FromSlash(relPath))
	entries, err = os.ReadDir(dirPath)
	if err != nil {
		if os.IsNotExist(err) {
			return nil, ErrPathNotFound
		}
		return nil, err
	}
	result = make([]TreeEntry, 0, len(entries))
	for i = 0; i < len(entries); i++ {
		entry = entries[i]
		kind = "file"
		if entry.IsDir() {
			kind = "dir"
		}
		info, err = entry.Info()
		if err != nil {
			continue
		}
		entryPath = entry.Name()
		if relPath != "" {
			entryPath = filepath.ToSlash(filepath.Join(relPath, entry.Name()))
		}
		result = append(result, TreeEntry{
			Name: entry.Name(),
			Path: entryPath,
			Type: kind,
			Size: info.Size(),
		})
	}
	sort.Slice(result, func(i int, j int) bool {
		if result[i].Type != result[j].Type {
			return result[i].Type == "dir"
		}
		return strings.ToLower(result[i].Name) < strings.ToLower(result[j].Name)
	})
	return result, nil
}