// Copyright 2018 The CUE Authors
//
// 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 build

import (
	"fmt"
	pathpkg "path"
	"path/filepath"
	"slices"
	"strconv"
	"strings"
	"unicode"

	"cuelang.org/go/cue/ast"
	"cuelang.org/go/cue/ast/astutil"
	"cuelang.org/go/cue/errors"
	"cuelang.org/go/cue/parser"
	"cuelang.org/go/cue/token"
	"cuelang.org/go/internal/mod/modfiledata"
	"cuelang.org/go/mod/module"
)

// An Instance describes the collection of files, and its imports, necessary
// to build a CUE instance.
//
// A typical way to create an Instance is to use the cue/load package.
type Instance struct {
	ctxt *Context

	BuildFiles    []*File // files to be included in the build
	IgnoredFiles  []*File // files excluded for this build
	OrphanedFiles []*File // recognized file formats not part of any build
	InvalidFiles  []*File // could not parse these files
	UnknownFiles  []*File // unknown file types

	User bool // True if package was created from individual files.

	// Files contains the AST for all files part of this instance.
	// When populated via [cuelang.org/go/cue/load.Instances], Files is
	// index-parallel with BuildFiles: Files[i] holds the parsed AST for
	// BuildFiles[i].
	// TODO: the intent is to deprecate this in favor of BuildFiles.
	Files []*ast.File

	loadFunc LoadFunc
	done     bool

	// CanonicalImportPath, if non-nil, is called for each import path
	// extracted from the instance's source files before it is resolved
	// to determine its canonical form. This allows the caller to
	// rewrite import paths to canonical forms — for example, adding a
	// major version qualifier to an unversioned import based on the
	// importing module's own defaults.
	CanonicalImportPath func(importPath string) string

	// PkgName is the name specified in the package clause.
	PkgName string
	hasName bool

	// ImportPath returns the unique path to identify an imported instance.
	//
	// Instances created with [Context.NewInstance] do not have an import path.
	ImportPath string

	// CanonicalID, if non-empty, holds the canonical identifier used for
	// hidden-field namespaces. It normalizes version and qualifier differences
	// so that the same package always gets the same hidden-field namespace
	// regardless of how it was imported.
	//
	// TODO it would be better to just canonicalize ImportPath but
	// doing so runs the risk of breaking existing users which assume
	// a direct mapping from import path to [Instance.ImportPath].
	// See https://cuelang.org/issue/4264 for some background.
	CanonicalID string

	// Imports lists the instances of all direct imports of this instance.
	Imports []*Instance

	// The Err for loading this package or nil on success. This does not
	// include any errors of dependencies. Incomplete will be set if there
	// were any errors in dependencies.
	Err errors.Error

	// ResolutionErr contains errors from identifier resolution, such as
	// "imported and not used". These are stored separately from Err to
	// avoid failing import loading for dependencies.
	ResolutionErr errors.Error

	parent *Instance // TODO: for cycle detection

	// The following fields are for informative purposes and are not used by
	// the cue package to create an instance.

	// DisplayPath is a user-friendly version of the package or import path.
	DisplayPath string

	// Module defines the module name of a package. It must be defined if
	// the packages within the directory structure of the module are to be
	// imported by other packages, including those within the module.
	Module string

	// ModuleVersion holds the resolved module version for the package.
	// For packages from external dependencies, this includes the full
	// resolved version. For packages in the main module, the version
	// will be empty.
	ModuleVersion module.Version

	// ModuleFile holds the actual module file data, if available.
	ModuleFile *modfiledata.File

	// Root is the root of the directory hierarchy, it may be "" if this an
	// instance has no imports.
	// If Module != "", this corresponds to the module root.
	// Root/pkg is the directory that holds third-party packages.
	Root string

	// RootLoc holds FS location information for [Instance.Root].
	// It is set when loading from an [io/fs.FS].
	RootLoc token.FSLoc

	// Dir is the package directory. A package may also include files from
	// ancestor directories, up to the module file.
	Dir string

	// DirLoc holds FS location information for [Instance.Dir].
	// It is set when loading from an [io/fs.FS].
	DirLoc token.FSLoc

	// NOTICE: the below struct field tags may change in the future.

	// Incomplete reports whether any dependencies had an error.
	Incomplete bool `api:"alpha"`

	// Dependencies

	// ImportPaths gives the transitive dependencies of all imports.
	ImportPaths []string               `api:"alpha"`
	ImportPos   map[string][]token.Pos `api:"alpha"` // line information for Imports

	Deps       []string `api:"alpha"`
	DepsErrors []error  `api:"alpha"`
	// TODO: Match was declared for years but never set by any of the cue/build logic.
	// If any user was trying to use it, we should implement it,
	// but that seems unlikely given that it was always empty.
	// Match []string `api:"alpha"`
}

