// Copyright 2019 The Hugo Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package hugolib

import (
	"context"
	"fmt"
	"path"
	"path/filepath"
	"strings"
	"sync"

	"github.com/gohugoio/hugo/common/maps"

	"github.com/gohugoio/hugo/common/types"
	"github.com/gohugoio/hugo/resources"

	"github.com/gohugoio/hugo/common/hugio"
	"github.com/gohugoio/hugo/hugofs"
	"github.com/gohugoio/hugo/hugofs/files"
	"github.com/gohugoio/hugo/parser/pageparser"
	"github.com/gohugoio/hugo/resources/page"
	"github.com/gohugoio/hugo/resources/resource"
	"github.com/spf13/cast"

	"github.com/gohugoio/hugo/common/para"
	"github.com/pkg/errors"
)

func newPageMaps(h *HugoSites) *pageMaps {
	mps := make([]*pageMap, len(h.Sites))
	for i, s := range h.Sites {
		mps[i] = s.pageMap
	}
	return &pageMaps{
		workers: para.New(h.numWorkers),
		pmaps:   mps,
	}
}

type pageMap struct {
	s *Site
	*contentMap
}

func (m *pageMap) Len() int {
	l := 0
	for _, t := range m.contentMap.pageTrees {
		l += t.Len()
	}
	return l
}

func (m *pageMap) createMissingTaxonomyNodes() error {
	if m.cfg.taxonomyDisabled {
		return nil
	}
	m.taxonomyEntries.Walk(func(s string, v interface{}) bool {
		n := v.(*contentNode)
		vi := n.viewInfo
		k := cleanSectionTreeKey(vi.name.plural + "/" + vi.termKey)

		if _, found := m.taxonomies.Get(k); !found {
			vic := &contentBundleViewInfo{
				name:       vi.name,
				termKey:    vi.termKey,
				termOrigin: vi.termOrigin,
			}
			m.taxonomies.Insert(k, &contentNode{viewInfo: vic})
		}
		return false
	})

	return nil
}

func (m *pageMap) newPageFromContentNode(n *contentNode, parentBucket *pagesMapBucket, owner *pageState) (*pageState, error) {
	if n.fi == nil {
		panic("FileInfo must (currently) be set")
	}

	f, err := newFileInfo(m.s.SourceSpec, n.fi)
	if err != nil {
		return nil, err
	}

	meta := n.fi.Meta()
	content := func() (hugio.ReadSeekCloser, error) {
		return meta.Open()
	}

	bundled := owner != nil
	s := m.s

	sections := s.sectionsFromFile(f)

	kind := s.kindFromFileInfoOrSections(f, sections)
	if kind == page.KindTerm {
		s.PathSpec.MakePathsSanitized(sections)
	}

	metaProvider := &pageMeta{kind: kind, sections: sections, bundled: bundled, s: s, f: f}

	ps, err := newPageBase(metaProvider)
	if err != nil {
		return nil, err
	}

	if n.fi.Meta().GetBool(walkIsRootFileMetaKey) {
		// Make sure that the bundle/section we start walking from is always
		// rendered.
		// This is only relevant in server fast render mode.
		ps.forceRender = true
	}

	n.p = ps
	if ps.IsNode() {
		ps.bucket = newPageBucket(ps)
	}

	gi, err := s.h.gitInfoForPage(ps)
	if err != nil {
		return nil, errors.Wrap(err, "failed to load Git data")
	}
	ps.gitInfo = gi

	r, err := content()
	if err != nil {
		return nil, err
	}
	defer r.Close()

	parseResult, err := pageparser.Parse(
		r,
		pageparser.Config{EnableEmoji: s.siteCfg.enableEmoji},
	)
	if err != nil {
		return nil, err
	}

	ps.pageContent = pageContent{
		source: rawPageContent{
			parsed:         parseResult,
			posMainContent: -1,
			posSummaryEnd:  -1,
			posBodyStart:   -1,
		},
	}

	ps.shortcodeState = newShortcodeHandler(ps, ps.s, nil)

	if err := ps.mapContent(parentBucket, metaProvider); err != nil {
		return nil, ps.wrapError(err)
	}

	if err := metaProvider.applyDefaultValues(n); err != nil {
		return nil, err
	}

	ps.init.Add(func() (interface{}, error) {
		pp, err := newPagePaths(s, ps, metaProvider)
		if err != nil {
			return nil, err
		}

		outputFormatsForPage := ps.m.outputFormats()

		// Prepare output formats for all sites.
		// We do this even if this page does not get rendered on
		// its own. It may be referenced via .Site.GetPage and
		// it will then need an output format.
		ps.pageOutputs = make([]*pageOutput, len(ps.s.h.renderFormats))
		created := make(map[string]*pageOutput)
		shouldRenderPage := !ps.m.noRender()

		for i, f := range ps.s.h.renderFormats {
			if po, found := created[f.Name]; found {
				ps.pageOutputs[i] = po
				continue
			}

			render := shouldRenderPage
			if render {
				_, render = outputFormatsForPage.GetByName(f.Name)
			}

			po := newPageOutput(ps, pp, f, render)

			// Create a content provider for the first,
			// we may be able to reuse it.
			if i == 0 {
				contentProvider, err := newPageContentOutput(ps, po)
				if err != nil {
					return nil, err
				}
				po.initContentProvider(contentProvider)
			}

			ps.pageOutputs[i] = po
			created[f.Name] = po

		}

		if err := ps.initCommonProviders(pp); err != nil {
			return nil, err
		}

		return nil, nil
	})

	ps.parent = owner

	return ps, nil
}

