package main

import (
	"encoding/json"
	"flag"
	"net/http"

	pb "git.esin.io/lab/weixin/protobuf/clientapi/mp/auth"
	"google.golang.org/grpc"
)

var (
	lisPort            string
	authServerEndpoint string
)

func init() {
	flag.StringVar(&lisPort, "port", "3000", "server listen port")
	flag.StringVar(&authServerEndpoint, "auth.server", "localhost:13721", "auth grpc server endpoint")
}

func main() {
	flag.Parse()

	if err := run(); err != nil {
		panic(err)
	}
}

func run() error {
	grpcDialOpts := []grpc.DialOption{
		grpc.WithInsecure(),
		grpc.WithBlock(),
	}
	grpcConn, err := grpc.Dial(authServerEndpoint, grpcDialOpts...)
	if err != nil {
		return err
	}

	h := NewHandler(pb.NewAuthServiceClient(grpcConn))

	http.HandleFunc("/url", h.getCodeURL)
	http.HandleFunc("/token", h.exchangeToken)
	http.HandleFunc("/userinfo", h.getUserinfo)
	http.HandleFunc("/userinfo/sync", h.syncUserinfo)

	return http.ListenAndServe(":"+lisPort, nil)
}

type restHandler struct {
	client pb.AuthServiceClient
}

func NewHandler(client pb.AuthServiceClient) *restHandler {
	return &restHandler{
		client: client,
	}
}

func (h restHandler) getCodeURL(w http.ResponseWriter, r *http.Request) {
	resp, err := h.client.GetCodeURL(r.Context(), &pb.GetCodeURLRequest{
		RedirectUrl: r.FormValue("redirect_url"),
		State:       r.FormValue("state"),
		Scope:       pb.GetCodeURLRequest_snsapi_base,
	})
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	encoder := json.NewEncoder(w)
	encoder.SetEscapeHTML(false)
	encoder.Encode(resp)
}

func (h restHandler) exchangeToken(w http.ResponseWriter, r *http.Request) {
	code := r.FormValue("code")

	resp, err := h.client.ExchangeToken(r.Context(), &pb.ExchangeTokenRequest{
		Code: code,
	})
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	json.NewEncoder(w).Encode(resp)
}

func (h restHandler) getUserinfo(w http.ResponseWriter, r *http.Request) {
	openid := r.FormValue("openid")
	resp, err := h.client.GetUserinfo(r.Context(), &pb.GetUserinfoRequest{
		OpenId: openid,
		Lang:   pb.GetUserinfoRequest_zh_CN,
	})
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	json.NewEncoder(w).Encode(resp)
}

func (h restHandler) syncUserinfo(w http.ResponseWriter, r *http.Request) {
	openid := r.FormValue("openid")
	resp, err := h.client.SyncUserinfo(r.Context(), &pb.SyncUserinfoRequest{
		OpenId: openid,
		Lang:   pb.SyncUserinfoRequest_zh_CN,
	})
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	json.NewEncoder(w).Encode(resp)
}