func checkTimer(cmd *exec.Cmd, comp *Compile, id int) {
	for {
		// if building process hava exit normally, exit timer
		if BuildProcessHaveExit {
			log.Blueln("Building Process Exit Normally.")
			return
		}

		stn := time.Now()
		now := stn.UnixNano()
		// over 10s
		if now-BuildStartTime > 10*1000000000 {
			comp.buildOverTime = true
			log.Warnln("Building Out of Time, Terminated!")
			cmd.Process.Kill()

			systemTag := com.SubString(runtime.GOOS, 0, 5)
			if systemTag == "linux" {
				// ps -ef|grep cc1|grep 5.c|awk '{print $2}'|xargs kill -9
				cleanScript := fmt.Sprintf("ps -ef|grep cc1|grep %d.c|awk '{print $2}'|xargs kill -9", id)
				cleanCmd := exec.Command("sh",
					"-c",
					cleanScript,
				)
				err := cleanCmd.Run()
				if err != nil {
					log.Warnln("clean orphan failed")
				}
			}
			return
		}
	}
}

// run before get
func (this *AdminBaseController) Prepare() {
	// login status
	user := this.GetSession("username")
	if user == nil {
		this.Redirect("/login", 302)
	} else {
		// find user id
		username := user.(string)
		u, err := models.FindUser(username)
		if err != nil {
			log.Warnln(err)
		} else {
			userLog := &models.UserLog{}

			// get ip
			ipPort := this.Ctx.Request.Header.Get("X-Forwarded-For")
			ipPortArr := strings.Split(ipPort, ":")
			ip := ipPortArr[0]

			// get location
			location := ""
			userLogIp, err := userLog.GetUserLogByIp(ip)
			if err == nil {
				locationData, err := com.JsonDecode(userLog.Location)
				if err == nil {
					locationJson := locationData.(map[string]interface{})
					if userLog.IsValidLocation(locationJson) {
						location = userLogIp.Location
					} else {
						location, _ = utils.GetLocation(ip)
					}
				} else {
					location, _ = utils.GetLocation(ip)
				}

			} else {
				location, _ = utils.GetLocation(ip)
			}

			// get user agent
			ua := this.Ctx.Request.UserAgent()

			// save data
			_, err = userLog.AddUserlog(int64(u.Id), ip, ua, location, 0)
			if err != nil {
				log.Warnln(err)
			}
		}
	}

	this.Data["isAdmin"] = true
	this.Data["inDev"] = beego.AppConfig.String("runmode") == "dev"
}

func InitCron() {
	if beego.AppConfig.String("runmode") == "prod" {
		tk := toolbox.NewTask("statistic", "0 0 * * * *", githubStat)
		err := tk.Run()
		if err != nil {
			log.Warnln("[Run Task Failed]")
			log.Warnln(err)
		}
		toolbox.AddTask("statistic", tk)
		toolbox.StartTask()
		defer toolbox.StopTask()
	}
}

func InitCron() {
	tk := toolbox.NewTask("judger", "0/30 * * * * *", task.CheckJudger)

	if beego.AppConfig.String("runmode") == "dev" {
		err := tk.Run()
		if err != nil {
			log.Warnln("[Run Task Failed]")
			log.Warnln(err)
		}
	}

	toolbox.AddTask("judger", tk)
	toolbox.StartTask()
}

// get top 10 problem
func (this *Problem) GetTop10() ([]orm.Params, error) {
	sql := `SELECT problem.id as id, problem.title as title, count(*) AS count FROM submissions,problem where submissions.pid=problem.id GROUP BY pid ORDER BY count DESC limit 10`

	var maps []orm.Params
	o := orm.NewOrm()
	_, err := o.Raw(sql).Values(&maps)
	if err != nil {
		log.Warnln("execute sql error:")
		log.Warnln(err)
		return nil, err
	} else {
		return maps, err
	}
}

func HandleJsonRpc(w http.ResponseWriter, r *http.Request) {
	// get request content
	p := make([]byte, r.ContentLength)
	r.Body.Read(p)

	content := string(p)

	log.Blueln(content)

	json, err := com.JsonDecode(content)

	if err != nil {
		log.Warnln("not json-rpc format")
		return
	}

	data := json.(map[string]interface{})

	// get system password
	password := C.Get("", "password")

	// parse received password
	passwordRecv, ok := data["password"].(string)
	if !ok {
		result, _ := com.JsonEncode(map[string]interface{}{
			"result": false, //bool, login result
			"msg":    "invalid password, password must be string.",
		})
		io.WriteString(w, result)
		return
	}

	// compare password
	if password != passwordRecv {
		result, _ := com.JsonEncode(map[string]interface{}{
			"result": false, //bool, login failed
		})
		io.WriteString(w, result)
		return
	}

	// trigger controller
	ctrl, exists := RouterMap[data["action"].(string)]
	if !exists {
		log.Warnln("not exist")
		return
	}
	ctrl.Http(data, w, r)
}