func (m *pageMap) newResource(fim hugofs.FileMetaInfo, owner *pageState) (resource.Resource, error) {
	if owner == nil {
		panic("owner is nil")
	}
	// TODO(bep) consolidate with multihost logic + clean up
	outputFormats := owner.m.outputFormats()
	seen := make(map[string]bool)
	var targetBasePaths []string
	// Make sure bundled resources are published to all of the output formats'
	// sub paths.
	for _, f := range outputFormats {
		p := f.Path
		if seen[p] {
			continue
		}
		seen[p] = true
		targetBasePaths = append(targetBasePaths, p)

	}

	meta := fim.Meta()
	r := func() (hugio.ReadSeekCloser, error) {
		return meta.Open()
	}

	target := strings.TrimPrefix(meta.Path(), owner.File().Dir())

	return owner.s.ResourceSpec.New(
		resources.ResourceSourceDescriptor{
			TargetPaths:        owner.getTargetPaths,
			OpenReadSeekCloser: r,
			FileInfo:           fim,
			RelTargetFilename:  target,
			TargetBasePaths:    targetBasePaths,
			LazyPublish:        !owner.m.buildConfig.PublishResources,
		})
}

func (m *pageMap) createSiteTaxonomies() error {
	m.s.taxonomies = make(TaxonomyList)
	var walkErr error
	m.taxonomies.Walk(func(s string, v interface{}) bool {
		n := v.(*contentNode)
		t := n.viewInfo

		viewName := t.name

		if t.termKey == "" {
			m.s.taxonomies[viewName.plural] = make(Taxonomy)
		} else {
			taxonomy := m.s.taxonomies[viewName.plural]
			if taxonomy == nil {
				walkErr = errors.Errorf("missing taxonomy: %s", viewName.plural)
				return true
			}
			m.taxonomyEntries.WalkPrefix(s, func(ss string, v interface{}) bool {
				b2 := v.(*contentNode)
				info := b2.viewInfo
				taxonomy.add(info.termKey, page.NewWeightedPage(info.weight, info.ref.p, n.p))

				return false
			})
		}

		return false
	})

	for _, taxonomy := range m.s.taxonomies {
		for _, v := range taxonomy {
			v.Sort()
		}
	}

	return walkErr
}

