package service

import (
	"errors"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/log"
	"time"

	"github.com/linmadan/egglib-go/core/application"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/mobile/auth/command"
	"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"
)

// 组织管理
type AuthService struct {
}

//AuthLogin 用户登录
func (srv AuthService) AuthLogin(loginCommand *command.LoginCommand) (interface{}, error) {
	var (
		result interface{}
		err    error
	)
	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, "系统错误")
	}
	switch loginCommand.GrantType {
	case "signInPassword":
		result, err = srv.SignInPassword(loginCommand.Phone, loginCommand.Password)
	case "signInCaptcha":
		result, err = srv.SignInCaptcha(loginCommand.Phone, loginCommand.Captcha)
	default:
		err = errors.New("登录方式无法解析")
	}
	return result, err
}

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

//SignInCaptcha 使用手机验证码登录
func (srv AuthService) SignInCaptcha(phone string, captcha string) (interface{}, error) {
	smsServeGateway := sms_serve.NewHttplibHttplibSmsServe()
	err := smsServeGateway.CheckSmsCode(phone, captcha)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	ltoken := domain.LoginToken{
		UserId:    0,
		Account:   phone,
		Platform:  domain.LoginPlatformApp,
		CompanyId: 0,
	}
	authcode, err := ltoken.GenerateAuthCode()
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	result := map[string]string{
		"authCode": authcode,
	}
	return result, nil
}

//GetAuthAccessToken 获取令牌Token
func (srv AuthService) GetAuthAccessToken(accessTokenCommand *command.AccessTokenCommand) (interface{}, error) {
	if err := accessTokenCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	ltoken := &domain.LoginToken{}
	err := ltoken.ParseToken(accessTokenCommand.AuthCode)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	phone := ltoken.Account
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
	userSeachResult, err := creationUserGateway.UserSearch(allied_creation_user.ReqUserSearch{
		CompanyId: ltoken.CompanyId,
		Phone:     phone,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if len(userSeachResult.Users) == 0 {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取用户信息失败")
	}
	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.INTERNAL_SERVER_ERROR, err.Error())
	}
	_, lAccess, err := loginAccessRepository.Find(map[string]interface{}{
		"account":  phone,
		"platform": domain.LoginPlatformApp,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	var currentAccess *domain.LoginAccess
	if len(lAccess) > 0 {
		currentAccess = lAccess[0]
		currentAccess.UpdatedTime = time.Now()
	} else {
		currentAccess = &domain.LoginAccess{
			UserBaseId: int64(userSeachResult.Users[0].UserBaseId),
			UserId:     int64(userSeachResult.Users[0].UserId),
			Account:    userSeachResult.Users[0].UserInfo.Phone,
			Platform:   domain.LoginPlatformApp,
			//CompanyId:      int64(userSeachResult.Users[0].Company.CompanyId),
			OrganizationId: int64(userSeachResult.Users[0].Org.OrgId),
			AccessToken:    "",
			RefreshToken:   "",
			AccessExpired:  0,
			RefreshExpired: 0,
			CreatedTime:    time.Now(),
			UpdatedTime:    time.Now(),
		}
		if userSeachResult.Users[0].Company != nil {
			currentAccess.CompanyId = int64(userSeachResult.Users[0].Company.CompanyId)
		}
	}
	//判定当前凭证的companyId，OrganizationId 是否在用户列表中
	var currentOrgIsOK bool
loopUser1:
	for _, v := range userSeachResult.Users {
		if v.Company.CompanyId == int(currentAccess.CompanyId) {
			for _, vv := range v.UserOrg {
				if vv.OrgID == int(currentAccess.OrganizationId) {
					currentOrgIsOK = true
					break loopUser1
				}
			}
		}
	}
	//记录上一次的登录公司组织信息不可用 ，重置登录记录
	//使用找到的第一个可用的公司组织
	if !currentOrgIsOK {
	loopUser2:
		for _, v := range userSeachResult.Users {
			currentAccess.CompanyId = int64(v.Company.CompanyId)
			for _, vv := range v.UserOrg {
				currentAccess.OrganizationId = int64(vv.OrgID)
				currentOrgIsOK = true
				break loopUser2
			}
		}
	}

	loginToken := domain.LoginToken{
		UserId:    currentAccess.UserId,
		Account:   currentAccess.Account,
		CompanyId: currentAccess.CompanyId,
		OrgId:     currentAccess.OrganizationId,
		Platform:  currentAccess.Platform,
	}

	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.TRANSACTION_ERROR, err.Error())
	}
	currentAccess.RefreshToken = refreshTokenStr
	currentAccess.AccessExpired = 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.TRANSACTION_ERROR, err.Error())
	}
	//后处理redis缓存
	tokenCache := cache.LoginTokenCache{}
	tokenCache.RemoveAccessToken(currentAccess.Account, domain.LoginPlatformApp)
	tokenCache.RemoveRefreshToken(currentAccess.Account, domain.LoginPlatformApp)
	tokenCache.SaveAccessToken(currentAccess)
	tokenCache.SaveRefreshToken(currentAccess)
	nowTime := time.Now().Unix()
	return map[string]interface{}{
		"refreshToken": accessTokenStr,
		"accessToken":  refreshTokenStr,
		"expiresIn":    currentAccess.AccessExpired - nowTime,
	}, nil
}