// List Tags
func (this *Tags) TagList() ([]orm.Params, error) {
	sql := "select * from tags order by time desc"

	var maps []orm.Params
	o := orm.NewOrm()
	_, err := o.Raw(sql).Values(&maps)
	if err != nil {
		log.Warnln("execute sql error:")
		log.Warnln(err)
		return nil, err
	} else {
		return maps, err
	}

}

// call gcc compiler in other os
func (this *Compile) gcc(id int) error {
	os.Chdir(this.itemBuildPath)

	var cmd *exec.Cmd

	log.Pinkln("cmd", "/K",
		this.compiler_c,
		this.codeFilePath,
		this.itemBuildPath,
	)

	if runtime.GOOS == "windows" {
		cmd = exec.Command("cmd", "/K",
			this.compiler_c,
			this.codeFilePath,
			this.itemBuildPath,
		)
	} else {
		cmd = exec.Command("sh",
			this.compiler_c,
			this.codeFilePath,
			this.itemBuildPath,
		)
	}

	err := cmd.Start()
	if err != nil {
		log.Warnln("Start Failed")
		log.Warnln(err)
	}

	stn := time.Now()
	BuildStartTime = stn.UnixNano()
	go checkTimer(cmd, this, id)
	BuildProcessHaveExit = false

	err = cmd.Wait()
	BuildProcessHaveExit = true

	if err != nil {
		log.Warnln("Wait Failed")
		log.Warnln(err)
	}

	os.Chdir(this.currentPath)

	return err
}

func GetCache(key string, to interface{}) error {
	if cc == nil {
		return errors.New("cc is nil")
	}

	defer func() {
		if r := recover(); r != nil {
			log.Redf("get cache error caught: %v\n", r)
			cc = nil
		}
	}()

	data := cc.Get(key)
	if data == nil {
		return errors.New("Cache不存在")
	}
	// log.Pinkln(data)
	err := Decode(data.([]byte), to)
	if err != nil {
		log.Warnln("获取Cache失败", key, err)
	} else {
		log.Greenln("获取Cache成功", key)
	}

	return err
}

// start the session
func (this *JClient) Start(ip string, port int, password string) error {
	// not login, first time
	this.login = false

	// default # to get the real sep
	this.mark = "#"
	addr := fmt.Sprintf("%s:%d", ip, port)
	conn, err := net.Dial("tcp", addr)
	if err != nil {
		if conn != nil {
			conn.Close()
		}

		log.Warnln("connect judge server failed in port:", port)

		return err
	} else {
		this.conn = conn
		this.connected = true
		content, err := this.read()
		if err != nil {
			return err
		}

		// get seperater mark
		reg := regexp.MustCompile(`/[\d\D]+$`)
		if arr := reg.FindAllString(content, -1); len(arr) > 0 {
			this.mark = com.SubString(arr[0], 1, 1)
		}

		log.Blueln(content)
	}

	// login
	loginRequest := map[string]interface{}{
		"action":   "login",
		"password": password,
	}

	response, err := this.Request(loginRequest)
	if err != nil {
		return err
	}

	result, ok := response["result"].(bool)
	if !result || !ok {
		return errors.New("login failed.")
	}

	sid, ok := response["sid"].(string)
	if ok {
		this.sid = sid
	} else {
		this.sid = ""
	}

	this.login = true

	return err
}

func SetCache(key string, value interface{}, timeout int64) error {
	data, err := Encode(value)
	if err != nil {
		return err
	}
	if cc == nil {
		return errors.New("cc is nil")
	}

	defer func() {
		if r := recover(); r != nil {
			log.Redf("set cache error caught: %v\n", r)
			cc = nil
		}
	}()

	err = cc.Put(key, data, timeout)
	if err != nil {
		log.Warnln("Cache失败，key:", key)
		return err
	} else {
		log.Blueln("Cache成功，key:", key)
		return nil
	}
}

func (this *AddArticleController) Post() {
	title := this.GetString("title")
	content := this.GetString("content")
	keywords := this.GetString("keywords")
	abstract := this.GetString("abstract")

	// if not login, permission deny
	user := this.GetSession("username")
	if user == nil {
		this.Data["json"] = map[string]interface{}{"result": false, "msg": "login first please", "refer": nil}
		this.ServeJson()
		return
	}

	if "" == title {
		this.Data["json"] = map[string]interface{}{"result": false, "msg": "title can not be empty", "refer": "/"}
		this.ServeJson()
		return
	}

	username := user.(string)

	id, err := AddArticle(title, content, keywords, abstract, username)
	if nil == err {
		this.Data["json"] = map[string]interface{}{"result": true, "msg": "success added, id " + fmt.Sprintf("[%d] ", id), "refer": nil}
	} else {
		log.Warnln(err)
		this.Data["json"] = map[string]interface{}{"result": false, "msg": "added failed", "refer": nil}
	}
	this.ServeJson()
}

