package common

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"time"

	"dashoo.cn/common_definition/admin/user_def"
	"dashoo.cn/common_definition/auth"
	"dashoo.cn/micro_libary/micro_srv"
	"dashoo.cn/micro_libary/request"
	"github.com/gogf/gf/encoding/gjson"
)

func TestRpcxHandler(tenant, token, url, path, method string, data string) ([]byte, error) {
	req, err := http.NewRequest("POST", url, bytes.NewBuffer([]byte(data)))
	if err != nil {
		return nil, err
	}
	req.Header.Set("content-type", "application/json")
	req.Header.Set("X-RPCX-SerializeType", "1")
	req.Header.Set("X-RPCX-ServicePath", path)
	req.Header.Set("X-RPCX-ServiceMethod", method)
	req.Header.Set("SrvEnv", "dev")
	req.Header.Set("Tenant", tenant)
	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
	// req.Header.Set("X-RPCX-Meta", fmt.Sprintf("ts=%s&sign=%s", ts, sign))

	cli := &http.Client{Timeout: 5 * time.Second}
	resp, err := cli.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	return ioutil.ReadAll(resp.Body)
}

func TestHandler(tenant, token, url, data string) ([]byte, error) {
	req, err := http.NewRequest("POST", url, bytes.NewBuffer([]byte(data)))
	if err != nil {
		return nil, err
	}
	req.Header.Set("content-type", "application/json")
	req.Header.Set("Tenant", tenant)
	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))

	cli := &http.Client{Timeout: 5 * time.Second}
	resp, err := cli.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	return ioutil.ReadAll(resp.Body)
}

func Token(tenant, username, password string) string {
	userService := micro_srv.InitMicroSrvClient("User", "micro_srv.admin")
	authService := micro_srv.InitMicroSrvClient("Auth", "micro_srv.auth")
	defer userService.Close()
	defer authService.Close()

	rsp := &user_def.LoginResp{}
	err := userService.Call(context.TODO(), "Login", &user_def.LoginReq{
		Tenant:    tenant,
		User:      username,
		Password:  password,
		Ip:        "",
		UserAgent: "",
	}, rsp)
	if err != nil {
		panic(err)
	}

	authrsp := &auth.Response{}
	err = authService.Call(context.TODO(), "GetToken", &auth.Request{
		Tenant:  tenant,
		UserKey: username,
		Uuid:    rsp.CommonMsg.Data.(string),
		Data:    string(rsp.UserInfo),
	}, authrsp)
	if err != nil {
		panic(err)
	}

	j, err := gjson.DecodeToJson(authrsp.Data)
	if err != nil {
		panic(err)
	}

	// fmt.Printf("%#v\n", rsp.CommonMsg)
	// fmt.Printf("%#v\n", string(rsp.UserInfo))
	// fmt.Printf("%#v\n", authrsp)
	return j.GetString("token")
}

func PrintIndentJson(data []byte) {
	var v interface{}
	err := json.Unmarshal(data, &v)
	if err != nil {
		panic(err)
	}
	data, err = json.MarshalIndent(v, "", "  ")
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data))
}

func Auth(tenant string, userId int32, uuid, username, realname, deptId string) (interface{}, error) {
	authService := micro_srv.InitMicroSrvClient("Auth", "micro_srv.auth")
	defer authService.Close()
	authUserinfo := request.UserInfo{
		Id:       userId,
		Uuid:     uuid,
		UserName: username,
		RealName: realname,
		DeptId:   deptId,
	}
	authUserinfoData, err := json.Marshal(authUserinfo)
	if err != nil {
		return nil, err
	}
	authrsp := &auth.Response{}
	err = authService.Call(context.TODO(), "GetToken", &auth.Request{
		Tenant:  tenant,
		UserKey: username,
		Uuid:    uuid,
		Data:    string(authUserinfoData),
	}, authrsp)
	if err != nil {
		return nil, err
	}
	data := map[string]interface{}{}
	// authrsp.Data  "{\"tenant\":\"EmGVD5szuT\",\"token\":\"ajg7o1Dts1JrKCm6VtgyuuaYbUIiirXxI5+6WzYnC7gWl+43NdKq6LbWxU1zWhsBaL0A/CIkBoefM0vuu6h4ZA==\",\"userKey\":\"dashoo\",\"uuid\":\"095771e03f6fbd20af351dc259560232\"}"
	err = json.Unmarshal([]byte(authrsp.Data), &data)
	return data, err
}