func (m *pageMap) createListAllPages() page.Pages {
	pages := make(page.Pages, 0)

	m.contentMap.pageTrees.Walk(func(s string, n *contentNode) bool {
		if n.p == nil {
			panic(fmt.Sprintf("BUG: page not set for %q", s))
		}
		if contentTreeNoListAlwaysFilter(s, n) {
			return false
		}
		pages = append(pages, n.p)
		return false
	})

	page.SortByDefault(pages)
	return pages
}

func (m *pageMap) assemblePages() error {
	m.taxonomyEntries.DeletePrefix("/")

	if err := m.assembleSections(); err != nil {
		return err
	}

	var err error

	if err != nil {
		return err
	}

	m.pages.Walk(func(s string, v interface{}) bool {
		n := v.(*contentNode)

		var shouldBuild bool

		defer func() {
			// Make sure we always rebuild the view cache.
			if shouldBuild && err == nil && n.p != nil {
				m.attachPageToViews(s, n)
			}
		}()

		if n.p != nil {
			// A rebuild
			shouldBuild = true
			return false
		}

		var parent *contentNode
		var parentBucket *pagesMapBucket

		_, parent = m.getSection(s)
		if parent == nil {
			panic(fmt.Sprintf("BUG: parent not set for %q", s))
		}
		parentBucket = parent.p.bucket

		n.p, err = m.newPageFromContentNode(n, parentBucket, nil)
		if err != nil {
			return true
		}

		shouldBuild = !(n.p.Kind() == page.KindPage && m.cfg.pageDisabled) && m.s.shouldBuild(n.p)
		if !shouldBuild {
			m.deletePage(s)
			return false
		}

		n.p.treeRef = &contentTreeRef{
			m:   m,
			t:   m.pages,
			n:   n,
			key: s,
		}

		if err = m.assembleResources(s, n.p, parentBucket); err != nil {
			return true
		}

		return false
	})

	m.deleteOrphanSections()

	return err
}

func (m *pageMap) assembleResources(s string, p *pageState, parentBucket *pagesMapBucket) error {
	var err error

	m.resources.WalkPrefix(s, func(s string, v interface{}) bool {
		n := v.(*contentNode)
		meta := n.fi.Meta()
		classifier := meta.Classifier()
		var r resource.Resource
		switch classifier {
		case files.ContentClassContent:
			var rp *pageState
			rp, err = m.newPageFromContentNode(n, parentBucket, p)
			if err != nil {
				return true
			}
			rp.m.resourcePath = filepath.ToSlash(strings.TrimPrefix(rp.Path(), p.File().Dir()))
			r = rp

		case files.ContentClassFile:
			r, err = m.newResource(n.fi, p)
			if err != nil {
				return true
			}
		default:
			panic(fmt.Sprintf("invalid classifier: %q", classifier))
		}

		p.resources = append(p.resources, r)
		return false
	})

	return err
}

