func BuildCommentsWidget(cnf Mapper, topCtx mustache.Context) (Widget, error) {
	log.Println("Comments >>", cnf.Layout())
	switch cnf.Layout() {
	case "disqus":
		disqus := cnf[cnf.Layout()].(map[string]interface{})
		short_name := disqus["short_name"]
		if short_name == nil {
			return nil, errors.New("CommentsWidget Of disqus need short_name")
		}
		self := make(CommentsWidget)
		self["comments"] = fmt.Sprintf(Comments_disqus, short_name)
		return self, nil
	case "uyan":
		uyan := cnf[cnf.Layout()].(map[string]interface{})
		uid := uyan["uid"]
		self := make(CommentsWidget)
		self["comments"] = fmt.Sprintf(tpl_uyan, uid)
		return self, nil
	case "duoshuo":
		duoshuo := cnf[cnf.Layout()].(map[string]interface{})
		short_name := duoshuo["short_name"]
		if short_name == nil {
			return nil, errors.New("CommentsWidget Of duoshuo need short_name")
		}
		self := make(CommentsWidget)
		self["comments"] = fmt.Sprintf(Comments_duoshuo, short_name)
		return self, nil
	}
	// 其他的,想不到还有啥,哈哈,需要其他的就报个issue吧
	return nil, errors.New("CommentsWidget Only for disqus yet")
}

func BuildAnalyticsWidget(cnf Mapper, topCtx mustache.Context) (Widget, error) {
	switch cnf.Layout() {
	case "google": // 鼎鼎大名的免费,但有点拖慢加载速度,原因你懂的
		google := cnf[cnf.Layout()].(map[string]interface{})
		tracking_id := google["tracking_id"]
		if tracking_id == nil {
			return nil, errors.New("AnalyticsWidget Of Google need tracking_id")
		}
		self := make(AnalyticsWidget)
		self["analytics"] = fmt.Sprintf(Analytics_google, tracking_id)
		return self, nil
	case "cnzz": //免费,而且很快,但强制嵌入一个反向链接,靠!
		cnzz := cnf[cnf.Layout()].(map[string]interface{})
		tracking_id := cnzz["tracking_id"]
		if tracking_id == nil {
			return nil, errors.New("AnalyticsWidget Of CNZZ need tracking_id")
		}
		self := make(AnalyticsWidget)
		self["analytics"] = fmt.Sprintf(tpl_cnzz, tracking_id, tracking_id)
		return self, nil
	}
	// 其他的尚不支持, 如果需要,请报个issue吧
	return nil, errors.New("AnalyticsWidget Only for Goolge/CNZZ yet")

}

func BuildCustomWidget(name string, dir string, cnf Mapper) (Widget, []string, error) {
	layoutName, ok := cnf["layout"]
	if !ok || layoutName == "" {
		log.Println("Skip Widget : " + dir)
		return nil, nil, nil
	}

	layoutFilePath := dir + "/layouts/" + layoutName.(string) + ".html"
	f, err := os.Open(layoutFilePath)
	if err != nil {
		return nil, nil, errors.New("Fail to load Widget Layout" + dir + "\n" + err.Error())
	}
	defer f.Close()
	cont, err := ioutil.ReadAll(f)
	if err != nil {
		return nil, nil, errors.New("Fail to load Widget Layout" + dir + "\n" + err.Error())
	}

	assets := []string{}
	for _, js := range cnf.GetStrings("javascripts") {
		path := "/assets/" + dir + "/javascripts/" + js
		assets = append(assets, fmt.Sprintf("<script type=\"text/javascript\" src=\"%s\"></script>", path))
	}
	for _, css := range cnf.GetStrings("stylesheets") {
		path2 := "/assets/" + dir + "/stylesheets/" + css
		assets = append(assets, fmt.Sprintf("<link href=\"%s\" type=\"text/css\" rel=\"stylesheet\" media=\"all\">", path2))
	}

	return &CustomWidget{name, &DocContent{string(cont), string(cont), nil}, cnf}, assets, nil

}

