package service

import (
	"github.com/GeeTeam/gt3-golang-sdk/geetest"
	"github.com/google/uuid"
	"github.com/linmadan/egglib-go/utils/json"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/auth/dto"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/auth/query"
	"time"

	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/log"

	"github.com/linmadan/egglib-go/core/application"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/auth/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/cache"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/service_gateway/allied_creation_user"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/service_gateway/sms_serve"
)

const (
	captchaID  = "33a2abf9c5df0d6bc3b89fb39280114b"
	privateKey = "13320fd2b10199e9a2440a4fbb4d46f7"
)

// 组织管理
type AuthService struct {
}

//AuthLogin 用户登录
func (svr AuthService) AuthLogin(loginCommand *command.LoginCommand) (interface{}, error) {
	var (
		authCode      string
		result        interface{}
		err           error
		loginPlatform string = domain.LoginPlatformApp
	)
	if loginCommand.DeviceType == domain.DeviceTypeWeb {
		loginPlatform = domain.LoginPlatformWeb
	}
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
	_, err = creationUserGateway.AuthRefreshIM(allied_creation_user.ReqAuthRefreshIM{
		Phone: loginCommand.Phone,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	switch loginCommand.GrantType {
	case domain.LoginPwd:
		authCode, err = svr.SignInPassword(loginCommand.Phone, loginCommand.Password, loginPlatform)
	case domain.LoginSmsCode:
		authCode, err = svr.SignInCaptcha(loginCommand.Phone, loginCommand.Captcha, loginPlatform)
	default:
		err = application.ThrowError(application.TRANSACTION_ERROR, "登录方式无法解析")
	}
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	result, err = svr.GetAuthAccessToken(&command.AccessTokenCommand{
		AuthCode:      authCode,
		SessionMode:   loginCommand.SessionMode,
		LoginPlatform: loginPlatform,
	})
	return map[string]interface{}{
		"access": result,
	}, err
}

//AuthLogin 用户登录
func (svr AuthService) AuthLoginPwd(loginCommand *command.LoginPwdCommand) (interface{}, error) {
	if err := loginCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	login := &command.LoginCommand{
		GrantType:   "signInPassword",
		Phone:       loginCommand.Username,
		Password:    loginCommand.Password,
		SessionMode: loginCommand.SessionMode,
		DeviceType:  loginCommand.DeviceType,
	}
	if len(loginCommand.CaptchaChallenge) > 0 {
		geetest := geetest.NewGeetestLib(captchaID, privateKey, 2*time.Second)
		validateResult := geetest.SuccessValidate(loginCommand.CaptchaChallenge, loginCommand.CaptchaValidate, loginCommand.CaptchaSeccode, "", "")
		if !validateResult {
			log.Logger.Error("validate captcha fail")
		}
	}
	return svr.AuthLogin(login)
}

//AuthLogin 用户登录
func (svr AuthService) AuthLoginSms(loginCommand *command.LoginSmsCommand) (interface{}, error) {
	if err := loginCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	login := &command.LoginCommand{
		GrantType:   "signInCaptcha",
		Phone:       loginCommand.Phone,
		Captcha:     loginCommand.Code,
		SessionMode: loginCommand.SessionMode,
		DeviceType:  loginCommand.DeviceType,
	}
	return svr.AuthLogin(login)
}

//AuthLoginQrcode 扫码登录
func (svr AuthService) AuthLoginQrcode(queryParam *query.QrcodeLoginStatusQuery) (interface{}, error) {
	qrmsg := domain.QrcodeMessage{}
	failLoginData := map[string]interface{}{
		"isLogin": false,
		"access":  struct{}{},
	}
	err := qrmsg.ParseToken(queryParam.Key)
	if err != nil {
		log.Logger.Error(err.Error())
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "二维码已失效")
	}
	qrCache := cache.LoginQrcodeCache{}
	qrmsgCache, err := qrCache.Get(qrmsg.Id)
	if err != nil {
		log.Logger.Error(err.Error())
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "二维码已失效")
	}
	if !qrmsgCache.IsLogin {
		return failLoginData, nil
	}
	loginToken := domain.LoginToken{
		UserId:     qrmsgCache.UserId,
		UserBaseId: qrmsgCache.UserBaseId,
		Account:    qrmsgCache.Account,
		Platform:   domain.LoginPlatformWeb,
		CompanyId:  qrmsgCache.CompanyId,
		OrgId:      qrmsgCache.OrgId,
	}
	accessToken, err := loginToken.GenerateAccessToken()
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	qrCache.Remove(qrmsgCache.Id)
	_ = accessToken
	result, err := svr.getToken(loginToken)
	data := map[string]interface{}{
		"isLogin": qrmsgCache.IsLogin,
		"access":  result["token"],
	}
	return data, nil
}

