template.go

/*
 * Copyright 2018 darkdarkfruit.  All rights reserved.
 *
 * Use of this source code is governed by a MIT style
 * license that can be found in the LICENSE file.
 *
 */

/*
Go(Golang) template manager, especially suited for web.


# There are 2 types of templateEnv(aka: 2 types of templateName). Default is ContextMode
1. ContextMode: Name starts with "C->" or not starts with "F->"

	eg: "C->main/demo/demo.tpl.html"
	 or "C-> main/demo/demo.tpl.html" (not: blanks before file(main/demo/demo.tpl.html) will be discarded)
	 or	"main/demo/demo.tpl.html"

2. FilesMode:   Name starts with "F->". (default separator of multiple files is ";")

	eg: "F->main/demo/demo.tpl.html"
     or "F-> main/demo/demo.tpl.html"
     or "F-> main/demo/demo.tpl.html;main/demo/demo_ads.tpl.html" (will use the first file name when executing template)

# ContextMode is using template nesting, somewhat like template-inheritance in django/jinja2/...
ContextMode will load context templates, then execute template in file: `FilePathOfLayoutRelativeToRoot`.

# FilesMode is basically the same as http/template

*/
package templatemanager

// package main

import (
	"bytes"
	"fmt"
	"github.com/oxtoacart/bpool"
	"github.com/tdewolff/minify"
	"github.com/tdewolff/minify/html"
	"html/template"
	"io"
	"io/ioutil"
	"log"
	"os"
	"path"
	"path/filepath"
	"strings"
	"sync"
	"time"
)

const (
	MimeHtml          = "text/html"
	templateEngineKey = "github.com/darkdarkfruit/templatemanager"
	VERSION           = "0.7.1"
)

var (
	htmlContentType    = []string{"text/html; charset=utf-8"}
	bufpool            *bpool.BufferPool
	htmlMinifier       *minify.M
	goTemplateMinifier *minify.M
)

func init() {
	log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
	bufpool = bpool.NewBufferPool(64)
	// log.Println("buffer allocation successful")
	htmlMinifier = minify.New()
	htmlMinifier.AddFunc(MimeHtml, html.Minify)

	goTemplateMinifier = minify.New()

	// we keep the minifier wild.
	goTemplateMinifier.Add(MimeHtml, &html.Minifier{
		KeepDefaultAttrVals: true,
		KeepWhitespace:      true,
		KeepDocumentTags:    true,
		KeepEndTags:         true,
	})
}

func Version() string {
	return VERSION
}

type TemplateManager struct {
	Config        TemplateConfig
	TemplatesMap  map[string]*template.Template
	templateMutex sync.RWMutex
}

type TemplateConfig struct {
	DirOfRoot                      string           // template root dir
	DirOfMainRelativeToRoot        string           // template dir: main
	DirOfContextRelativeToRoot     string           // template dir: context
	FilePathOfLayoutRelativeToRoot string           // template layout file path
	Extension                      string           // template extension
	FuncMap                        template.FuncMap // template functions
	Delims                         Delims           // delimiters

	IsDebugging          bool // true: Show debug info; false: disable debug info and enable cache.
	VerboseLevel         int  // 0: not show anything
	EnableMinifyTemplate bool // enable minify template after loading it and before storing it to the memory.
	EnableMinifyHtml     bool // decide to minify html while output
	ShowQps              bool // if VerboseLevel >= 1 || ShowQps { // show qps }, default is false
}

type Delims struct {
	Left  string
	Right string
}

func New(config TemplateConfig) *TemplateManager {
	return &TemplateManager{
		Config: config,

		TemplatesMap:  make(map[string]*template.Template),
		templateMutex: sync.RWMutex{},
	}
}

func NewDefault(isDebugging bool) *TemplateManager {
	return New(NewDefaultConfig(isDebugging))
}