func parseLanguageAbility(req *http.Request) ([]db.LanguageAbility, error) {
	var languages []db.LanguageAbility

	rawJson := req.FormValue("langAbilities")
	if len(rawJson) == 0 {
		return languages, errors.New("No argument")
	}

	decoder := json.NewDecoder(strings.NewReader(rawJson))
	if _, e := decoder.Token(); e != nil { //The first array bracket
		return languages, errors.New("Wrong json format")
	}

	element := RawLang{}
	for decoder.More() {
		if e := decoder.Decode(&element); e != nil {
			continue
		}

		if len(element.Abilities) < 4 {
			continue
		}
		lang := db.LanguageAbility{
			Name:      element.LangName,
			Listening: uint(element.Abilities[0].Value),
			Speaking:  uint(element.Abilities[1].Value),
			Reading:   uint(element.Abilities[2].Value),
			Writing:   uint(element.Abilities[3].Value),
		}
		languages = append(languages, lang)
	}

	decoder.Token() //The last array bracket
	return languages, nil
}

func GetSessionUserPermission(req *http.Request) (UserPermission, error) {
	if v, err := GetUserSessionValue(req, USER_PERMISSION_SESSION_KEY); err != nil || v == nil {
		return UserPermission(0), errors.New("Invalid session key")
	} else {
		if perm, found := v.(UserPermission); found {
			return perm, nil
		} else {
			return UserPermission(0), errors.New("Invalid session permission format")
		}
	}
}

func BuildCommentsWidget(cnf Mapper, topCtx mustache.Context) (Widget, error) {
	if cnf.Layout() != "disqus" {
		return nil, errors.New("CommentsWidget Only for disqus yet")
	}
	disqus := cnf[cnf.Layout()].(map[string]interface{})
	short_name := disqus["short_name"]
	if short_name == nil {
		return nil, errors.New("CommentsWidget Of disqus need short_name")
	}
	self := make(CommentsWidget)
	self["comments"] = fmt.Sprintf(Comments_disqus, short_name)
	return self, nil
}

func BuildAnalyticsWidget(cnf Mapper, topCtx mustache.Context) (Widget, error) {
	if cnf.Layout() != "google" {
		return nil, errors.New("AnalyticsWidget Only for Goolge yet")
	}
	google := cnf[cnf.Layout()].(map[string]interface{})
	tracking_id := google["tracking_id"]
	if tracking_id == nil {
		return nil, errors.New("AnalyticsWidget Of Google need tracking_id")
	}
	self := make(AnalyticsWidget)
	self["analytics"] = fmt.Sprintf(Analytics_google, tracking_id)
	return self, nil
}

func GetSessionGMId(req *http.Request) (bson.ObjectId, error) {
	if v, err := GetGMSessionValue(req, GM_ID_SESSION_KEY); err != nil || v == nil {
		return bson.ObjectId(""), errors.New("Invalid session id format")
	} else {
		if str, found := v.(string); found {
			if bson.IsObjectIdHex(str) {
				return bson.ObjectIdHex(str), nil
			} else {
				return bson.ObjectId(""), errors.New("Invalid session id format")
			}
		} else {
			return bson.ObjectId(""), errors.New("Invalid session id format")
		}
	}
}

func parseTopic(req *http.Request) (uint, error) {
	for i, v := range TOPICS {
		if len(req.FormValue(v)) == 0 {
			continue
		}
		return uint(i), nil
	}
	return 1, errors.New("Not Found")
}

func parseSchoolGrade(req *http.Request) (string, error) {
	gradeType := req.FormValue("gradeType")
	schoolGrade := req.FormValue("schoolGrade")

	var numGrade int
	if n, _ := fmt.Sscanf(schoolGrade, "%d", &numGrade); n < 1 || numGrade < 0 {
		return "", errors.New("Invalid Grade")
	}

	return fmt.Sprintf("%[email protected]%d", gradeType, numGrade), nil
}

func SetGMSessionValue(req *http.Request, resp http.ResponseWriter, key, value interface{}) error {
	//Ignore the error since sometimes the browser side coolie storage is broken
	//But we still can assign new cookies
	s, _ := SessionStorage.Get(req, GM_AUTH_SESSION)
	if s == nil {
		return errors.New("Session " + GM_AUTH_SESSION + " not available")
	}

	s.Values[key] = value
	return s.Save(req, resp)
}

