// Copyright © 2014 Steve Francia <spf@spf13.com>.

// Copyright 2009 The Go 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 afero

import (

	"path/filepath"

	"sort"

	"strings"

)

// Glob returns the names of all files matching pattern or nil

// if there is no matching file. The syntax of patterns is the same

// as in Match. The pattern may describe hierarchical names such as

// /usr/*/bin/ed (assuming the Separator is '/').

//

// Glob ignores file system errors such as I/O errors reading directories.

// The only possible returned error is ErrBadPattern, when pattern

// is malformed.

//

// This was adapted from (http://golang.org/pkg/path/filepath) and uses several

// built-ins from that package.

func Glob(fs Fs, pattern string) (matches []string, err error) {

	if !hasMeta(pattern) {

		// Lstat not supported by a ll filesystems.

		if _, err = lstatIfPossible(fs, pattern); err != nil {

			return nil, nil

		}

		return []string{pattern}, nil

	}

	dir, file := filepath.Split(pattern)

	switch dir {

	case "":

		dir = "."

	case string(filepath.Separator):

	// nothing

	default:

		dir = dir[0 : len(dir)-1] // chop off trailing separator

	}

	if !hasMeta(dir) {

		return glob(fs, dir, file, nil)

	}

	var m []string

	m, err = Glob(fs, dir)

	if err != nil {

		return

	}

	for _, d := range m {

		matches, err = glob(fs, d, file, matches)

		if err != nil {

			return

		}

	}

	return

}

// glob searches for files matching pattern in the directory dir

// and appends them to matches. If the directory cannot be

// opened, it returns the existing matches. New matches are

// added in lexicographical order.

func glob(fs Fs, dir, pattern string, matches []string) (m []string, e error) {

	m = matches

	fi, err := fs.Stat(dir)

	if err != nil {

		return

	}

	if !fi.IsDir() {

		return

	}

	d, err := fs.Open(dir)

	if err != nil {

		return

	}

	defer d.Close()

	names, _ := d.Readdirnames(-1)

	sort.Strings(names)

	for _, n := range names {

		matched, err := filepath.Match(pattern, n)

		if err != nil {

			return m, err

		}

		if matched {

			m = append(m, filepath.Join(dir, n))

		}

	}

	return

}

// hasMeta reports whether path contains any of the magic characters

// recognized by Match.

func hasMeta(path string) bool {

	// TODO(niemeyer): Should other magic characters be added here?

	return strings.ContainsAny(path, "*?[")

}