func Register(app *iris.Application) {
  app.Get("/{path:path}", controller.ReRouteContext)
}

func ReRouteContext(ctx iris.Context) {
	params, _ := parseRoute(ctx)
	// 先驗證文件是否真的存在，如果存在，則fileServe
	exists := FileServe(ctx)
	if exists {
		return
	}
	
	for i, v := range params {
		if len(i) == 0 {
			continue
		}
		ctx.Params().Set(i, v)
		if i == "page" && v > "0" {
			ctx.Values().Set("page", v)
		}
	}

	switch params["match"] {
	case "notfound":
		// 走到 not Found
		break
	case "archive":
		ArchiveDetail(ctx)
		return
		return
	case "category":
		CategoryPage(ctx)
		return
	case "index":
		IndexPage(ctx)
		return
		return
	}

	//如果沒有合適的路由，則報錯
	NotFound(ctx)
}

// FileServe 靜態(tài)文件處理，靜態(tài)文件存放在public目錄中，因此訪問路徑為/public/xxx
func FileServe(ctx iris.Context) bool {
	uri := ctx.RequestPath(false)
	if uri != "/" && !strings.HasSuffix(uri, "/") {
		baseDir := fmt.Sprintf("%spublic", RootPath)
		uriFile := baseDir + uri
		_, err := os.Stat(uriFile)
		if err == nil {
			ctx.ServeFile(uriFile)
			return true
		}
	}
	
	return false
}

// parseRoute 正則表達(dá)式解析路由 
func parseRoute(ctx iris.Context) (map[string]string, bool) {
	//這里總共有2條正則規(guī)則，需要逐一匹配
	// 由于用戶可能會采用相同的配置，因此這里需要嘗試多次讀取
	matchMap := map[string]string{}
	paramValue := ctx.Params().Get("path")
	// index
	if paramValue == "" {
		matchMap["match"] = "index"
		return matchMap, true
	}
	// 靜態(tài)資源直接返回
	if strings.HasPrefix(paramValue, "uploads/") ||
		strings.HasPrefix(paramValue, "static/") {
		return matchMap, true
	}
	rewritePattern := service.ParsePatten(false)
	//category
	reg = regexp.MustCompile(rewritePattern.CategoryRule)
	match = reg.FindStringSubmatch(paramValue)
	if len(match) > 1 {
		matchMap["match"] = "category"
		for i, v := range match {
			key := rewritePattern.CategoryTags[i]
			if i == 0 {
				key = "route"
			}
			matchMap[key] = v
		}
		if matchMap["catname"] != "" {
			matchMap["filename"] = matchMap["catname"]
		}
		if matchMap["multicatname"] != "" {
			chunkCatNames := strings.Split(matchMap["multicatname"], "/")
			matchMap["filename"] = chunkCatNames[len(chunkCatNames)-1]
		}
		if matchMap["module"] != "" {
			// 需要先驗證是否是module
			module := service.GetModuleFromCacheByToken(matchMap["module"])
			if module != nil {
				if matchMap["filename"] != "" {
					// 這個規(guī)則可能與下面的沖突，因此檢查一遍
					category := service.GetCategoryFromCacheByToken(matchMap["filename"])
					if category != nil {
						return matchMap, true
					}
				} else {
					return matchMap, true
				}
			}
		} else {
			if matchMap["filename"] != "" {
				// 這個規(guī)則可能與下面的沖突，因此檢查一遍
				category := service.GetCategoryFromCacheByToken(matchMap["filename"])
				if category != nil {
					return matchMap, true
				}
			} else {
				return matchMap, true
			}
		}
		matchMap = map[string]string{}
	}
	//最后archive
	reg = regexp.MustCompile(rewritePattern.ArchiveRule)
	match = reg.FindStringSubmatch(paramValue)
	if len(match) > 1 {
		matchMap["match"] = "archive"
		for i, v := range match {
			key := rewritePattern.ArchiveTags[i]
			if i == 0 {
				key = "route"
			}
			matchMap[key] = v
		}
		if matchMap["module"] != "" {
			// 需要先驗證是否是module
			module := service.GetModuleFromCacheByToken(matchMap["module"])
			if module != nil {
				return matchMap, true
			}
		} else {
			return matchMap, true
		}
	}

	//不存在，定義到notfound
	matchMap["match"] = "notfound"
	return matchMap, true
}

type RewritePatten struct {
	Archive      string `json:"archive"`
	Category     string `json:"category"`

	ArchiveRule      string
	CategoryRule     string

	ArchiveTags      map[int]string
	CategoryTags     map[int]string
	Parsed bool
}


type replaceChar struct {
	Key   string
	Value string
}

var needReplace = []replaceChar{
	{Key: "/", Value: "\\/"},
	{Key: "*", Value: "\\*"},
	{Key: "+", Value: "\\+"},
	{Key: "?", Value: "\\?"},
	{Key: ".", Value: "\\."},
	{Key: "-", Value: "\\-"},
	{Key: "[", Value: "\\["},
	{Key: "]", Value: "\\]"},
	{Key: ")", Value: ")?"}, //fix?  map無序，可能會出現(xiàn)?混亂
}