func NewDefaultConfig(isDebugging bool) TemplateConfig {
	return TemplateConfig{
		DirOfRoot:                      "templates",
		DirOfMainRelativeToRoot:        "main",
		DirOfContextRelativeToRoot:     "context",
		FilePathOfLayoutRelativeToRoot: "context/layout/layout.tpl.html",
		Extension:                      ".html",
		FuncMap:                        make(template.FuncMap),
		Delims:                         Delims{Left: "{{", Right: "}}"},
		IsDebugging:                    isDebugging,
		VerboseLevel:                   1,
		EnableMinifyTemplate:           false,
		EnableMinifyHtml:               false,
	}
}
func (tm *TemplateManager) DoShowDebugMessage() bool {
	if tm.Config.VerboseLevel <= 0 {
		return false
	}
	return tm.Config.IsDebugging && tm.Config.VerboseLevel > 0
}

// 0: disables all
func (tm *TemplateManager) SetVerboseLevel(level int) {
	tm.Config.VerboseLevel = level
}

func (tm *TemplateManager) GetTemplateNames() (names []string) {
	for k := range tm.TemplatesMap {
		names = append(names, k)
	}
	return
}

func (tm *TemplateManager) GetFilePathOfBase() (name string) {
	return path.Join(tm.Config.DirOfRoot, tm.Config.FilePathOfLayoutRelativeToRoot)
}

func (tm *TemplateManager) GetMapOfTemplateNameToDefinedNames() (m map[string]string) {
	m = make(map[string]string)
	for k, tpl := range tm.TemplatesMap {
		m[k] = tpl.DefinedTemplates()
	}
	return
}

func (tm *TemplateManager) Report() string {
	s := fmt.Sprintf(`
Report of template manager
==============================
--> config
%#v
------------------------
--> (map(sum=%d):  templateName -> it's definedNames), 
`, tm.Config, len(tm.TemplatesMap))
	i := 0
	for tplName, definedNames := range tm.GetMapOfTemplateNameToDefinedNames() {
		i += 1
		s += fmt.Sprintf("%d: %q -> %s\n", i, tplName, definedNames)
	}
	s += "------------------------\n"
	return s
}

func (tm *TemplateManager) getDirOfMain() string {
	return path.Join(tm.Config.DirOfRoot, tm.Config.DirOfMainRelativeToRoot)
}

func (tm *TemplateManager) getDirOfContext() string {
	return path.Join(tm.Config.DirOfRoot, tm.Config.DirOfContextRelativeToRoot)
}

func getTemplateFilePathsByWalking(root string, ext string, prefix string) ([]string, error) {
	var filePaths []string
	walkFunc := func(p string, info os.FileInfo, err error) error {
		if err != nil {
			currentDir, _ := os.Getwd()
			log.Panicf("error happens while walking dir: %q(current dir is: %q), walking-root-for-function: %q,  err: %v", p, currentDir, root, err)
		}
		if !info.IsDir() && path.Ext(p) == ext {
			filePaths = append(filePaths, path.Join(prefix, p))
		}
		return nil
	}
	err := filepath.Walk(root, walkFunc)
	if err != nil {
		log.Printf("Faild walking root dir: %q. err: %q", root, err)
		log.Fatalf("Faild walking root dir: %q. err: %q", root, err)
		return nil, err
	}
	return filePaths, nil
}

// ContainsString checks if the slice has the contains value in it.
func ContainsString(slice []string, contains string) bool {
	for _, value := range slice {
		if value == contains {
			return true
		}
	}
	return false
}

func (tm *TemplateManager) getContextFiles() []string {
	contextFiles, err := getTemplateFilePathsByWalking(tm.getDirOfContext(), tm.Config.Extension, "")
	if err != nil {
		log.Fatalf("Could not get context files of dir: %q. err: %s", tm.getDirOfContext(), err)
	}
	if tm.DoShowDebugMessage() {
		log.Printf("ContextFiles are: %v", contextFiles)
	}
	if !ContainsString(contextFiles, tm.GetFilePathOfBase()) {
		contextFiles = append(contextFiles, tm.GetFilePathOfBase())
	}

	return contextFiles
}