func (m *pageMap) assembleSections() error {
	var sectionsToDelete []string
	var err error

	m.sections.Walk(func(s string, v interface{}) bool {
		n := v.(*contentNode)
		var shouldBuild bool

		defer func() {
			// Make sure we always rebuild the view cache.
			if shouldBuild && err == nil && n.p != nil {
				m.attachPageToViews(s, n)
				if n.p.IsHome() {
					m.s.home = n.p
				}
			}
		}()

		sections := m.splitKey(s)

		if n.p != nil {
			if n.p.IsHome() {
				m.s.home = n.p
			}
			shouldBuild = true
			return false
		}

		var parent *contentNode
		var parentBucket *pagesMapBucket

		if s != "/" {
			_, parent = m.getSection(s)
			if parent == nil || parent.p == nil {
				panic(fmt.Sprintf("BUG: parent not set for %q", s))
			}
		}

		if parent != nil {
			parentBucket = parent.p.bucket
		}

		kind := page.KindSection
		if s == "/" {
			kind = page.KindHome
		}

		if n.fi != nil {
			n.p, err = m.newPageFromContentNode(n, parentBucket, nil)
			if err != nil {
				return true
			}
		} else {
			n.p = m.s.newPage(n, parentBucket, kind, "", sections...)
		}

		shouldBuild = m.s.shouldBuild(n.p)
		if !shouldBuild {
			sectionsToDelete = append(sectionsToDelete, s)
			return false
		}

		n.p.treeRef = &contentTreeRef{
			m:   m,
			t:   m.sections,
			n:   n,
			key: s,
		}

		if err = m.assembleResources(s+cmLeafSeparator, n.p, parentBucket); err != nil {
			return true
		}

		return false
	})

	for _, s := range sectionsToDelete {
		m.deleteSectionByPath(s)
	}

	return err
}

func (m *pageMap) assembleTaxonomies() error {
	var taxonomiesToDelete []string
	var err error

	m.taxonomies.Walk(func(s string, v interface{}) bool {
		n := v.(*contentNode)

		if n.p != nil {
			return false
		}

		kind := n.viewInfo.kind()
		sections := n.viewInfo.sections()

		_, parent := m.getTaxonomyParent(s)
		if parent == nil || parent.p == nil {
			panic(fmt.Sprintf("BUG: parent not set for %q", s))
		}
		parentBucket := parent.p.bucket

		if n.fi != nil {
			n.p, err = m.newPageFromContentNode(n, parent.p.bucket, nil)
			if err != nil {
				return true
			}
		} else {
			title := ""
			if kind == page.KindTerm {
				title = n.viewInfo.term()
			}
			n.p = m.s.newPage(n, parent.p.bucket, kind, title, sections...)
		}

		if !m.s.shouldBuild(n.p) {
			taxonomiesToDelete = append(taxonomiesToDelete, s)
			return false
		}

		n.p.treeRef = &contentTreeRef{
			m:   m,
			t:   m.taxonomies,
			n:   n,
			key: s,
		}

		if err = m.assembleResources(s+cmLeafSeparator, n.p, parentBucket); err != nil {
			return true
		}

		return false
	})

	for _, s := range taxonomiesToDelete {
		m.deleteTaxonomy(s)
	}

	return err
}

func (m *pageMap) attachPageToViews(s string, b *contentNode) {
	if m.cfg.taxonomyDisabled {
		return
	}

	for _, viewName := range m.cfg.taxonomyConfig {
		vals := types.ToStringSlicePreserveString(getParam(b.p, viewName.plural, false))
		if vals == nil {
			continue
		}
		w := getParamToLower(b.p, viewName.plural+"_weight")
		weight, err := cast.ToIntE(w)
		if err != nil {
			m.s.Log.Errorf("Unable to convert taxonomy weight %#v to int for %q", w, b.p.Path())
			// weight will equal zero, so let the flow continue
		}

		for i, v := range vals {
			termKey := m.s.getTaxonomyKey(v)

			bv := &contentNode{
				viewInfo: &contentBundleViewInfo{
					ordinal:    i,
					name:       viewName,
					termKey:    termKey,
					termOrigin: v,
					weight:     weight,
					ref:        b,
				},
			}

			var key string
			if strings.HasSuffix(s, "/") {
				key = cleanSectionTreeKey(path.Join(viewName.plural, termKey, s))
			} else {
				key = cleanTreeKey(path.Join(viewName.plural, termKey, s))
			}
			m.taxonomyEntries.Insert(key, bv)
		}
	}
}

type pageMapQuery struct {
	Prefix string
	Filter contentTreeNodeCallback
}

func (m *pageMap) collectPages(query pageMapQuery, fn func(c *contentNode)) error {
	if query.Filter == nil {
		query.Filter = contentTreeNoListAlwaysFilter
	}

	m.pages.WalkQuery(query, func(s string, n *contentNode) bool {
		fn(n)
		return false
	})

	return nil
}