//AuthLoginQrcodeBind 扫码登录-绑定
func (svr AuthService) AuthLoginQrcodeBinding(bindingCmd *command.QrcodeBindingCommand) (interface{}, error) {
	qrmsg := domain.QrcodeMessage{}
	err := qrmsg.ParseToken(bindingCmd.Key)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "您扫描的二维码无效，请确认后重新扫描")
	}
	qrCache := cache.LoginQrcodeCache{}
	qrmsgCache, err := qrCache.Get(qrmsg.Id)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "您扫描的二维码无效，请确认后重新扫描")
	}
	if err := qrmsgCache.BindUser(bindingCmd.Operator); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := qrCache.Save(*qrmsgCache); err != nil {
		log.Logger.Error(err.Error())
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "登录失败,请重试")
	}
	return struct{}{}, nil
}

//SendSmsCaptcha 发送验证码短信
func (svr AuthService) SendSmsCaptcha(smsCodeCommand *command.SendSmsCodeCommand) error {
	smsServeGateway := sms_serve.NewHttplibHttplibSmsServe()
	err := smsServeGateway.SendSms(smsCodeCommand.Phone)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return nil
}

//SignInPassword 使用账号密码校验
func (svr AuthService) SignInPassword(account string, password string, loginPlatform string) (string, error) {
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
	_, err := creationUserGateway.AuthCheckPassword(allied_creation_user.ReqAuthCheckPassword{
		Password: password,
		Phone:    account,
	})
	if err != nil {
		return "", application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	loginToken := domain.LoginToken{
		UserId:    0,
		Account:   account,
		Platform:  loginPlatform,
		CompanyId: 0,
	}
	authCode, err := loginToken.GenerateAuthCode()
	if err != nil {
		return "", application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return authCode, nil
}

//SignInCaptcha 使用手机验证码登录
func (svr AuthService) SignInCaptcha(phone string, captcha string, loginPlatform string) (string, error) {
	smsServeGateway := sms_serve.NewHttplibHttplibSmsServe()
	err := smsServeGateway.CheckSmsCode(phone, captcha)
	if err != nil {
		return "", application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	loginToken := domain.LoginToken{
		UserId:    0,
		Account:   phone,
		Platform:  loginPlatform,
		CompanyId: 0,
	}
	authCode, err := loginToken.GenerateAuthCode()
	if err != nil {
		return "", application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return authCode, nil
}

//GetAuthAccessToken 获取令牌Token
func (svr AuthService) GetAuthAccessToken(accessTokenCommand *command.AccessTokenCommand) (interface{}, error) {
	if err := accessTokenCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	loginToken := &domain.LoginToken{}
	err := loginToken.ParseToken(accessTokenCommand.AuthCode)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	loginToken.Platform = accessTokenCommand.LoginPlatform
	loginToken.SessionMode = accessTokenCommand.SessionMode
	result, err := svr.getToken(*loginToken)
	return result["token"], err
}

func (svr AuthService) RefreshAuthAccessToken(refreshTokenCommand *command.RefreshTokenCommand) (interface{}, error) {
	if err := refreshTokenCommand.ValidateCommand(); err != nil {
		return nil, domain.NewApplicationError(domain.InvalidRefreshToken)
	}
	loginToken := domain.LoginToken{}
	err := loginToken.ParseToken(refreshTokenCommand.RefreshToken)
	if err != nil {
		return nil, domain.NewApplicationError(domain.InvalidRefreshToken)
	}
	//redis缓存
	tokenCache := cache.LoginTokenCache{}
	refreshToken, err := tokenCache.GetRefreshToken(loginToken.Account, loginToken.Platform)
	if err != nil {
		log.Logger.Debug(err.Error())
		return nil, domain.NewApplicationError(domain.InvalidRefreshToken)
	}
	if refreshToken != refreshTokenCommand.RefreshToken {
		return nil, domain.NewApplicationError(domain.InvalidRefreshToken)
	}

	token, err := svr.getToken(loginToken)
	if err != nil {
		return nil, domain.NewApplicationError(domain.InvalidRefreshToken)
	}
	return map[string]interface{}{
		"access": token["token"],
	}, err
}

//GetUserMenus 获取用户信息
func (svr AuthService) GetUserInfo(userInfoCommand *command.UserInfoCommand) (interface{}, error) {
	user, err := svr.getUserInfo(userInfoCommand.Operator)
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	return map[string]interface{}{
		"user": user,
	}, nil
}

//GetUserMenus 获取用户信息-额外的数据
func (svr AuthService) GetFavoriteMenus(userInfoCommand *command.UserInfoCommand) (interface{}, error) {
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(
		userInfoCommand.Operator)
	resultUser, err := creationUserGateway.UserGet(allied_creation_user.ReqGetUser{
		UserId: int(userInfoCommand.Operator.UserId),
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	return map[string]interface{}{
		"favoriteMenus": resultUser.FavoriteMenus,
	}, nil
}

//GetUserMenus 获取用户菜单
func (svr AuthService) GetUserMenus(userMenusCommand *command.UserMenusCommand) (interface{}, error) {
	if userMenusCommand.Operator.UserId == 0 {
		return map[string]interface{}{
			"accessMenus": struct{}{},
		}, nil
	}
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(
		userMenusCommand.Operator)
	resultMenu, err := creationUserGateway.UserAccessMenus(allied_creation_user.ReqUserAccessMenus{
		UserId:         int(userMenusCommand.Operator.UserId),
		MenuCategory:   userMenusCommand.MenuCategory,
		ALLDisableMenu: userMenusCommand.ALLDisableMenu,
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	return map[string]interface{}{
		"accessMenus": resultMenu.Menus,
	}, nil
}

//GetUserMenus 获取用户组织
func (svr AuthService) GetUserOrg(userOrgCommand *command.UserOrgCommand) (interface{}, error) {
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(userOrgCommand.Operator)
	result, err := creationUserGateway.UserSearch(allied_creation_user.ReqUserSearch{
		Offset:       0,
		Limit:        100,
		UserBaseId:   userOrgCommand.Operator.UserBaseId,
		UserType:     domain.UserTypeEmployee,
		EnableStatus: domain.UserStatusEnable,
		PullRealTime: true,
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	var res = make([]interface{}, 0)
	for i := range result.Users {
		for j := range result.Users[i].UserOrg {
			org := result.Users[i].UserOrg[j]
			res = append(res, map[string]interface{}{
				"orgId":   org.OrgID,
				"orgName": org.OrgName,
			})
		}
	}
	return map[string]interface{}{
		"orgs": res,
	}, nil
}

//OrgSwitch 组织切换
func (svr AuthService) OrgSwitch(switchOrgCommand *command.SwitchOrgCommand) (interface{}, error) {
	if err := switchOrgCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	loginToken := domain.LoginToken{}
	err := loginToken.ParseToken(switchOrgCommand.Operator.Token)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "accessToken 不可用，"+err.Error())
	}
	loginToken.OrgId = switchOrgCommand.OrgId
	token, err := svr.getToken(loginToken)
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	var userId int64
	if v, ok := token["userId"]; ok {
		if vInt, ok := v.(int); !ok || vInt == 0 {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, "用户不存在")
		} else {
			userId = int64(vInt)
		}
	}
	user, err := svr.getUserInfo(domain.Operator{UserId: userId, OrgId: loginToken.OrgId})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(
		switchOrgCommand.Operator)
	resultMenu, err := creationUserGateway.UserAccessMenus(allied_creation_user.ReqUserAccessMenus{
		UserId: int(userId),
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	var res = map[string]interface{}{
		"user":        user,
		"accessMenus": resultMenu.Menus,
		"access":      token["token"],
	}
	return res, nil
}

// CompanySignUp 企业注册
func (svr AuthService) CompanySignUp(companySignUpCommand *command.CompanySignUpCommand) (interface{}, error) {
	smsServeGateway := sms_serve.NewHttplibHttplibSmsServe()
	err := smsServeGateway.CheckSmsCode(companySignUpCommand.Phone, companySignUpCommand.SmsCode)
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
	_, err = creationUserGateway.AuthCompanySignUp(allied_creation_user.ReqAuthCompanySignUp{
		CompanyName:      companySignUpCommand.CompanyName,
		Phone:            companySignUpCommand.Phone,
		Password:         companySignUpCommand.Password,
		Contacts:         companySignUpCommand.Contacts,
		IndustryCategory: companySignUpCommand.IndustryCategory,
		Scale:            companySignUpCommand.Scale,
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	return companySignUpCommand, err
}

// ResetPassword  重置密码（找回密码）
func (svr AuthService) ResetPassword(resetPasswordCommand *command.ResetPasswordCommand) (interface{}, error) {
	if err := resetPasswordCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	var phone = resetPasswordCommand.Phone
	if len(resetPasswordCommand.SmsCode) > 0 {
		smsServeGateway := sms_serve.NewHttplibHttplibSmsServe()
		err := smsServeGateway.CheckSmsCode(resetPasswordCommand.Phone, resetPasswordCommand.SmsCode)
		if err != nil {
			return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
		}
	} else {
		pcc := cache.PhoneCheckCache{}
		var item = &cache.PhoneCheckItem{}
		if err := pcc.Get(resetPasswordCommand.SmsCodeIdentity, item); err != nil {
			log.Logger.Error(err.Error())
			return nil, application.ThrowError(application.BUSINESS_ERROR, "验证码已失效")
		}
		phone = item.Phone
	}

	// 2.重置密码
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
	result, err := creationUserGateway.AuthResetPassword(allied_creation_user.ReqAuthResetPassword{
		Phone:    phone,
		Password: resetPasswordCommand.Password,
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	return result, err
}

func (svr AuthService) getUserInfo(operator domain.Operator) (interface{}, error) {
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(
		operator)

	// 个人用户登录
	if operator.UserId == 0 && len(operator.Phone) != 0 {
		resultUser, err := creationUserGateway.AuthUserBaseInfo(allied_creation_user.ReqAuthUserBase{
			Account: operator.Phone,
		})
		if err != nil {
			return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
		}
		var user = map[string]interface{}{
			"userId": 0,
			//"userOpenId": fmt.Sprintf("%v",resultUser.UserBaseID),
			"userInfo": map[string]interface{}{
				"userName":   resultUser.UserInfo.UserName,
				"userPhone":  resultUser.UserInfo.Phone,
				"userAvatar": resultUser.UserInfo.Avatar,
				"email":      resultUser.UserInfo.Email,
			},
			"department": struct{}{},
			"company":    map[string]interface{}{},
			"im":         resultUser.Im,
			"org":        struct{}{},
		}
		return user, nil
	}
	// 企业用户登录
	resultUser, err := creationUserGateway.UserGet(allied_creation_user.ReqGetUser{
		UserId: int(operator.UserId),
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	resultOrg, err := creationUserGateway.OrgGet(allied_creation_user.ReqOrgGet{
		OrgId: int(operator.OrgId),
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	var user = map[string]interface{}{
		"userId": resultUser.UserId,
		//"userOpenId": fmt.Sprintf("%v",resultUser.UserBaseId),
		"userInfo": map[string]interface{}{
			"userName":   resultUser.UserInfo.UserName,
			"userPhone":  resultUser.UserInfo.Phone,
			"userAvatar": resultUser.UserInfo.Avatar,
			"userCode":   resultUser.UserInfo.UserCode,
			"email":      resultUser.UserInfo.Email,
		},
		"department": resultUser.Department,
		"company": map[string]interface{}{
			"companyId":   resultUser.Company.CompanyId,
			"companyName": resultUser.Company.CompanyName,
			"logo":        resultUser.Company.Log,
			"systemName":  resultUser.Company.SystemName,
			"address":     resultUser.Company.Address,
		},
		"im": resultUser.IM,
		"org": map[string]interface{}{
			"orgId":     resultOrg.OrgID,
			"orgName":   resultOrg.OrgName,
			"orgCode":   resultOrg.OrgCode,
			"companyId": resultOrg.CompanyID,
		},
		//"currentLoginOrg": resultUser.Org,
		"favoriteMenus": resultUser.FavoriteMenus,
	}
	return user, nil
}

func (svr AuthService) getToken(loginToken domain.LoginToken) (map[string]interface{}, error) {
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
	userSearchResult, err := creationUserGateway.UserSearch(allied_creation_user.ReqUserSearch{
		Phone:        loginToken.Account,
		UserType:     domain.UserTypeEmployee,
		EnableStatus: domain.UserStatusEnable,
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "用户信息获取失败，"+err.Error())
	}
	// 1 . 判定当前凭证的companyId，OrganizationId 是否在用户列表中
	var currentOrgIsOK bool
	var currentUser allied_creation_user.UserDetail
loopUser1:
	for _, v := range userSearchResult.Users {
		for _, vv := range v.UserOrg {
			if vv.OrgID == int(loginToken.OrgId) {
				currentOrgIsOK = true
				currentUser = v
				break loopUser1
			}
		}
	}
	if !currentOrgIsOK {
	loopUser2:
		for _, v := range userSearchResult.Users {
			for _, vv := range v.UserOrg {
				loginToken.OrgId = int64(vv.OrgID)
				currentOrgIsOK = true
				currentUser = v
				break loopUser2
			}
		}
	}
	if !currentOrgIsOK && loginToken.Platform == domain.LoginPlatformWeb {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "登录的公司组织不可用")
	}
	if currentOrgIsOK {
		loginToken.UserId = int64(currentUser.UserId)
		loginToken.UserBaseId = int64(currentUser.UserBaseId)
		loginToken.CompanyId = int64(currentUser.Company.CompanyId)
		var orgIds []int64
		for i := range currentUser.UserOrg {
			orgIds = append(orgIds, int64(currentUser.UserOrg[i].OrgID))
		}
		loginToken.OrgIds = orgIds
	}

	// 个人登录
	if len(userSearchResult.Users) == 0 {
		userBase, err := creationUserGateway.AuthUserBaseInfo(allied_creation_user.ReqAuthUserBase{
			Account: loginToken.Account,
		})
		if err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, "账号不存在")
		}
		loginToken.UserBaseId = int64(userBase.UserBaseID)
	}

	// 2. 更新currentAccess信息
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	var loginAccessRepository domain.LoginAccessRepository
	if loginAccessRepository, err = factory.CreateLoginAccessRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	_, lAccess, err := loginAccessRepository.Find(map[string]interface{}{
		"account":  loginToken.Account,
		"platform": loginToken.Platform,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	var currentAccess = &domain.LoginAccess{CreatedTime: time.Now()}
	if len(lAccess) > 0 {
		currentAccess = lAccess[0]
	}
	currentAccess.UserId = int64(loginToken.UserId)
	currentAccess.UserBaseId = int64(loginToken.UserBaseId)
	currentAccess.Account = loginToken.Account
	currentAccess.Platform = loginToken.Platform
	currentAccess.CompanyId = int64(loginToken.CompanyId)
	currentAccess.OrganizationId = loginToken.OrgId
	currentAccess.OrgIds = loginToken.OrgIds
	currentAccess.UpdatedTime = time.Now()

	accessTokenStr, err := loginToken.GenerateAccessToken()
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	currentAccess.AccessToken = accessTokenStr
	currentAccess.AccessExpired = loginToken.ExpiresAt
	refreshTokenStr, err := loginToken.GenerateRefreshToken()
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	currentAccess.RefreshToken = refreshTokenStr
	currentAccess.RefreshExpired = loginToken.ExpiresAt

	//存数据库
	_, err = loginAccessRepository.Save(currentAccess)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}

	//redis缓存
	tokenCache := cache.LoginTokenCache{}

	//todo:error handler
	if err = tokenCache.SaveAccessToken(currentAccess); err != nil {
		return nil, err
	}
	if err = tokenCache.SaveRefreshToken(currentAccess); err != nil {
		return nil, err
	}
	nowTime := time.Now().Unix()
	token := map[string]interface{}{
		"refreshToken": refreshTokenStr,
		"accessToken":  accessTokenStr,
		"expiresIn":    currentAccess.AccessExpired - nowTime,
	}
	return map[string]interface{}{
		"token":  token,
		"userId": currentUser.UserId,
	}, nil
}

//GetCompanyOrgsByUser 获取登录用户的公司组织列表
func (svr AuthService) GetCompanyOrgsByUser(queryParam *query.GetCompanyOrgsByUserQuery) (interface{}, error) {
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(queryParam.Operator)
	result, err := creationUserGateway.UserSearch(allied_creation_user.ReqUserSearch{
		Phone:        queryParam.Operator.Phone,
		UserType:     domain.UserTypeEmployee,
		PullRealTime: true,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	var (
		companys []dto.CompanyItem
		orgs     []dto.OrgItem
	)

	for _, v := range result.Users {
		companys = append(companys, dto.CompanyItem{
			CompanyId:   v.Company.CompanyId,
			CompanyName: v.Company.CompanyName,
		})
		for _, vv := range v.UserOrg {
			orgs = append(orgs, dto.OrgItem{
				OrganizationId:   vv.OrgID,
				OrganizationName: vv.OrgName,
				CompanyId:        v.Company.CompanyId,
			})
		}
	}

	data := map[string]interface{}{
		"companys":      companys,
		"organizations": orgs,
	}
	return data, nil
}

//GetQrcode 获取扫码登录需要的二维码
func (svr AuthService) GetQrcode() (interface{}, error) {
	qrmsg := domain.QrcodeMessage{}
	_, err := qrmsg.GenerateImageBase64() //imgBase64
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	qrCache := cache.LoginQrcodeCache{}
	err = qrCache.Save(qrmsg)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	data := map[string]interface{}{
		//"image": imgBase64,
		"key": qrmsg.Token,
	}
	return data, nil
}

//CheckSmsCode 验证手机短信验证码
func (svr AuthService) CheckSmsCode(smsCodeCommand *command.CheckSmsCodeCommand) (interface{}, error) {
	smsServeGateway := sms_serve.NewHttplibHttplibSmsServe()
	err := smsServeGateway.CheckSmsCode(smsCodeCommand.Phone, smsCodeCommand.SmsCode)
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	uid := uuid.New()
	pcc := cache.PhoneCheckCache{}
	if err := pcc.Add(uid.String(), cache.PhoneCheckItem{
		Phone:           smsCodeCommand.Phone,
		SmsCodeIdentity: uid.String(),
		Action:          smsCodeCommand.Action,
	}); err != nil {
		log.Logger.Error(err.Error())
		return nil, application.ThrowError(application.BUSINESS_ERROR, "系统错误")
	}
	return map[string]interface{}{
		"smsCodeIdentity": uid.String(),
	}, nil
}

func (svr *AuthService) CaptchaInit(request *query.CaptchaInitRequest) (interface{}, error) {
	var rsp map[string]interface{}
	var err error

	lib := geetest.NewGeetestLib(captchaID, privateKey, 2*time.Second)
	status, responseBt := lib.PreProcess("", request.UserIp)
	var geetestRsp geetest.FailbackRegisterRespnse
	json.Unmarshal(responseBt, &geetestRsp)
	rspData := map[string]interface{}{
		"success":    geetestRsp.Success,
		"gt":         geetestRsp.GT,
		"challenge":  geetestRsp.Challenge,
		"newCaptcha": geetestRsp.NewCaptcha,
	}
	if status == 0 {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "获取图形验证码失败,请重试")
	}

	rsp = rspData
	return rsp, err
}