// get templates which is not context file.
func (tm *TemplateManager) getMainFiles() []string {
	// mainFiles, err := filepath.Glob(path.Join(tm.getDirOfMain(), "**", "*"+tm.Config.Extension))
	mainFiles, err := getTemplateFilePathsByWalking(tm.getDirOfMain(), tm.Config.Extension, "")
	if err != nil {
		log.Fatalf("Could not get main files of dir: %q. err: %s", tm.getDirOfMain(), err)
	}

	// DirOfContextRelativeToRoot might be a sub directory of DirOfMainRelativeToRoot
	var mf []string
	for _, f := range mainFiles {
		// skip context files (if context_dir is a sub_dir of main_dir)
		if strings.HasPrefix(f, tm.Config.DirOfContextRelativeToRoot) {
			continue
		}
		mf = append(mf, f)
	}

	log.Printf("Found %d main templates(exclude context templates)", len(mf))
	return mf
}

func (tm *TemplateManager) getBasicTemplateNameByFilePath(filepath string) string {
	s := strings.TrimPrefix(filepath, tm.Config.DirOfRoot)
	return strings.TrimPrefix(s, "/")
}

// func (tm *TemplateManager) getContextTemplate() *template.Template {
//	contextTemplate := template.Must(template.ParseFiles(tm.getContextFiles()...))
//	return contextTemplate
//}

func (tm *TemplateManager) setTemplate(te *TemplateEnv, tpl *template.Template) {
	if tpl == nil {
		panic("Template can not be nil")
	}

	tplName := te.StandardTemplateName()
	tm.templateMutex.Lock()
	defer tm.templateMutex.Unlock()
	tm.TemplatesMap[tplName] = tpl
}

func (tm *TemplateManager) parseMainFiles() error {
	for i, f := range tm.getMainFiles() {
		if tm.DoShowDebugMessage() {
			log.Printf("\n")
			log.Printf("--(template: seq: %d)--> Parsing template file: %q", i, f)
		}
		tm.parseMainTemplateByFilePath(f)
	}
	log.Printf("")
	return nil
}

func (tm *TemplateManager) MustTemplate(tplName string, filesForParsing []string) *template.Template {
	if !tm.Config.EnableMinifyTemplate {
		tpl := template.Must(template.New(tplName).Funcs(tm.Config.FuncMap).ParseFiles(filesForParsing...))
		return tpl
	} else {
		/* Could not find a better way to store minified content while keeps filenames which required by template to "ParseFiles"
		 * solution:
		 * 	create a tmp dir, then populates it with minified files.
		 * ...
		 * ...
		 */
		if tm.DoShowDebugMessage() {
			log.Printf("Minifying template: %q", tplName)
		}
		tmpDir, err := ioutil.TempDir("", "go-template")
		if err != nil {
			log.Printf("Could not create temparary dir. err: %s", err)
			panic(err)
			return nil
		}
		defer func() {
			err := os.RemoveAll(tmpDir)
			if err != nil {
				log.Printf("could not remove tmpDir: %q. e: %v", tmpDir, err)
			}
		}()

		for _, f := range filesForParsing {
			baseName := path.Base(f)
			fpath := path.Join(tmpDir, baseName)
			outFile, err := os.Create(fpath)
			if err != nil {
				fmt.Printf("Could not create file: %q. err: %s", fpath, err)
				panic(err)
				return nil
			}

			inFile, err := os.Open(f)
			if err != nil {
				fmt.Printf("Could not open file: %q. err: %s", f, err)
				panic(err)
				return nil
			}
			err = goTemplateMinifier.Minify(MimeHtml, outFile, inFile)
			if err != nil {
				log.Printf("Could not minify template in buf. err: %s", err)
				panic(err)
			}
		}
		tpl := template.Must(template.New(tplName).Funcs(tm.Config.FuncMap).ParseGlob(filepath.Join(tmpDir, "*")))
		return tpl
	}
}