var replaceParams = map[string]string{
	"{id}":           "([\\d]+)",
	"{filename}":     "([^\\/]+?)",
	"{catname}":      "([^\\/]+?)",
	"{multicatname}": "(.+?)",
	"{module}":       "([^\\/]+?)",
	"{catid}":        "([\\d]+)",
	"{year}":         "([\\d]{4})",
	"{month}":        "([\\d]{2})",
	"{day}":          "([\\d]{2})",
	"{hour}":         "([\\d]{2})",
	"{minute}":       "([\\d]{2})",
	"{second}":       "([\\d]{2})",
	"{page}":         "([\\d]+)",
}

var parsedPatten *RewritePatten

func GetRewritePatten(focus bool) *RewritePatten {
	if parsedPatten != nil && !focus {
		return parsedPatten
	}
	
  parsedPatten = parseRewritePatten(PluginRewrite.Patten)

	return parsedPatten
}

// parseRewritePatten 才需要解析
// 一共2行,分別是文章詳情、分類,===和前面部分不可修改。
// 變量由花括號包裹{},如{id}?？捎玫淖兞坑?數(shù)據(jù)ID {id}、數(shù)據(jù)自定義鏈接名 {filename}、分類自定義鏈接名 {catname}、分類ID {catid},分頁ID {page}，分頁需要使用()處理，用來首頁忽略。如：(/{page})或(_{page})
func parseRewritePatten(patten string) *RewritePatten {
	parsedPatten := &RewritePatten{}
	// 再解開
	pattenSlice := strings.Split(patten, "\n")
	for _, v := range pattenSlice {
		singlePatten := strings.Split(v, "===")
		if len(singlePatten) == 2 {
			val := strings.TrimSpace(singlePatten[1])

			switch strings.TrimSpace(singlePatten[0]) {
			case "archive":
				parsedPatten.Archive = val
			case "category":
				parsedPatten.Category = val
			}
		}
	}
	
	return parsedPatten
}

var mu sync.Mutex

func ParsePatten(focus bool) *RewritePatten {
	mu.Lock()
	defer mu.Unlock()
	GetRewritePatten(focus)
	if parsedPatten.Parsed {
		return parsedPatten
	}

	parsedPatten.ArchiveTags = map[int]string{}
	parsedPatten.CategoryTags = map[int]string{}

	pattens := map[string]string{
		"archive":      parsedPatten.Archive,
		"category":     parsedPatten.Category,
	}

	for key, item := range pattens {
		n := 0
		str := ""
		for _, v := range item {
			if v == '{' {
				n++
				str += string(v)
			} else if v == '}' {
				str = strings.TrimLeft(str, "{")
				if str == "page" {
					//page+1
					n++
				}
				switch key {
				case "archive":
					parsedPatten.ArchiveTags[n] = str
				case "category":
					parsedPatten.CategoryTags[n] = str
				}
				//重置
				str = ""
			} else if str != "" {
				str += string(v)
			}
		}
	}

	//移除首個 /
	parsedPatten.ArchiveRule = strings.TrimLeft(parsedPatten.Archive, "/")
	parsedPatten.CategoryRule = strings.TrimLeft(parsedPatten.Category, "/")

	for _, r := range needReplace {
		if strings.Contains(parsedPatten.ArchiveRule, r.Key) {
			parsedPatten.ArchiveRule = strings.ReplaceAll(parsedPatten.ArchiveRule, r.Key, r.Value)
		}
		if strings.Contains(parsedPatten.CategoryRule, r.Key) {
			parsedPatten.CategoryRule = strings.ReplaceAll(parsedPatten.CategoryRule, r.Key, r.Value)
		}
	}

	for s, r := range replaceParams {
		if strings.Contains(parsedPatten.ArchiveRule, s) {
			parsedPatten.ArchiveRule = strings.ReplaceAll(parsedPatten.ArchiveRule, s, r)
		}
		if strings.Contains(parsedPatten.CategoryRule, s) {
			parsedPatten.CategoryRule = strings.ReplaceAll(parsedPatten.CategoryRule, s, r)
		}
	}
	//修改為強制包裹
	parsedPatten.ArchiveRule = fmt.Sprintf("^%s$", parsedPatten.ArchiveRule)
	parsedPatten.CategoryRule = fmt.Sprintf("^%s$", parsedPatten.CategoryRule)
	parsedPatten.PageRule = fmt.Sprintf("^%s$", parsedPatten.PageRule)
	parsedPatten.ArchiveIndexRule = fmt.Sprintf("^%s$", parsedPatten.ArchiveIndexRule)
	parsedPatten.TagIndexRule = fmt.Sprintf("^%s$", parsedPatten.TagIndexRule)
	parsedPatten.TagRule = fmt.Sprintf("^%s$", parsedPatten.TagRule)

	//標(biāo)記替換過
  parsedPatten.Parsed = true

	return parsedPatten
}