// RelPath reports the path of f relative to the root of the instance's module
// directory. The full path is returned if a relative path could not be found.
func (inst *Instance) RelPath(f *File) string {
	p, err := filepath.Rel(inst.Root, f.Filename)
	if err != nil {
		return f.Filename
	}
	return p
}

// ID returns the package ID unique for this module.
func (inst *Instance) ID() string {
	if s := inst.CanonicalID; s != "" {
		return s
	}
	if s := inst.ImportPath; s != "" {
		return s
	}
	if inst.PkgName == "" {
		return "_"
	}
	s := fmt.Sprintf("%s:%s", inst.Module, inst.PkgName)
	return s
}

// Dependencies reports all Instances on which this instance depends.
func (inst *Instance) Dependencies() []*Instance {
	// TODO: as cyclic dependencies are not allowed, we could just not check.
	// Do for safety now and remove later if needed.
	return appendDependencies(nil, inst, map[*Instance]bool{})
}

func appendDependencies(a []*Instance, inst *Instance, done map[*Instance]bool) []*Instance {
	for _, d := range inst.Imports {
		if done[d] {
			continue
		}
		a = append(a, d)
		done[d] = true
		a = appendDependencies(a, d, done)
	}
	return a
}

// Abs converts relative path used in the one of the file fields to an
// absolute one.
func (inst *Instance) Abs(path string) string {
	if filepath.IsAbs(path) {
		return path
	}
	return filepath.Join(inst.Root, path)
}

func (inst *Instance) setPkg(pkg string) bool {
	if !inst.hasName {
		inst.hasName = true
		inst.PkgName = pkg
		return true
	}
	return false
}

// ReportError reports an error processing this instance.
func (inst *Instance) ReportError(err errors.Error) {
	inst.Err = errors.Append(inst.Err, err)
}

// Context defines the build context for this instance. All files defined
// in Syntax as well as all imported instances must be created using the
// same build context.
func (inst *Instance) Context() *Context {
	return inst.ctxt
}

func (inst *Instance) parse(name string, src interface{}) (*ast.File, error) {
	cfg := parser.NewConfig(parser.ParseComments)
	if inst.ModuleFile != nil && inst.ModuleFile.Language != nil {
		cfg = cfg.Apply(parser.Version(inst.ModuleFile.Language.Version))
	}
	if inst.ctxt != nil && inst.ctxt.parseFunc != nil {
		return inst.ctxt.parseFunc(name, src, cfg)
	}
	return parser.ParseFile(name, src, cfg)
}

// LookupImport defines a mapping from an ImportSpec's ImportPath to Instance.
func (inst *Instance) LookupImport(path string) *Instance {
	path = inst.canonicalImportPath(inst.expandPath(path))
	for _, inst := range inst.Imports {
		if inst.ImportPath == path {
			return inst
		}
	}
	return nil
}

func (inst *Instance) canonicalImportPath(path string) string {
	if inst.CanonicalImportPath == nil {
		return path
	}
	return inst.CanonicalImportPath(path)
}

func (inst *Instance) addImport(imp *Instance) {
	for _, inst := range inst.Imports {
		if inst.ImportPath == imp.ImportPath {
			if inst != imp {
				panic("import added multiple times with different instances")
			}
			return
		}
	}
	inst.Imports = append(inst.Imports, imp)
}

// AddFile adds the file with the given name to the list of files for this
// instance. The file may be loaded from the cache of the instance's context.
// It does not process the file's imports. The package name of the file must
// match the package name of the instance.
//
// Deprecated: use [Instance.AddSyntax] or wait for this to be renamed using a new
// signature.
func (inst *Instance) AddFile(filename string, src interface{}) error {
	file, err := inst.parse(filename, src)
	if err != nil {
		// should always be an errors.List, but just in case.
		err := errors.Promote(err, "error adding file")
		inst.ReportError(err)
		return err
	}

	return inst.AddSyntax(file)
}

// AddSyntax adds the given file to list of files for this instance. The package
// name of the file must match the package name of the instance.
func (inst *Instance) AddSyntax(file *ast.File) errors.Error {
	astutil.Resolve(file, func(pos token.Pos, msg string, args ...interface{}) {
		inst.Err = errors.Append(inst.Err, errors.Newf(pos, msg, args...))
	})
	pkg := file.PackageName()
	if pkg != "" && pkg != "_" && !inst.User && !inst.setPkg(pkg) && pkg != inst.PkgName {
		err := errors.Newf(file.Pos(),
			"package name %q conflicts with previous package name %q",
			pkg, inst.PkgName)
		inst.ReportError(err)
		return err
	}
	inst.Files = append(inst.Files, file)
	return nil
}

func (inst *Instance) expandPath(path string) string {
	isLocal := IsLocalImport(path)
	if isLocal {
		path = dirToImportPath(filepath.Join(inst.Dir, path))
	}
	return path
}

