package im

import (
	"context"
	"sportfitness/base/global"
	im "sportfitness/base/repository/grpc/bsw/im/im"

	"google.golang.org/grpc/status"

	"git.beswell.com/gframe/application"
	"google.golang.org/grpc/metadata"
)

func handleErr(err error) {
	if err == nil {
		return
	}
	s, _ := status.FromError(err)

	panic(application.ErrorBusinessF(application.ErrorCode(s.Code()), s.Message()))
}

func getClient() im.ApiClient {
	conn, err := application.GetServiceGrpcConn("bsw/im")
	if err != nil {
		panic(err)
	}
	client := im.NewApiClient(conn)

	return client
}

func ctx() context.Context {
	md := metadata.Pairs("sys_token", global.SysToken)
	return metadata.NewOutgoingContext(context.Background(), md)
}

func SignUpUserCode(params *im.SignUpRequest) (userId int64) {
	r, err := getClient().SignUpUserCode(ctx(), params)

	handleErr(err)
	userId = r.GetId()
	return
}

func GenVerifyImage(height, width int32) (id, imageBase64 string) {
	r, err := getClient().GenVerifyImage(ctx(), &im.GenVerifyImageRequest{
		Height: int32(height),
		Width:  int32(width),
	})
	handleErr(err)

	id = r.CodeId
	imageBase64 = r.ImageBase64
	return
}

func SignInUserCodePassword(userCode, password, ip, ClientInfo, codeId, verifyCode string) (token string, userId int) {
	r, err := getClient().SignInUserCode(ctx(), &im.SignInPasswordRequest{
		Credential:    userCode,
		Password:      password,
		ExpirationSec: global.TokenExpireSec,
		Ip:            ip,
		ClientInfo:    ClientInfo,
		CodeId:        codeId,
		VerifyCode:    verifyCode,
	})
	handleErr(err)
	token = r.Token
	userId = int(r.UserId)

	return
}

func RegisterServiceList(servicePathList []string) {
	request := &im.SaveServiceListRequest{}

	for _, p := range servicePathList {
		request.List = append(request.List, &im.Service{
			Path: p,
			Memo: "自动添加",
		})
	}

	_, err := getClient().SubServiceSaveList(ctx(), request)
	if err != nil {
		panic(err)
	}
}

func SignOut(token string) {
	request := &im.TokenParam{Token: token}

	_, err := getClient().SubSignOut(ctx(), request)
	handleErr(err)
}

func SubSessionCheck(token string) int64 {
	request := &im.TokenParam{Token: token}

	rs, err := getClient().SubSessionCheck(ctx(), request)
	handleErr(err)
	return rs.UserId
}

func SubPermissionListCheck(token string, shopId int64, servicePathList []string) *im.PermissionCheckReply {

	rs, err := getClient().SubPermissionListCheck(ctx(), &im.PermissionCheck{
		Token:           token,
		ShopId:          shopId,
		ServicePathList: servicePathList,
	})
	handleErr(err)
	return rs
}

func ShopListRequest(name string, status im.Status, sId int64) *im.ShopListReply {

	request := &im.ShopListRequest{SysId: 0, Name: name, Status: status, SId: sId}

	rs, err := getClient().ShopList(ctx(), request)
	handleErr(err)
	return rs
}

// ShopDetail 查询商家信息
func ShopDetail(shopId int64) *im.ShopInfo {
	request := &im.ShopDetailRequest{ShopId: shopId}

	rs, err := getClient().ShopDetail(ctx(), request)
	handleErr(err)
	return rs
}

// ShopLicenseList 商户许可列表
func ShopLicenseList(shopId int64) *im.LicenseList {
	request := &im.ShopDetailRequest{ShopId: shopId}

	rs, err := getClient().ShopLicenseList(ctx(), request)

	handleErr(err)
	return rs
}

// LicenseTypeMap 许可类型字典
func LicenseTypeMap(idList []int64) *im.LicenseTypeMapReply {
	request := &im.IdList{IdList: idList}

	rs, err := getClient().LicenseTypeMap(ctx(), request)

	handleErr(err)
	return rs
}

func GetShopNavi(userId, shopId int64, parentId int64, status im.Status) *im.UserGetColumnListReply {

	request := &im.UserGetColumnListRequest{UserId: userId, ShopId: shopId, ParentId: parentId, Status: status}

	rs, err := getClient().UserGetColumnList(ctx(), request)
	handleErr(err)
	return rs
}

func ManageableSimpleQuery(shopId int64, status im.Status) *im.UserListReply {

	request := &im.UserListRequest{ShopId: shopId, Status: status}

	rs, err := getClient().UserList(ctx(), request)
	handleErr(err)
	return rs
}

// RoleList 通过userId查询用户权限
func RoleList(userId, sysId int64) *im.RoleListReply {

	request := &im.RoleListRequest{UserId: userId, SysId: sysId}

	rs, err := getClient().RoleList(ctx(), request)
	handleErr(err)
	return rs
}