func (srv AuthService) RefreshAuthAccessToken(refreshTokenCommand *command.RefreshTokenCommand) (interface{}, error) {
	if err := refreshTokenCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	ltoken := domain.LoginToken{}
	err := ltoken.ParseToken(refreshTokenCommand.RefreshToken)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "refreshToken 不可用，"+err.Error())
	}
	token, err := srv.getToken(domain.Operator{}, ltoken)
	//	phone := ltoken.Account
	//	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
	//	userSearchResult, err := creationUserGateway.UserSearch(allied_creation_user.ReqUserSearch{
	//		Phone: phone,
	//	})
	//	if err != nil {
	//		return nil, application.ThrowError(application.TRANSACTION_ERROR, "用户信息获取失败，"+err.Error())
	//	}
	//	//判定当前凭证的companyId，OrganizationId 是否在用户列表中
	//	var currentOrgIsOK bool
	//loopUser1:
	//	for _, v := range userSearchResult.Users {
	//		if v.Company.CompanyId == int(ltoken.CompanyId) {
	//			for _, vv := range v.UserOrg {
	//				if vv.OrgID == int(ltoken.OrgId) {
	//					currentOrgIsOK = true
	//					break loopUser1
	//				}
	//			}
	//		}
	//	}
	//	if !currentOrgIsOK {
	//		return nil, application.ThrowError(application.TRANSACTION_ERROR, "登录的公司组织不可用")
	//	}
	//
	//	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.INTERNAL_SERVER_ERROR, err.Error())
	//	}
	//	_, lAccess, err := loginAccessRepository.Find(map[string]interface{}{
	//		"account":  phone,
	//		"platform": domain.LoginPlatformApp,
	//	})
	//	if err != nil {
	//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	//	}
	//	var currentAccess *domain.LoginAccess
	//	if len(lAccess) > 0 {
	//		currentAccess = lAccess[0]
	//		currentAccess.UpdatedTime = time.Now()
	//	} else {
	//		currentAccess = &domain.LoginAccess{
	//			UserBaseId:     ltoken.UserBaseId,
	//			UserId:         ltoken.UserId,
	//			Account:        ltoken.Account,
	//			Platform:       domain.LoginPlatformApp,
	//			CompanyId:      ltoken.CompanyId,
	//			OrganizationId: ltoken.OrgId,
	//			AccessToken:    "",
	//			RefreshToken:   "",
	//			AccessExpired:  0,
	//			RefreshExpired: 0,
	//			CreatedTime:    time.Now(),
	//			UpdatedTime:    time.Now(),
	//		}
	//	}
	//	accessTokenStr, err := ltoken.GenerateAccessToken()
	//	if err != nil {
	//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	//	}
	//	currentAccess.AccessToken = accessTokenStr
	//	currentAccess.AccessExpired = ltoken.ExpiresAt
	//	refreshTokenStr, err := ltoken.GenerateRefreshToken()
	//	if err != nil {
	//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	//	}
	//	currentAccess.RefreshToken = refreshTokenStr
	//	currentAccess.RefreshExpired = ltoken.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.TRANSACTION_ERROR, err.Error())
	//	}
	//	//后处理redis缓存
	//	tokenCache := cache.LoginTokenCache{}
	//	tokenCache.RemoveAccessToken(currentAccess.Account, domain.LoginPlatformApp)
	//	tokenCache.RemoveRefreshToken(currentAccess.Account, domain.LoginPlatformApp)
	//	tokenCache.SaveAccessToken(currentAccess)
	//	tokenCache.SaveRefreshToken(currentAccess)
	//	nowTime := time.Now().Unix()
	//	return map[string]interface{}{
	//		"refreshToken": accessTokenStr,
	//		"accessToken":  refreshTokenStr,
	//		"expiresIn":    currentAccess.AccessExpired - nowTime,
	//	}, nil
	return token, err
}

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

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