func initStorage() {
	if !Config.IsSet("storage.serviceAccountEmail") || !Config.IsSet("storage.privateKeyPath") {
		panic(errors.New("storage.serviceAccountEmail or storage.privateKeyPath not set"))
	}

	StorageServiceAccountEmail = Config.GetString("storage.serviceAccountEmail")
	//LogD.Println("Service account: " + StorageServiceAccountEmail)

	privateKeyPath := Config.GetString("storage.privateKeyPath")
	if file, err := os.Open(privateKeyPath); err != nil {
		panic(errors.New("storage.privateKeyPath not exist"))
	} else {
		defer file.Close()
		if StoragePrivateKey, err = ioutil.ReadAll(file); err != nil {
			panic(errors.New("storage.privateKeyPath read file error"))
		} else {
			//LogD.Printf("Private key length: %d\n", len(StoragePrivateKey))
		}
	}
}

// 遍历目录,加载挂件
func LoadWidgets(topCtx mustache.Context) ([]Widget, string, error) {
	widgets := make([]Widget, 0)
	assets := ""

	err := filepath.Walk("widgets", func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return nil
		}
		if !info.IsDir() {
			return nil
		}
		cnf_path := path + "/config.yml"
		fst, err := os.Stat(cnf_path)
		if err != nil || fst.IsDir() {
			return nil //ignore
		}
		cnf, err := ReadYml(cnf_path)
		if err != nil {
			return errors.New(cnf_path + ":" + err.Error())
		}
		if cnf["layout"] != nil {
			widget_enable, ok := cnf["layout"].(bool)
			if ok && !widget_enable {
				log.Println("Disable >", cnf_path)
			}
		}
		builderFunc := WidgetBuilders[info.Name()]
		if builderFunc == nil { // 看看是否符合自定义挂件的格式
			_widget, _assets, _err := BuildCustomWidget(info.Name(), path, cnf)
			if _err != nil {
				log.Println("NO WidgetBuilder >>", cnf_path, _err)
			}
			if _widget != nil {
				widgets = append(widgets, _widget)
				if _assets != nil {
					for _, asset := range _assets {
						assets += asset + "\n"
					}
				}
			}
			return nil
		}
		widget, err := builderFunc(cnf, topCtx)
		if err != nil {
			return err
		}
		widgets = append(widgets, widget)
		log.Println("Load widget from ", cnf_path)
		return nil
	})
	return widgets, assets, err
}

func GetSessionUserId(req *http.Request) (bson.ObjectId, error) {

	if data := req.Header.Get(GM_PERMITTED_HEADER_KEY); len(data) != 0 && bson.IsObjectIdHex(data) {
		//Controlled user id
		user_id := bson.ObjectIdHex(data)
		return user_id, nil
	}

	if v, err := GetUserSessionValue(req, USER_ID_SESSION_KEY); err != nil || v == nil {
		return bson.ObjectId(""), errors.New("Invalid session id format")
	} else {
		if str, found := v.(string); found {
			if bson.IsObjectIdHex(str) {
				return bson.ObjectIdHex(str), nil
			} else {
				return bson.ObjectId(""), errors.New("Invalid session id format")
			}
		} else {
			return bson.ObjectId(""), errors.New("Invalid session id format")
		}
	}
}

func parseRecommendationLetters(req *http.Request) ([]public.BasicUser, error) {
	var letters []public.BasicUser

	rawJson := req.FormValue("recommendationLetters")
	if len(rawJson) == 0 {
		return letters, errors.New("No argument")
	}

	decoder := json.NewDecoder(strings.NewReader(rawJson))
	if _, e := decoder.Token(); e != nil { //The first array bracket
		return letters, errors.New("Wrong json format")
	}

	element := public.BasicUser{}
	for decoder.More() {
		if e := decoder.Decode(&element); e != nil {
			continue
		}
		letters = append(letters, element)
	}

	decoder.Token() //The last array bracket
	return letters, nil
}

func parseStudiedClasses(req *http.Request) ([]db.StudiedClass, error) {
	var classes []db.StudiedClass

	rawJson := req.FormValue("classHistory")
	if len(rawJson) == 0 {
		return classes, errors.New("No argument")
	}

	decoder := json.NewDecoder(strings.NewReader(rawJson))
	if _, e := decoder.Token(); e != nil { //The first array bracket
		return classes, errors.New("Wrong json format")
	}

	element := db.StudiedClass{}
	for decoder.More() {
		if e := decoder.Decode(&element); e != nil {
			continue
		}
		classes = append(classes, element)
	}

	decoder.Token() //The last array bracket
	return classes, nil
}

