const TemplateVersion = 2

var DefaultParseConfig = ParseConfig{
	Version: TemplateVersion,
}

var DefaultParseInfo = ParseInfo{
	Config: DefaultParseConfig,
}

type FileInfo interface {
	Name() string
	Filename() string
}

type Info interface {
	ParseInfo() ParseInfo

	// Identifies this template and its dependencies.
	identity.Provider
}

type InfoManager interface {
	ParseInfo() ParseInfo

	// Identifies and manages this template and its dependencies.
	identity.Manager
}

type ParseConfig struct {
	Version int
}

type ParseInfo struct {
	// Set for shortcode templates with any {{ .Inner }}
	IsInner bool

	// Set for partials with a return statement.
	HasReturn bool

	// Config extracted from template.
	Config ParseConfig
}

type Template interface {
	Name() string
	Prepare() (*texttemplate.Template, error)
}

type TemplateDebugger interface {
	Debug()
}

type TemplateFinder interface {
	TemplateLookup
	TemplateLookupVariant
}

type TemplateFuncGetter interface {
	GetFunc(name string) (reflect.Value, bool)
}

type TemplateHandler interface {
	TemplateFinder
	Execute(t Template, wr io.Writer, data any) error
	ExecuteWithContext(ctx context.Context, t Template, wr io.Writer, data any) error
	LookupLayout(d output.LayoutDescriptor, f output.Format) (Template, bool, error)
	HasTemplate(name string) bool
}

type TemplateLookup interface {
	Lookup(name string) (Template, bool)
}

type TemplateLookupVariant interface {
	// TODO(bep) this currently only works for shortcodes.
	// We may unify and expand this variant pattern to the
	// other templates, but we need this now for the shortcodes to
	// quickly determine if a shortcode has a template for a given
	// output format.
	// It returns the template, if it was found or not and if there are
	// alternative representations (output format, language).
	// We are currently only interested in output formats, so we should improve
	// this for speed.
	LookupVariant(name string, variants TemplateVariants) (Template, bool, bool)
	LookupVariants(name string) []Template
}

type TemplateManager interface {
	TemplateHandler
	TemplateFuncGetter
	AddTemplate(name, tpl string) error
	MarkReady() error
}

type TemplateParseFinder interface {
	TemplateParser
	TemplateFinder
}

type TemplateParser interface {
	Parse(name, tpl string) (Template, error)
}

type TemplateVariants struct {
	Language     string
	OutputFormat output.Format
}

type TemplatesProvider interface {
	Tmpl() TemplateHandler
	TextTmpl() TemplateParseFinder
}

type UnusedTemplatesProvider interface {
	UnusedTemplates() []FileInfo
}