func (tm *TemplateManager) ParseContextModeTemplate(te *TemplateEnv) *template.Template {
	if !te.IsContextMode() {
		return nil
	}

	tplName := te.StandardTemplateName()
	filePaths := te.GetFilePaths(tm.Config.DirOfRoot)

	if tm.DoShowDebugMessage() {
		if len(filePaths) == 1 {
			log.Printf("ContextEnv Parsing: (tplName -> tplPath) (%q -> %q)", tplName, filePaths[0])
		} else {
			log.Printf("ContextEnv Parsing: (tplName -> tplPaths) (%q -> %q)", tplName, filePaths)
		}
	}
	contextFiles := tm.getContextFiles()
	filesForParsing := append(contextFiles, filePaths...)

	// tpl := template.Must(template.New(tplName).Funcs(tm.Config.FuncMap).ParseFiles(filesForParsing...))
	tpl := tm.MustTemplate(tplName, filesForParsing)
	tm.setTemplate(te, tpl)
	if tm.DoShowDebugMessage() {
		log.Printf("ContextEnv template:     (templateName -> definedTemplates): %q -> %s", tpl.Name(), tpl.DefinedTemplates())
	}
	return tpl
}

func (tm *TemplateManager) ParseFilesModeTemplate(te *TemplateEnv) *template.Template {
	if !te.IsFilesMode() {
		return nil
	}
	tplName := te.StandardTemplateName()
	filesForParsing := te.GetFilePaths(tm.Config.DirOfRoot)
	if tm.DoShowDebugMessage() {
		log.Printf("FilesEnv Parsing: (tplName -> tplPath) (%q -> %q)", tplName, filesForParsing)
	}
	// tpl := template.Must(template.New(tplName).Funcs(tm.Config.FuncMap).ParseFiles(filesForParsing...))
	tpl := tm.MustTemplate(tplName, filesForParsing)
	tm.setTemplate(te, tpl)
	if tm.DoShowDebugMessage() {
		log.Printf("FilesEnv template: (tplName -> definedTemplates): %q -> %s", tpl.Name(), tpl.DefinedTemplates())
	}
	return tpl
}

func (tm *TemplateManager) parseTemplate(te *TemplateEnv) *template.Template {
	tplName := te.StandardTemplateName()
	if te.IsContextMode() {
		if tm.DoShowDebugMessage() {
			log.Printf("tplName: %q is a contextEnv tplName", tplName)
		}
		return tm.ParseContextModeTemplate(te)
	} else if te.IsFilesMode() {
		if tm.DoShowDebugMessage() {
			log.Printf("tplName: %q is a filesEnv tplName", tplName)
		}
		return tm.ParseFilesModeTemplate(te)
	} else {
		log.Printf("tplName: %q is an invalid tplName", tplName)
		msg := fmt.Sprintf("Could not find template by tplName: %q", tplName)
		log.Printf(msg)
		panic(msg)
	}
}

func (tm *TemplateManager) parseMainTemplateByFilePath(filePath string) *template.Template {
	basicTplName := tm.getBasicTemplateNameByFilePath(filePath)
	te := NewTemplateEnvByParsing(basicTplName)
	te.ToContextMode()
	contextTpl := tm.ParseContextModeTemplate(te)
	if contextTpl == nil {
		log.Printf("Error filepath: %q", filePath)
	}

	te.ToFilesMode()
	filesTpl := tm.ParseFilesModeTemplate(te)
	if filesTpl == nil {
		log.Printf("Error filepath: %q", filePath)
	}
	return contextTpl
}