func (this *Compile) Run(code string, language string, id int, sid string) (string, error) {

	err := this.createDirs(id, sid)
	if err != nil {
		log.Warnln(err)
		return "", err
	} else {
		err = this.writeCode(code, id, language)
		if err != nil {
			log.Warnln(err)
			return "", err
		}
	}

	return this.itemBuildPath, this.gcc(id)

}

// get avatar
func (this *User) GetAvatar(id int, username string, email string, nickname string) (string, error) {
	user, err := this.GetUser(id, username, email, nickname)
	if nil == err {
		return beego.AppConfig.String("avatar") + com.Md5(user.Email), err
	} else {
		log.Warnln("GetAvatar Failed.", err)
		return "", err
	}
}

func Get(name string) *client.JClient {
	jdg, ok := J[name].(*client.JClient)
	if !ok {
		log.Warnln("get failed")
		return nil
	}

	return jdg
}

func CheckJudger() error {
	jdg := judger.Get("default")
	err := jdg.Ping()
	if err != nil {
		log.Warnln("reconnecting")
		reconnect()
	}

	return nil
}

func Judger() {
	parseArg()

	dataPath := "data.db"

	if Mode == "docker" {
		log.Blueln("[mode]", "docker")

		if !com.FileExist("/data") {
			if err := com.Mkdir("/data"); err != nil {
				log.Warnln("[Warn]", "create dir /data failed")
			} else {
				log.Blueln("[info]", "create dir /data")
			}
		}

		if !com.FileExist("/data/config_docker.ini") {
			com.CopyFile("/data/config_docker.ini", "conf/config_docker.ini")
		}

		if !com.FileExist("/data/executer.json") {
			com.CopyFile("/data/executer.json", "sandbox/c/build/executer.json")
		}

		dataPath = "/data/data.db"
	}

	if configFile == "" {
		configFile = "conf/config.ini"
	}

	if !com.FileExist(configFile) {
		log.Dangerln("[Error]", configFile, "does not exist!")
		os.Exit(-1)
	}

	log.Blueln("[config]")
	log.Blueln(configFile)

	C = &Config{}
	C.NewConfig(configFile)

	GenScript()

	log.Blueln("[data]")
	log.Blueln(dataPath)
	DB = &Sqlite{}
	DB.NewSqlite(dataPath)

	createBuildDir()

	go TcpStart()
	HttpStart()
}

func HttpStart() {

	http.HandleFunc("/", HandleJsonRpc)

	err := http.ListenAndServe(":1005", nil)
	if err != nil {
		log.Warnln("ListenAndServe: ", err)
	} else {
		log.Blueln("Http Server Started!")
	}
}

func (this *Submissions) GetSubmissionStatus(id int) (string, error) {

	jdg := judger.Get("default")
	response, err := jdg.GetStatus(int64(id))

	if err != nil {
		log.Warnln("send Request failed:", err)
	}

	info := response["info"].(map[string]interface{})

	o := orm.NewOrm()
	var subm Submissions
	subm.Id = id
	err = o.Read(&subm, "Id")

	if err != nil {
		log.Warnf("记录[%d]不存在\n", id)
		return "", err
	} else {

		status := info["run_result"].(string)

		if status == "PEN" {
			subm.Status = "AC"
		} else if status == "PRE" {
			subm.Status = "RE"
		} else if status == "POM" {
			subm.Status = "MLE"
		} else if status == "POT" {
			subm.Status = "TLE"
		} else if status == "POL" {
			subm.Status = "OLE"
		} else if status == "PSF" {
			subm.Status = "PSF"
		} else if status == "EC" {
			subm.Status = "CE"
		} else {
			subm.Status = "UK"
		}

		subm.BuildLog = info["build_log"].(string)
		exe_debug, ok := info["executer_debug"].(string)
		if ok {
			subm.ExecuterDebug = exe_debug
		}
		o.Update(&subm)

		return subm.Status, err
	}
}

// send request
func (this *JClient) Request(msg map[string]interface{}) (map[string]interface{}, error) {
	msgStr, err := com.JsonEncode(msg)

	if err != nil {
		return nil, err
	}

	if this.conn == nil {
		log.Warnln("Connection Not Exist")
		return nil, errors.New("Connection Not Exist")
	}

	_, err = this.conn.Write([]byte(msgStr + this.mark))
	if err != nil {
		log.Warnln("[Write Error]", err)
		this.conn.Close()
		return nil, err
	}

	content, err := this.read()

	if err != nil {
		return nil, err
	}

	// kick sep char
	reg := regexp.MustCompile(this.mark)
	content = reg.ReplaceAllString(content, "")

	if this.debug {
		log.Bluef("[judger/send:%s]\n%s\n", time.Now(), msgStr)
		log.Warnf("[judger/recv:%s]\n%s\n", time.Now(), content)
	}

	resp, err := com.JsonDecode(content)

	return resp.(map[string]interface{}), err
}