package member

import (
	"fmt"
	"time"

	"git.loafle.net/overflow/overflow_server_app/backend"

	"git.loafle.net/overflow/overflow_server_app/server"

	"encoding/json"
	"log"

	jwt "github.com/dgrijalva/jwt-go"
	"github.com/valyala/fasthttp"
)

var ofSigningKey = []byte("secret")

func SignIn(sctx *server.ServerContext, ctx *fasthttp.RequestCtx) {
	grpcPool := sctx.Value("grpc").(backend.Pool)
	fmt.Fprintf(ctx, "avail: %d\n", grpcPool.Available())
	c, err := grpcPool.Get()
	if nil != err {

	}
	defer c.Close()

	fmt.Fprintf(ctx, "avail: %d\n", grpcPool.Available())

	//signinId := string(ctx.FormValue("signinId"))
	//signinPw := string(ctx.FormValue("signinPw"))

	var webParams []interface{}
	webBytes := ctx.PostBody()
	err = json.Unmarshal(webBytes, &webParams)

	if err != nil {
		fmt.Fprintf(ctx, "Err!!!!: %s\n", err)
	}

	length := len(webParams)

	if length < 0 {
		fmt.Println("eeee")
	}

	jsonMap := webParams[0].(map[string]interface{})
	signinId := jsonMap["signinId"].(string)
	signinPw := jsonMap["signinPw"].(string)

	params := []string{signinId, signinPw}

	r, err := c.Exec("MemberService", "signin", params)
	if nil != err {
		fmt.Fprintf(ctx, "%v", err)
		return
	}

	token := jwt.New(jwt.SigningMethodRS256)

	/* Create a map to store our claims */
	claims := token.Claims.(jwt.MapClaims)

	/* Set token claims */

	claims["uid"] = signinId
	claims["exp"] = time.Now().Add(time.Hour * 24).Unix()

	/* Sign the token with our secret */
	tokenString, _ := token.SignedString(ofSigningKey)

	var jwtCookie fasthttp.Cookie
	jwtCookie.SetKey("AuthToken")
	jwtCookie.SetValue(tokenString)
	ctx.Response.Header.SetCookie(&jwtCookie)

	//fmt.Fprintf(ctx, "Welcome!!!!: %s\n", r)
	ctx.SetContentType("application/javascript")
	log.Printf("M:%s", r)
	ctx.SetBody([]byte(r))

}