//GetUserMenus 获取用户组织
func (srv 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 res, nil
}

//OrgSwitch 组织切换
func (srv AuthService) OrgSwitch(switchOrgCommand *command.SwitchOrgCommand) (interface{}, error) {

	return nil, nil
}

// CompanySignUp 企业注册
func (srv AuthService) CompanySignUp(companySignUpCommand *command.CompanySignUpCommand) (interface{}, error) {
	//TODO:验证码验证测试去掉，后期恢复回来
	//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{})
	result, 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 result, err
}

// ResetPassword  重置密码（找回密码）
func (srv AuthService) ResetPassword(resetPasswordCommand *command.ResetPasswordCommand) (interface{}, error) {
	if err := resetPasswordCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	//var phone string
	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, "验证码已失效")
	}
	// 2.重置密码
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
	result, err := creationUserGateway.AuthResetPassword(allied_creation_user.ReqAuthResetPassword{
		Phone:    item.Phone,
		Password: resetPasswordCommand.Password,
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	return result, err
}

func (srv AuthService) getUserInfo(operator domain.Operator) (interface{}, error) {
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(
		operator)
	resultUser, err := creationUserGateway.UserGet(allied_creation_user.ReqGetUser{
		UserId: int(operator.UserId),
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	var user = map[string]interface{}{
		"userId": resultUser.UserId,
		"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,
		},
		"im":  resultUser.IM,
		"org": resultUser.Org,
	}
	return user, nil
}

func (srv AuthService) getToken(operator domain.Operator, ltoken domain.LoginToken) (interface{}, error) {
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
	userSearchResult, err := creationUserGateway.UserSearch(allied_creation_user.ReqUserSearch{
		Phone: ltoken.Account,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "用户信息获取失败，"+err.Error())
	}
	//判定当前凭证的companyId，OrganizationId 是否在用户列表中
	var currentOrgIsOK bool
loopUser1:
	for _, v := range userSearchResult.Users {
		if v.Company.CompanyId == int(ltoken.CompanyId) {
			for _, vv := range v.UserOrg {
				if vv.OrgID == int(ltoken.OrgId) || vv.OrgID == int(operator.OrgId) {
					currentOrgIsOK = true
					break loopUser1
				}
			}
		}
	}
	if !currentOrgIsOK {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "登录的公司组织不可用")
	}

	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.INTERNAL_SERVER_ERROR, err.Error())
	}
	_, lAccess, err := loginAccessRepository.Find(map[string]interface{}{
		"account":  ltoken.Account,
		"platform": domain.LoginPlatformApp,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	var currentAccess *domain.LoginAccess
	if len(lAccess) > 0 {
		currentAccess = lAccess[0]
		currentAccess.UpdatedTime = time.Now()
	} else {
		currentAccess = &domain.LoginAccess{
			UserBaseId:     ltoken.UserBaseId,
			UserId:         ltoken.UserId,
			Account:        ltoken.Account,
			Platform:       domain.LoginPlatformApp,
			CompanyId:      ltoken.CompanyId,
			OrganizationId: ltoken.OrgId,
			AccessToken:    "",
			RefreshToken:   "",
			AccessExpired:  0,
			RefreshExpired: 0,
			CreatedTime:    time.Now(),
			UpdatedTime:    time.Now(),
		}
	}
	accessTokenStr, err := ltoken.GenerateAccessToken()
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	currentAccess.AccessToken = accessTokenStr
	currentAccess.AccessExpired = ltoken.ExpiresAt
	refreshTokenStr, err := ltoken.GenerateRefreshToken()
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	currentAccess.RefreshToken = refreshTokenStr
	currentAccess.RefreshExpired = ltoken.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.TRANSACTION_ERROR, err.Error())
	}
	//后处理redis缓存
	tokenCache := cache.LoginTokenCache{}
	tokenCache.RemoveAccessToken(currentAccess.Account, domain.LoginPlatformApp)
	tokenCache.RemoveRefreshToken(currentAccess.Account, domain.LoginPlatformApp)
	tokenCache.SaveAccessToken(currentAccess)
	tokenCache.SaveRefreshToken(currentAccess)
	nowTime := time.Now().Unix()
	return map[string]interface{}{
		"refreshToken": accessTokenStr,
		"accessToken":  refreshTokenStr,
		"expiresIn":    currentAccess.AccessExpired - nowTime,
	}, nil
}