package main
import (
	"net/http"
	"html/template"
	"xxx/httprouter" // 为啥用它？因为虽然是渲染页面，但本质上还是一个request到后台，后台接受之后处理再返回给前台。
					 // 只不过，在web UI部分,我们大部分返回的都是整个的html页面，而非json的消息或文件流。所以整个的原理是一样的。
)

func RegisterHandler() *httprouter.Router {
	router := httprouter.New()


	router.GET("/", homeHandler) // 主页
	router.POST("/", homeHandler) // POST是提交表单过程中跳转的下一个页面
	
	router.GET("/userhome", userHomeHandler) // 用户页
	router.POST("/", userHomeHandler)


	router.POST("/api", apiHandler) // api转发类请求
	
	//	file server: 放静态文件的server
	//	golang提供原生方法将url绑到文件夹作为file server。可以直接通过url引它
	//	如下，我们的template文件夹，会挂到/statics/这个url下
	router.ServeFiles("/statics/*filepath", http.Dir("./template")) 

	return router	
}

func main() {
	r := RegisterHandler()
	http.ListenAndServe(":8080", r)
}

<a href="#news">{{.Name}}</a> // .Name就是模板里需要替换掉的东西

package main

//	替换到模板上的传入结构体
type HomePage struct {
	Name string // 需要和模板中一一对应
}

func homeHandler(w http.ResponseWriter, r*http.Request, ps httprouter.Router) {
	p := &HomePage{Name: "azen"}
	t, e := template.ParseFile("./template/home.html") // 工程中的相对/绝对路径问题
	if e != nil {
		log.Printf("Parsing 模板出错:%s", e)
		return
	}

	t.Execute(w, p)
	return
}

#! /bin/bash

#Build web UI
cd $GOPATH/src/xxxxxx/video_server/web
go install
cp $GOPATH/bin/web $GOPATH/bin/video_server_web_ui/web
cp -R $GOPATH/src/xxxxx/video_server/templates $GOPATH/bin/video_server_web_ui

#起服务
cd $GOPATH/bin/video_server_web_ui
./web

func homeHandler(w http.ResponseWriter, r *http.Request, ...) {
...
	cname, err1 := r.Cookie("username")
	sid, err1 := r.Cookie("session")

	if err1 != nil || err2 != nil {
		// 返回登录/注册页面
	}

	if len(cname.Value) != 0 && len(sid.Value) != 0 { // 非生产环境的，减少了判断。生产：判断存在、判断用户匹配
		http.Redirect(w, r, "/userhome", http.StatusFound) // 302
		// 楼上的url，是相对url，不带host的
	}
...
}

func UserPage struct {
	Name string
}

func userHomeHandler(w http.ResponseWriter, r*http.Request, ps httprouter.Router) {
	//	判断cookie里有木有session和username
	//	和上面一样就不写了
	//	如果xxx重定向到"/"
	
	fname := r.FormValue("username") // 这里直接读表单里的username，此处不判断用户是否合法
									 // 检查是否合法会放到客户端提交表单的时候，通过调api来判断是否合法，提交过来的都是合法的
									 // 原因：减少web server的逻辑处理能力，在处理能力上做到解耦，利于服务化解耦的理念和工程实践
									 //	写「前后端分离」的时候，尽量把和「业务」相关的内容放到后端 - api service
									 //「业务相关」不大的逻辑判断和填充，放到大前端的web service里面
	
	var p *UserPage
	if len(cname.Value) != 0 {
		p = &UserPage{Name: cname.Value} // 已登录，就直接拿cookie里的cname
	} else if len(fname) != 0 {
		p = &UserPage{Name: fname} // 没登录，从表单提交的里面读
	}

	t, e := template.ParseFiles("./templates/userhome.html")
	if e != nil {
		log.Printf("Parsing userhome.html error: &s", e)
		return
	}

	e.Excute(w, p)
}

type ApiBody struct {
	Url string `json:"url"` // 必有
	Method string `json: "method"`  // 必有
	ReqBody string `json: "req_body"`  // POST请求必有
}

...

func apiHandler(w http.ResponseWriter, r*http.Request, ps httprouter.Router) {
	if r.Method != http.MethodPost {  // 一定要是POST请求才符合我们的规范，否则抛错
		re, _ := json.Marshal(ErrorRequestNotRecognized) // 返回一个异常
		io.WriteString(w, string(re))
		return
	}

	res, _ := ioutil.ReadAll(r.Body)
	apibody := &ApiBody{}
	if err := json.Unmarshal(res, apibody); err != nil {
		re, _ := json.Marshal(ErrorRequestBodyParseFailed) // 返回一个异常
		io.WriteString(w, string(re))
		return
	}

	//	真正处理Request
	request(apibody, w, r)
	derfer r.Body.Close() // 为了安全而Close - Request在退完之前可能会留在栈里
}

var httpClient *http.httpClient

func init() {
	httpClient = &http.Client{}
}

func request(b *ApiBody, w http.ResponseWriter, r*http.Request) {
	var resp *http.Response
	var err error

	// 分别处理GET、POST、DELETE
	switch b.Method {
	case http.MethodGet:
		req, _ := http.NewRequest("GET", b.Url, nil) // method, url, body-get为nil
		req.Header = r.Header
		resp, err = httpClient.Do(req)
		if err != nil {
			log.Printf(err)
			return
		}
		normalResponse(w, resp)

	case http.MethodPost:
		req, _ := http.NewRequest("POST", b.Url, bytes.NewBuffer([]byte(b.ReqBody))) // method, url, body-get为nil
		req.Header = r.Header
		resp, err = httpClient.Do(req)
		if err != nil {
			log.Printf(err)
			return
		}

		normalResponse(w, resp)

	case http.MethodDelete:
		req, _ := http.NewRequest("Delete", b.Url, nil) // method, url, body-get为nil
		req.Header = r.Header
		resp, err = httpClient.Do(req)
		if err != nil {
			log.Printf(err)
			return
		}

		normalResponse(w, resp)

	default:
		w.WriteHeader(http.StatusBadRequest)
		io.WriteString(w, "Bad api request")
	}
}


func normalResponse(w http.ResponseWriter, r*http.Response) { // r用来写入真的response
	res, err := ioutil.ReadAll(r.Body)
	if err != nil {
		re, _ := json.Marshal(ErrorInternalFaluts)
		w.WriteHeader(500)
		io.WriteString(w, string(re))
		return
	}


	w.WriterHeader(r.StatusCode)
	io.WriteString(w, string(res))
}

// web-server端
router.POST("upload/:vid-id", proxyHandler)

func proxyHandler(w http.ResponseWriter, r*http.Request, ps httprouter.Router) {
	// url parse出来
	u, _ := url.Parse("http://127.0.0.1:9000/") // 这个生产环境应该写到可下发的配置里面，而不是hard code.
	proxy := httputil.NewSingleHostReverseProxy(u)
	proxy.ServeHTTP(w, r)
}