package notes

import (

"os"

"path/filepath"

"strings"

"github.com/pkg/errors"

)

// CategoryCollectMode customizes the behavior of how to collect categories

type CategoryCollectMode uint

const (

// OnlyFirstCategory is a flag to stop collecting categories earlier. If this flag is included

// in mode parameter of CollectCategories(), it collects only first category and only first

// note and stops finding anymore.

OnlyFirstCategory CategoryCollectMode = 1 << iota

)

// Category represents a category directory which contains some notes

type Category struct {

// Path is a path to the category directory

Path string

// Name is a name of category

Name string

// NotePaths are paths to notes of the category

NotePaths []string

}

// Notes returns all Note instances which belong to the category

func (cat *Category) Notes(c *Config) ([]*Note, error) {

notes := make([]*Note, 0, len(cat.NotePaths))

for _, p := range cat.NotePaths {

n, err := LoadNote(p, c)

if err != nil {

return nil, err

}

notes = append(notes, n)

}

return notes, nil

}

// Categories is a map from category name to Category instance

type Categories map[string]*Category

// Names returns all category names as slice

func (cats Categories) Names() []string {

ss := make([]string, 0, len(cats))

for n := range cats {

ss = append(ss, n)

}

return ss

}

// Notes returns all Note instances which belong to the categories

func (cats Categories) Notes(cfg *Config) ([]*Note, error) {

numNotes := 0

for _, c := range cats {

numNotes += len(c.NotePaths)

}

notes := make([]*Note, 0, numNotes)

for _, c := range cats {

for _, p := range c.NotePaths {

n, err := LoadNote(p, cfg)

if err != nil {

return nil, err

}

notes = append(notes, n)

}

}

return notes, nil

}

// CollectCategories collects all categories under home by default. The behavior of collecting categories

// can be customized with mode parameter. Default mode value is 0 (nothing specified).

func CollectCategories(cfg *Config, mode CategoryCollectMode) (Categories, error) {

cats := Categories(map[string]*Category{})

fs, err := os.ReadDir(cfg.HomePath)

if err != nil {

return nil, errors.Wrap(err, "Cannot read home")

}

stopWalking := false

for _, f := range fs {

name := f.Name()

if !f.IsDir() || strings.HasPrefix(name, ".") {

continue

}

root := filepath.Join(cfg.HomePath, name)

if err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {

if stopWalking {

return filepath.SkipDir

}

if err != nil {

return err

}

path = normPathNFD(path)

name := info.Name()

if info.IsDir() {

if strings.HasPrefix(name, ".") {

return filepath.SkipDir

}

rel := strings.TrimPrefix(path, cfg.HomePath)

n := strings.TrimPrefix(filepath.ToSlash(rel), "/")

cats[n] = &Category{Name: n, Path: path}

return nil

}

if strings.HasPrefix(name, ".") || !strings.HasSuffix(name, ".md") {

return nil

}

rel := strings.TrimPrefix(filepath.Dir(path), cfg.HomePath)

cat := cats[strings.TrimPrefix(filepath.ToSlash(rel), "/")]

cat.NotePaths = append(cat.NotePaths, path)

if mode&OnlyFirstCategory != 0 {

stopWalking = true

return filepath.SkipDir

}

return nil

}); err != nil {

return nil, errors.Wrapf(err, "Cannot walk on directory for category %q", name)

}

if stopWalking {

break

}

}

// Remove category which has no note

for n, c := range cats {

if len(c.NotePaths) == 0 {

delete(cats, n)

}

}

return cats, nil

}