// get: /user/exists/sheldon
func (uc *UserController) Exists(ctx *wk.HttpContext) (result wk.HttpResult, err error) {
	valid := true
	if name := ctx.FV("name"); name != "" {
		valid = !userRepo.Exists(name)
	}
	return wk.Data(valid), nil
}

func showQrCode(ctx *wk.HttpContext) (result wk.HttpResult, err error) {
	text := ctx.FV("text")
	if text == "" {
		err = errors.New("text is invalid")
	} else {
		result = &QrCodeResult{
			Text: text,
		}
	}
	return
}

// url: /basic/add/?int=32&str=string&uint=1024&float=1.1&byte=64
func (c *BasicController) Add(ctx *wk.HttpContext) (result wk.HttpResult, err error) {
	data := Data{
		Int:   ctx.FormIntOr("int", 0),
		Uint:  uint64(ctx.FormIntOr("uint", 0)),
		Str:   ctx.FormValue("str"),
		Float: float32(ctx.FormFloatOr("float", 0.0)),
		Byte:  byte(ctx.FormIntOr("byte", 0)),
	}
	c.data = append(c.data, data)
	return wk.Data(data.String()), nil
}

// url: /basic/rangecount/?start=1&end=99
func (c *BasicController) RangeCount(ctx *wk.HttpContext) (result wk.HttpResult, err error) {
	start := ctx.FormIntOr("start", 0)
	end := ctx.FormIntOr("end", 0)
	var count int = 0

	for _, d := range c.data {
		if d.Int >= start && d.Int <= end {
			count++
		}
	}
	return wk.Data(count), nil
}

// Execute write qrcode image to response
func (qrcode *QrCodeResult) Execute(ctx *wk.HttpContext) error {

	c, err := qr.Encode(qrcode.Text, qr.M)
	if err != nil {
		log.Println("QrCodeResult Execute Error", err)
		return err
	}
	png := c.PNG()
	//ioutil.WriteFile(qrcode.Text+"_demo.png", png, 0666)
	ctx.ContentType("image/png")
	ctx.Write(png)

	return nil
}

// url: /basic/set/32?str=s&uint=64&float=3.14&byte=8
func (c *BasicController) Set(ctx *wk.HttpContext) (result wk.HttpResult, err error) {
	var id int

	if i, ok := ctx.RouteData.Int("id"); ok {
		id = i
	} else {
		return wk.Data(0), nil
	}

	var count int = 0
	for i := 0; i < len(c.data); i++ {
		d := c.data[i]

		if d.Int != id {
			continue
		}
		if x := ctx.FormValue("str"); x != "" {
			d.Str = x
		}
		if x, ok := ctx.FormInt("uint"); ok {
			d.Uint = uint64(x)
		}
		if x, ok := ctx.FormFloat("float"); ok {
			d.Float = float32(x)
		}
		if x, ok := ctx.FormInt("byte"); ok {
			d.Byte = byte(x)
		}
		count++
	}

	return wk.Data(count), nil
}

// url: post /basic/post/
func (c *BasicController) Post(ctx *wk.HttpContext) (result wk.HttpResult, err error) {
	var body []byte
	if body, err = ctx.ReadBody(); err != nil {
		return nil, err
	}

	data := &Data{}
	err = json.Unmarshal(body, data)
	if err != nil {
		return nil, err
	}
	c.data = append(c.data, *data)
	return wk.Data(true), nil
}

// post: /user/edit/1
func (uc *UserController) EditPost(ctx *wk.HttpContext) (result wk.HttpResult, err error) {
	var id int
	if id, err = parseId(ctx); err != nil {
		return
	}

	u := User{
		Id:       id,
		Location: ctx.FV("location"),
		Gender:   ctx.FV("gender"),
		Skills:   ctx.Request.Form["skill"],
	}
	if userRepo.Update(u) {
		return wk.Redirect(fmt.Sprintf("/user/view/%d", id), false), nil
	}
	return wk.View("user/edit.html"), nil
}

func printTrace(ctx *wk.HttpContext, trace []EventTrace) {

	if len(trace) == 0 {
		return
	}

	var buffer bytes.Buffer
	indent := 0
	s := "    "
	offset := trace[0].Timestamp

	buffer.WriteString("\n")
	//buffer.WriteString(fmt.Sprintf("url:%v \n", ctx.Request.URL))
	//buffer.WriteString(strings.Repeat("-", 10))
	//buffer.WriteString("\n")

	buffer.WriteString("<script>\n")
	buffer.WriteString("var pageProfiler = \"")
	for _, t := range trace {
		if strings.HasPrefix(t.Name, "end_") && indent > 0 {
			indent--
		}

		buffer.WriteString(strings.Repeat(s, indent))
		//buffer.WriteString(fmt.Sprintf("%s\t %s\t %d \n", t.Module, t.Name, t.Timestamp-offset))
		buffer.WriteString(fmt.Sprintf("%s\t %s\t %d ns \\n", t.Module, t.Name, t.Timestamp-offset))

		if strings.HasPrefix(t.Name, "start_") {
			indent++
		}
	}
	//buffer.WriteString(strings.Repeat("-", 10))
	//buffer.WriteString("\n")
	buffer.WriteString("\";")
	buffer.WriteString("\n</script>\n")
	ctx.Write(buffer.Bytes())
}

// get/post: /user/add
func (uc *UserController) AddPost(ctx *wk.HttpContext) (result wk.HttpResult, err error) {
	id := 0
	if name := ctx.FV("name"); name == "" {
		ctx.ViewData["errmsg"] = "name is required"
	} else if name == "error" {
		ctx.ViewData["errmsg"] = "name is error"
	} else if userRepo.Exists(name) {
		ctx.ViewData["errmsg"] = "name exists"
	} else {
		u := User{
			Name:     ctx.FV("name"),
			Location: ctx.FV("location"),
			Gender:   ctx.FV("gender"),
			Skills:   ctx.Request.Form["skill"],
		}
		id = userRepo.Add(u)
	}

	if id <= 0 {
		ctx.ViewData["ctx"] = ctx
		return wk.View("user/add.html"), nil
	}
	return wk.Redirect(fmt.Sprintf("/user/view/%d", id), false), nil
}

// url: /session/remove?k=test
func (c *Session) Remove(ctx *wk.HttpContext) (wk.HttpResult, error) {
	err := ctx.Session.Remove(ctx.FV("k"))
	return wk.Data(err == nil), err
}

// url: /session/get?k=test
func (c *Session) Get(ctx *wk.HttpContext) (result wk.HttpResult, err error) {
	v, _, err := ctx.Session.Get(ctx.FV("k"))
	return wk.Data(v), err
}

// url: /session/add?k=test&v=101
func (c *Session) Add(ctx *wk.HttpContext) (wk.HttpResult, error) {
	ok, err := ctx.Session.Add(ctx.FV("k"), ctx.FV("v"))
	return wk.Data(ok), err
}

// url: /session/id
func (c *Session) Id(ctx *wk.HttpContext) (wk.HttpResult, error) {
	id := ctx.SessionId()
	return wk.Data(id), nil
}