func (tm *TemplateManager) Init(useMaster bool) error {
	log.Printf("Initing templates. DirOfMainRelativeToRoot: %q, DirOfContextRelativeToRoot: %q", tm.Config.DirOfMainRelativeToRoot, tm.Config.DirOfContextRelativeToRoot)
	includeFunc := func(name string, data interface{}) (template.HTML, error) {
		buf := new(bytes.Buffer)
		err := tm.ExecuteTemplate(buf, name, data)
		return template.HTML(buf.String()), err
	}
	tm.Config.FuncMap["include"] = includeFunc

	return tm.parseMainFiles()
}

func (tm *TemplateManager) GetTemplate(tplName string) (*template.Template, bool) {
	tm.templateMutex.RLock()
	defer tm.templateMutex.RUnlock()
	tpl, ok := tm.TemplatesMap[tplName]
	return tpl, ok
}

func (tm *TemplateManager) rightBeforeExecuteTemplate(tpl *template.Template, out io.Writer, name string, data interface{}) error {
	if !tm.Config.EnableMinifyHtml {
		return tpl.ExecuteTemplate(out, name, data)
	} else {
		buf := bufpool.Get()
		defer bufpool.Put(buf)

		err := tpl.ExecuteTemplate(buf, name, data)
		if err != nil {
			log.Printf("Error executing template of %q with data: %v", name, data)
			return err
		}

		if err := htmlMinifier.Minify(MimeHtml, out, buf); err != nil {
			log.Printf("Error while minifying text/html. err: %s", err)
			return err
		}
		//buf.WriteTo(out)
		return nil
		//return tm.ExecuteTemplate(out, name, data)
	}
}

func (tm *TemplateManager) ExecuteTemplate(out io.Writer, templateName string, data interface{}) error {
	t0 := time.Now()
	var tpl *template.Template
	var err error
	var ok bool

	te := NewTemplateEnvByParsing(templateName)
	tplName := te.StandardTemplateName()
	if tm.DoShowDebugMessage() {
		log.Printf("Request executing template name: %q, standard template name is: %q", templateName, tplName)
	}
	tpl, ok = tm.GetTemplate(tplName)

	if !ok || tm.Config.IsDebugging {
		log.Printf("Template-not-exist or in-debug-mode. Requst executing templateName: %q. Re-parsing it.", tplName)
		tpl = tm.parseTemplate(te)
		tpl, ok = tm.GetTemplate(tplName)
		if !ok {
			log.Printf("Could not find correspondent template by tplName: %s", tplName)
		}
	}

	var name string
	if te.IsContextMode() {
		name = filepath.Base(tm.Config.FilePathOfLayoutRelativeToRoot)
	} else if te.IsFilesMode() {
		name = filepath.Base(te.Names[0])
	}

	err = tm.rightBeforeExecuteTemplate(tpl, out, name, data)
	if err != nil {
		log.Printf("TemplateManager execute template error: %s", err)
		return err
	}

	//// render
	//if te.IsContextMode() {
	//	//err = tpl.ExecuteTemplate(out, filepath.Base(tm.Config.FilePathOfLayoutRelativeToRoot), data)
	//	err = tm.rightBeforeExecuteTemplate(tpl, out, filepath.Base(tm.Config.FilePathOfLayoutRelativeToRoot), data)
	//	if err != nil {
	//		log.Printf("TemplateManager execute template error: %s", err)
	//		return err
	//	}
	//} else if te.IsFilesMode() {
	//	name := filepath.Base(te.Names[0])
	//	err = tpl.ExecuteTemplate(out, name, data)
	//	if err != nil {
	//		log.Printf("TemplateManager execute template error: %s", err)
	//		return err
	//	}
	//}

	if tm.Config.VerboseLevel >= 1 || tm.Config.ShowQps {
		log.Printf("func: ExecuteTemplate, name: %q, isDebuging: %v, stat: %s", templateName, tm.Config.IsDebugging, NewQpsStat(t0, time.Now(), 1).ShortString())
	}
	return nil
}