func RenderInLayout(content string, layoutName string, layouts map[string]Mapper, ctx mustache.Context) (string, error) {
	//log.Println("Render Layout", layoutName, ">>", content, "<<END")
	ctx2 := make(map[string]string)
	ctx2["content"] = content
	layout := layouts[layoutName]
	if layout == nil {
		return "", errors.New("Not such Layout : " + layoutName)
	}
	//log.Println(layoutName, layout["_content"])
	buf := &bytes.Buffer{}
	err := layout["_content"].(*DocContent).TPL.Render(mustache.MakeContexts(ctx2, ctx), buf)
	if err != nil {
		return content, err
	}
	if layout.Layout() != "" {
		return RenderInLayout(buf.String(), layout.Layout(), layouts, ctx)
	}
	return buf.String(), nil
}

func initRecommLetter() {
	RecommLetterSubject = `NTHU A+ Recommendation Request`
	recommLetterContentTmpl := `
		Hi,
		This is NTHU A+ management team.
		{{.ApplyUser.Name}}({{.ApplyUser.Email}}) wanted to request for your recommendation in his/her application.
		If you know about this, please visit {{.RecommUrl}} to leave your recommendation.

		Best Regards,

		NTHU A+ management team
		http://www.nthuaplus.org
	`

	var err error
	RecommLetterTmpl, err = template.New("recommLetter").Parse(recommLetterContentTmpl)
	if err != nil {
		panic(errors.New("Error parsing recommendation letter template: " + err.Error()))
	}
}

func (y *yamlReader) ReadMap(minIndent int) (map[string]interface{}, error) {
	_map := map[string]interface{}{}
	//log.Println("ReadMap", minIndent)
OUT:
	for {
		line, err := y.NextLine()
		if err != nil {
			return _map, err
		}
		indent, str := getIndent(line)
		//log.Printf("Indent : %d, str = %s", indent, str)
		switch {
		case indent < minIndent:
			y.lastLine = line
			if len(_map) == 0 {
				return nil, nil
			}
			return _map, nil
		case indent == minIndent:
			key, value, err := y.asMapKeyValue(str)
			if err != nil {
				return nil, err
			}
			//log.Println("Key=", key, "value=", value)
			switch value {
			case nil:
				return nil, y.Error("Unexpect", nil)
			case MAP_KEY_ONLY:
				//log.Println("KeyOnly, read inner Map", key)

				//--------------------------------------
				_line, err := y.NextLine()
				if err != nil {
					if err == io.EOF {
						if _line == "" {
							// Emtry map item?
							_map[key.(string)] = nil
							return _map, err
						}
					} else {
						return nil, y.Error("ERR?", err)
					}
				}
				y.lastLine = _line
				_indent, _str := getIndent(_line)
				if _indent < minIndent {
					return _map, nil
				}
				////log.Println("##>>", _indent, _str)
				if _indent == minIndent {
					if _str[0] == '-' {
						//log.Println("Read Same-Indent ListItem for Map")
						_list, err := y.ReadList(minIndent)
						if _list != nil {
							_map[key.(string)] = _list
						}
						if err != nil {
							return _map, nil
						}
						continue OUT
					} else {
						// Emtry map item?
						_map[key.(string)] = nil
						continue OUT
					}
				}
				//--------------------------------------
				//log.Println("Read Map Item", _indent, _str)

				obj, err := y.ReadObject(_indent)
				if obj != nil {
					_map[key.(string)] = obj
				}
				if err != nil {
					return _map, err
				}
			default:
				_map[key.(string)] = value
			}
		default:
			//log.Println("Bad", indent, str)
			return nil, y.Error("Bad Indent\n"+line, nil)
		}
	}
	panic("ERROR")
	return nil, errors.New("Impossible")

}

func (y *yamlReader) Error(msg string, err error) error {
	if err != nil {
		return errors.New(fmt.Sprintf("line %d : %s : %v", y.lineNum, msg, err.Error()))
	}
	return errors.New(fmt.Sprintf("line %d >> %s", y.lineNum, msg))
}