func (m *pageMap) collectPagesAndSections(query pageMapQuery, fn func(c *contentNode)) error {
	if err := m.collectSections(query, fn); err != nil {
		return err
	}

	query.Prefix = query.Prefix + cmBranchSeparator
	if err := m.collectPages(query, fn); err != nil {
		return err
	}

	return nil
}

func (m *pageMap) collectSections(query pageMapQuery, fn func(c *contentNode)) error {
	level := strings.Count(query.Prefix, "/")

	return m.collectSectionsFn(query, func(s string, c *contentNode) bool {
		if strings.Count(s, "/") != level+1 {
			return false
		}

		fn(c)

		return false
	})
}

func (m *pageMap) collectSectionsFn(query pageMapQuery, fn func(s string, c *contentNode) bool) error {
	if !strings.HasSuffix(query.Prefix, "/") {
		query.Prefix += "/"
	}

	m.sections.WalkQuery(query, func(s string, n *contentNode) bool {
		return fn(s, n)
	})

	return nil
}

func (m *pageMap) collectSectionsRecursiveIncludingSelf(query pageMapQuery, fn func(c *contentNode)) error {
	return m.collectSectionsFn(query, func(s string, c *contentNode) bool {
		fn(c)
		return false
	})
}

func (m *pageMap) collectTaxonomies(prefix string, fn func(c *contentNode)) error {
	m.taxonomies.WalkQuery(pageMapQuery{Prefix: prefix}, func(s string, n *contentNode) bool {
		fn(n)
		return false
	})
	return nil
}

// withEveryBundlePage applies fn to every Page, including those bundled inside
// leaf bundles.
func (m *pageMap) withEveryBundlePage(fn func(p *pageState) bool) {
	m.bundleTrees.Walk(func(s string, n *contentNode) bool {
		if n.p != nil {
			return fn(n.p)
		}
		return false
	})
}

type pageMaps struct {
	workers *para.Workers
	pmaps   []*pageMap
}

// deleteSection deletes the entire section from s.
func (m *pageMaps) deleteSection(s string) {
	m.withMaps(func(pm *pageMap) error {
		pm.deleteSectionByPath(s)
		return nil
	})
}

func (m *pageMaps) AssemblePages() error {
	return m.withMaps(func(pm *pageMap) error {
		if err := pm.CreateMissingNodes(); err != nil {
			return err
		}

		if err := pm.assemblePages(); err != nil {
			return err
		}

		if err := pm.createMissingTaxonomyNodes(); err != nil {
			return err
		}

		// Handle any new sections created in the step above.
		if err := pm.assembleSections(); err != nil {
			return err
		}

		if pm.s.home == nil {
			// Home is disabled, everything is.
			pm.bundleTrees.DeletePrefix("")
			return nil
		}

		if err := pm.assembleTaxonomies(); err != nil {
			return err
		}

		if err := pm.createSiteTaxonomies(); err != nil {
			return err
		}

		sw := &sectionWalker{m: pm.contentMap}
		a := sw.applyAggregates()
		_, mainSectionsSet := pm.s.s.Info.Params()["mainsections"]
		if !mainSectionsSet && a.mainSection != "" {
			mainSections := []string{strings.TrimRight(a.mainSection, "/")}
			pm.s.s.Info.Params()["mainSections"] = mainSections
			pm.s.s.Info.Params()["mainsections"] = mainSections
		}

		pm.s.lastmod = a.datesAll.Lastmod()
		if resource.IsZeroDates(pm.s.home) {
			pm.s.home.m.Dates = a.datesAll
		}

		return nil
	})
}

func (m *pageMaps) walkBundles(fn func(n *contentNode) bool) {
	_ = m.withMaps(func(pm *pageMap) error {
		pm.bundleTrees.Walk(func(s string, n *contentNode) bool {
			return fn(n)
		})
		return nil
	})
}