// dirToImportPath returns the pseudo-import path we use for a package
// outside the CUE path. It begins with _/ and then contains the full path
// to the directory. If the package lives in c:\home\gopher\my\pkg then
// the pseudo-import path is _/c_/home/gopher/my/pkg.
// Using a pseudo-import path like this makes the ./ imports no longer
// a special case, so that all the code to deal with ordinary imports works
// automatically.
func dirToImportPath(dir string) string {
	return pathpkg.Join("_", strings.Map(makeImportValid, filepath.ToSlash(dir)))
}

func makeImportValid(r rune) rune {
	// Should match Go spec, compilers, and ../../go/parser/parser.go:/isValidImport.
	const illegalChars = `!"#$%&'()*,:;<=>?[\]^{|}` + "`\uFFFD"
	if !unicode.IsGraphic(r) || unicode.IsSpace(r) || strings.ContainsRune(illegalChars, r) {
		return '_'
	}
	return r
}

// IsLocalImport reports whether the import path is
// a local import path, like ".", "..", "./foo", or "../foo".
func IsLocalImport(path string) bool {
	return path == "." || path == ".." ||
		strings.HasPrefix(path, "./") || strings.HasPrefix(path, "../")
}

func (inst *Instance) resolveIdentifiers() errors.Error {
	// Link top-level declarations. As top-level entries get unified, an entry
	// may be linked to any top-level entry of any of the files.
	allFields := map[string]ast.Node{}
	for _, f := range inst.Files {
		if f.PackageName() == "" {
			continue
		}
		for _, d := range f.Decls {
			if f, ok := d.(*ast.Field); ok && f.Value != nil {
				if ident, ok := f.Label.(*ast.Ident); ok {
					allFields[ident.Name] = f.Value
				}
			}
		}
	}

	var errs errors.Error
	for _, f := range inst.Files {
		err := inst.resolveFile(f, allFields)
		errs = errors.Append(errs, err)
	}
	return errs
}

func (inst *Instance) resolveFile(f *ast.File, allFields map[string]ast.Node) errors.Error {
	unresolved := map[string][]*ast.Ident{}
	for _, u := range f.Unresolved {
		unresolved[u.Name] = append(unresolved[u.Name], u)
	}
	fields := map[string]ast.Node{}
	for _, d := range f.Decls {
		if f, ok := d.(*ast.Field); ok && f.Value != nil {
			if ident, ok := f.Label.(*ast.Ident); ok {
				fields[ident.Name] = d
			}
		}
	}
	var errs errors.Error

	specs := []*ast.ImportSpec{}

	for spec := range f.ImportSpecs() {
		id, err := strconv.Unquote(spec.Path.Value)
		if err != nil {
			continue // quietly ignore the error
		}
		name := pathpkg.Base(id)
		if imp := inst.LookupImport(id); imp != nil {
			name = imp.PkgName
		}
		if spec.Name != nil {
			name = spec.Name.Name
		}
		if n, ok := fields[name]; ok {
			errs = errors.Append(errs, errors.Newf(spec.Pos(),
				"%s redeclared as imported package name\n"+
					"\tprevious declaration at %s", name, n.Pos()))
			continue
		}
		fields[name] = spec
		used := false
		for _, u := range unresolved[name] {
			used = true
			u.Node = spec
		}
		if !used {
			specs = append(specs, spec)
		}
	}

	// Verify each import is used.
	if len(specs) > 0 {
		// Find references to imports. This assumes that identifiers in labels
		// are not resolved or that such errors are caught elsewhere.
		ast.Walk(f, nil, func(n ast.Node) {
			if x, ok := n.(*ast.Ident); ok {
				// As we also visit labels, most nodes will be nil.
				if x.Node == nil {
					return
				}
				for i, s := range specs {
					if s == x.Node {
						specs[i] = nil
						return
					}
				}
			}
		})

		// Add errors for unused imports.
		for _, spec := range specs {
			if spec == nil {
				continue
			}
			if spec.Name == nil {
				errs = errors.Append(errs, errors.Newf(spec.Pos(),
					"imported and not used: %s", spec.Path.Value))
			} else {
				errs = errors.Append(errs, errors.Newf(spec.Pos(),
					"imported and not used: %s as %s", spec.Path.Value, spec.Name))
			}
		}
	}

	f.Unresolved = slices.DeleteFunc(f.Unresolved, func(u *ast.Ident) bool {
		if n, ok := allFields[u.Name]; ok {
			u.Node = n
			u.Scope = f
			return true
		}
		if u.Node != nil {
			// Keep valid import resolutions; clear any stale
			// field references from a previous instance context.
			if _, ok := u.Node.(*ast.ImportSpec); ok {
				return true
			}
			u.Node = nil
			u.Scope = nil
		}
		return false
	})

	return errs
}
