package service

import (
	"aps_crm/conf"
	"aps_crm/constvar"
	"aps_crm/model"
	"aps_crm/pkg/ecode"
	"aps_crm/pkg/encrypt"
	"aps_crm/pkg/logx"
	"aps_crm/proto/user"
	"context"
	"errors"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"gorm.io/gorm"
	"time"
)

type UserService struct{}

func (userService *UserService) Login(u *model.User) (userInter *model.User, errCode int) {
	userInter, err := model.NewUserSearch(nil).SetUserName(u.Username).First()
	if err != nil {
		return nil, ecode.UserNotExist
	}

	if ok := encrypt.BcryptCheck(u.Password, userInter.Password); !ok {
		return nil, ecode.PasswordErr
	}

	return userInter, ecode.OK
}

func (userService *UserService) Register(u *model.User) (userInter *model.User, errCode int) {
	_, err := model.NewUserSearch(nil).SetUserName(u.Username).First()
	if err != gorm.ErrRecordNotFound {
		return userInter, ecode.UserNameExistErr
	}

	err = model.NewUserSearch(nil).Create(u)
	return u, ecode.OK
}

func (userService *UserService) ChangePassword(u *model.User, newPassword string) (userInter *model.User, errCode int) {
	user, err := model.NewUserSearch(nil).SetId(u.UUID).First()
	if err != nil {
		return nil, ecode.UserNotExist
	}

	if ok := encrypt.BcryptCheck(u.Password, user.Password); !ok {
		return nil, ecode.PasswordErr
	}

	user.Password = encrypt.BcryptHash(newPassword)
	err = model.NewUserSearch(nil).SetId(u.UUID).UpdateByMap(map[string]interface{}{
		"password": user.Password})

	return user, ecode.OK

}

func (userService *UserService) DeleteUser(id string) (err error) {
	user, err := model.NewUserSearch(nil).SetId(id).First()
	if err != nil {
		return err
	}

	if user.UserType != constvar.UserTypeSub {
		return errors.New("该用户非子账户，无法删除")
	}

	err = model.NewUserSearch(nil).SetId(id).Delete()
	if err != nil {
		return err
	}

	return model.NewUserMenuSearch(nil).SetUserId(id).Delete()
}

func (userService *UserService) SetUserInfo(req model.User) error {
	return model.NewUserSearch(nil).SetId(req.UUID).UpdateByMap(map[string]interface{}{
		"nick_name":  req.NickName,
		"header_img": req.HeaderImg,
		"phone":      req.Phone,
		"email":      req.Email,
		"pos":        req.Pos,
	})
}

func (userService *UserService) GetUserInfo(id string) (user *model.User, err error) {
	return model.NewUserSearch(nil).SetId(id).First()
}

func (userService *UserService) ResetPassword(id string) (err error) {
	return model.NewUserSearch(nil).SetId(id).UpdateByMap(map[string]interface{}{
		"password": encrypt.BcryptHash("123456"),
	})
}

func (userService *UserService) GetUserList() (userList []*model.User, err error) {
	return model.NewUserSearch(nil).FindAll()
}

var (
	userConn *grpc.ClientConn
)

func InitUserConn() {
	var err error
	userConn, err = grpc.Dial(conf.Conf.GrpcServiceAddr.Admin, grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		logx.Errorf("grpc dial user service error: %v", err.Error())
		return
	}
}

func CloseUserConn() {
	if userConn != nil {
		userConn.Close()
	}
}

func SyncUserInfo() {
	cli := user.NewUserServiceClient(userConn)

	var users []*user.User

	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	r, err := cli.SyncUser(ctx, &user.UserRequest{Users: users})
	if err != nil {
		logx.Fatalf("could not sync users: %v", err)
	}

	fmt.Printf("Synced: %v, Message: %s", r.List, r.Message)

	for _, member := range r.List {
		err = model.NewUserSearch(nil).FirstOrCreate(model.User{
			UUID:     member.Uuid,
			Username: member.Username,
			UserType: constvar.UserType(member.Usertype),
			NickName: member.Nickname,
		})
		if err != nil {
			logx.Errorf("sync user error: %v", err.Error())
			continue
		}
	}
}