func (m *pageMaps) walkBranchesPrefix(prefix string, fn func(s string, n *contentNode) bool) {
	_ = m.withMaps(func(pm *pageMap) error {
		pm.branchTrees.WalkPrefix(prefix, func(s string, n *contentNode) bool {
			return fn(s, n)
		})
		return nil
	})
}

func (m *pageMaps) withMaps(fn func(pm *pageMap) error) error {
	g, _ := m.workers.Start(context.Background())
	for _, pm := range m.pmaps {
		pm := pm
		g.Run(func() error {
			return fn(pm)
		})
	}
	return g.Wait()
}

type pagesMapBucket struct {
	// Cascading front matter.
	cascade map[page.PageMatcher]maps.Params

	owner *pageState // The branch node

	*pagesMapBucketPages
}

type pagesMapBucketPages struct {
	pagesInit sync.Once
	pages     page.Pages

	pagesAndSectionsInit sync.Once
	pagesAndSections     page.Pages

	sectionsInit sync.Once
	sections     page.Pages
}

func (b *pagesMapBucket) getPages() page.Pages {
	b.pagesInit.Do(func() {
		b.pages = b.owner.treeRef.getPages()
		page.SortByDefault(b.pages)
	})
	return b.pages
}

func (b *pagesMapBucket) getPagesRecursive() page.Pages {
	pages := b.owner.treeRef.getPagesRecursive()
	page.SortByDefault(pages)
	return pages
}

func (b *pagesMapBucket) getPagesAndSections() page.Pages {
	b.pagesAndSectionsInit.Do(func() {
		b.pagesAndSections = b.owner.treeRef.getPagesAndSections()
	})
	return b.pagesAndSections
}

func (b *pagesMapBucket) getSections() page.Pages {
	b.sectionsInit.Do(func() {
		if b.owner.treeRef == nil {
			return
		}
		b.sections = b.owner.treeRef.getSections()
	})

	return b.sections
}

func (b *pagesMapBucket) getTaxonomies() page.Pages {
	b.sectionsInit.Do(func() {
		var pas page.Pages
		ref := b.owner.treeRef
		ref.m.collectTaxonomies(ref.key, func(c *contentNode) {
			pas = append(pas, c.p)
		})
		page.SortByDefault(pas)
		b.sections = pas
	})

	return b.sections
}

func (b *pagesMapBucket) getTaxonomyEntries() page.Pages {
	var pas page.Pages
	ref := b.owner.treeRef
	viewInfo := ref.n.viewInfo
	prefix := strings.ToLower("/" + viewInfo.name.plural + "/" + viewInfo.termKey + "/")
	ref.m.taxonomyEntries.WalkPrefix(prefix, func(s string, v interface{}) bool {
		n := v.(*contentNode)
		pas = append(pas, n.viewInfo.ref.p)
		return false
	})
	page.SortByDefault(pas)
	return pas
}

type sectionAggregate struct {
	datesAll             resource.Dates
	datesSection         resource.Dates
	pageCount            int
	mainSection          string
	mainSectionPageCount int
}

type sectionAggregateHandler struct {
	sectionAggregate
	sectionPageCount int

	// Section
	b *contentNode
	s string
}

func (h *sectionAggregateHandler) String() string {
	return fmt.Sprintf("%s/%s - %d - %s", h.sectionAggregate.datesAll, h.sectionAggregate.datesSection, h.sectionPageCount, h.s)
}

func (h *sectionAggregateHandler) isRootSection() bool {
	return h.s != "/" && strings.Count(h.s, "/") == 2
}

func (h *sectionAggregateHandler) handleNested(v sectionWalkHandler) error {
	nested := v.(*sectionAggregateHandler)
	h.sectionPageCount += nested.pageCount
	h.pageCount += h.sectionPageCount
	h.datesAll.UpdateDateAndLastmodIfAfter(nested.datesAll)
	h.datesSection.UpdateDateAndLastmodIfAfter(nested.datesAll)
	return nil
}

func (h *sectionAggregateHandler) handlePage(s string, n *contentNode) error {
	h.sectionPageCount++

	var d resource.Dated
	if n.p != nil {
		d = n.p
	} else if n.viewInfo != nil && n.viewInfo.ref != nil {
		d = n.viewInfo.ref.p
	} else {
		return nil
	}

	h.datesAll.UpdateDateAndLastmodIfAfter(d)
	h.datesSection.UpdateDateAndLastmodIfAfter(d)
	return nil
}

func (h *sectionAggregateHandler) handleSectionPost() error {
	if h.sectionPageCount > h.mainSectionPageCount && h.isRootSection() {
		h.mainSectionPageCount = h.sectionPageCount
		h.mainSection = strings.TrimPrefix(h.s, "/")
	}

	if resource.IsZeroDates(h.b.p) {
		h.b.p.m.Dates = h.datesSection
	}

	h.datesSection = resource.Dates{}

	return nil
}

func (h *sectionAggregateHandler) handleSectionPre(s string, b *contentNode) error {
	h.s = s
	h.b = b
	h.sectionPageCount = 0
	h.datesAll.UpdateDateAndLastmodIfAfter(b.p)
	return nil
}

type sectionWalkHandler interface {
	handleNested(v sectionWalkHandler) error
	handlePage(s string, b *contentNode) error
	handleSectionPost() error
	handleSectionPre(s string, b *contentNode) error
}

type sectionWalker struct {
	err error
	m   *contentMap
}

func (w *sectionWalker) applyAggregates() *sectionAggregateHandler {
	return w.walkLevel("/", func() sectionWalkHandler {
		return &sectionAggregateHandler{}
	}).(*sectionAggregateHandler)
}

func (w *sectionWalker) walkLevel(prefix string, createVisitor func() sectionWalkHandler) sectionWalkHandler {
	level := strings.Count(prefix, "/")

	visitor := createVisitor()

	w.m.taxonomies.WalkBelow(prefix, func(s string, v interface{}) bool {
		currentLevel := strings.Count(s, "/")

		if currentLevel > level+1 {
			return false
		}

		n := v.(*contentNode)

		if w.err = visitor.handleSectionPre(s, n); w.err != nil {
			return true
		}

		if currentLevel == 2 {
			nested := w.walkLevel(s, createVisitor)
			if w.err = visitor.handleNested(nested); w.err != nil {
				return true
			}
		} else {
			w.m.taxonomyEntries.WalkPrefix(s, func(ss string, v interface{}) bool {
				n := v.(*contentNode)
				w.err = visitor.handlePage(ss, n)
				return w.err != nil
			})
		}

		w.err = visitor.handleSectionPost()

		return w.err != nil
	})

	w.m.sections.WalkBelow(prefix, func(s string, v interface{}) bool {
		currentLevel := strings.Count(s, "/")
		if currentLevel > level+1 {
			return false
		}

		n := v.(*contentNode)

		if w.err = visitor.handleSectionPre(s, n); w.err != nil {
			return true
		}

		w.m.pages.WalkPrefix(s+cmBranchSeparator, func(s string, v interface{}) bool {
			w.err = visitor.handlePage(s, v.(*contentNode))
			return w.err != nil
		})

		if w.err != nil {
			return true
		}

		nested := w.walkLevel(s, createVisitor)
		if w.err = visitor.handleNested(nested); w.err != nil {
			return true
		}

		w.err = visitor.handleSectionPost()

		return w.err != nil
	})

	return visitor
}

type viewName struct {
	singular string // e.g. "category"
	plural   string // e.g. "categories"
}

func (v viewName) IsZero() bool {
	return v.singular == ""
}
