// Package grpc 将 user-service 认证、用户和短号用例适配成 protobuf gRPC 服务。
package grpc

import (
	"context"

	userv1 "hyapp/api/proto/user/v1"
	"hyapp/pkg/xerr"
	authservice "hyapp/services/user-service/internal/service/auth"
	userservice "hyapp/services/user-service/internal/service/user"
)

// Server 把 user-service 用例层适配为 protobuf gRPC 接口。
type Server struct {
	// UnimplementedAuthServiceServer 保持新增 RPC 时的向前兼容默认行为。
	userv1.UnimplementedAuthServiceServer
	// UnimplementedUserServiceServer 保持用户服务新增 RPC 时的向前兼容默认行为。
	userv1.UnimplementedUserServiceServer
	// UnimplementedUserIdentityServiceServer 保持短号服务新增 RPC 时的向前兼容默认行为。
	userv1.UnimplementedUserIdentityServiceServer

	// authSvc 承载登录、设置密码、refresh 和 logout。
	authSvc *authservice.Service
	// userSvc 承载用户主数据和 display_user_id/靓号用例。
	userSvc *userservice.Service
}

// NewServer 创建 user-service gRPC server。
func NewServer(authSvc *authservice.Service, userSvc *userservice.Service) *Server {
	// gRPC 层只做协议转换和错误转换，不保存领域状态。
	return &Server{
		authSvc: authSvc,
		userSvc: userSvc,
	}
}

// LoginPassword 统一把短号不存在、未设置密码和密码错误留给 service 层映射为 AUTH_FAILED。
func (s *Server) LoginPassword(ctx context.Context, req *userv1.LoginPasswordRequest) (*userv1.AuthResponse, error) {
	// device_id、request_id、client_ip 等审计字段统一从 RequestMeta 转换。
	token, err := s.authSvc.LoginPassword(ctx, req.GetDisplayUserId(), req.GetPassword(), req.GetMeta().GetDeviceId(), authMeta(req.GetMeta()))
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &userv1.AuthResponse{Token: toProtoToken(token)}, nil
}

// LoginThirdParty 只接受 provider 凭证，不在 gateway 泄漏 provider secret。
func (s *Server) LoginThirdParty(ctx context.Context, req *userv1.LoginThirdPartyRequest) (*userv1.AuthResponse, error) {
	// 是否新用户由 auth service 根据 provider subject 绑定是否存在决定。
	token, isNewUser, err := s.authSvc.LoginThirdParty(ctx, req.GetProvider(), req.GetCredential(), req.GetMeta().GetDeviceId(), authMeta(req.GetMeta()))
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &userv1.AuthResponse{Token: toProtoToken(token), IsNewUser: isNewUser}, nil
}

// SetPassword 为已登录用户首次写入密码身份。
func (s *Server) SetPassword(ctx context.Context, req *userv1.SetPasswordRequest) (*userv1.SetPasswordResponse, error) {
	// user_id 必须由 gateway 鉴权后传入，service 层会拒绝非法值。
	if err := s.authSvc.SetPassword(ctx, req.GetUserId(), req.GetPassword(), authMeta(req.GetMeta())); err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &userv1.SetPasswordResponse{PasswordSet: true}, nil
}

// RefreshToken 执行 refresh token 轮换。
func (s *Server) RefreshToken(ctx context.Context, req *userv1.RefreshTokenRequest) (*userv1.RefreshTokenResponse, error) {
	// refresh token 轮换后响应里会返回新的 refresh token，旧 token 立即失效。
	token, err := s.authSvc.RefreshToken(ctx, req.GetRefreshToken(), req.GetMeta().GetDeviceId(), authMeta(req.GetMeta()))
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &userv1.RefreshTokenResponse{Token: toProtoToken(token)}, nil
}

// Logout 失效指定会话或 refresh token。
func (s *Server) Logout(ctx context.Context, req *userv1.LogoutRequest) (*userv1.LogoutResponse, error) {
	// Logout 支持按 session_id 或 refresh token 失效会话。
	revoked, err := s.authSvc.Logout(ctx, req.GetSessionId(), req.GetRefreshToken(), authMeta(req.GetMeta()))
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &userv1.LogoutResponse{Revoked: revoked}, nil
}

// GetUser 返回用户主状态。
func (s *Server) GetUser(ctx context.Context, req *userv1.GetUserRequest) (*userv1.GetUserResponse, error) {
	// 用户查询可能触发靓号懒过期，因此仍走 service 层而不是直接读 repository。
	user, err := s.userSvc.GetUser(ctx, req.GetUserId())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &userv1.GetUserResponse{User: toProtoUser(user)}, nil
}

// BatchGetUsers 批量返回用户主状态，缺失用户不填充占位对象。
func (s *Server) BatchGetUsers(ctx context.Context, req *userv1.BatchGetUsersRequest) (*userv1.BatchGetUsersResponse, error) {
	// 批量查询缺失用户不填充空对象，客户端按 map key 判断存在。
	users, err := s.userSvc.BatchGetUsers(ctx, req.GetUserIds())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	result := make(map[int64]*userv1.User, len(users))
	for userID, user := range users {
		// proto map key 使用 user_id，value 是当前有效用户投影。
		result[userID] = toProtoUser(user)
	}

	return &userv1.BatchGetUsersResponse{Users: result}, nil
}

// GetUserIdentity 按系统 user_id 查询当前 active display_user_id。
func (s *Server) GetUserIdentity(ctx context.Context, req *userv1.GetUserIdentityRequest) (*userv1.GetUserIdentityResponse, error) {
	// Identity 查询返回当前 active display_user_id，过期靓号会在 service 层恢复。
	identity, err := s.userSvc.GetUserIdentity(ctx, req.GetUserId())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &userv1.GetUserIdentityResponse{Identity: toProtoIdentity(identity)}, nil
}

// ResolveDisplayUserID 把展示短号解析为系统 user_id。
func (s *Server) ResolveDisplayUserID(ctx context.Context, req *userv1.ResolveDisplayUserIDRequest) (*userv1.ResolveDisplayUserIDResponse, error) {
	// display_user_id 解析只接受当前 active 短号，不解析 held 默认号或过期靓号。
	identity, err := s.userSvc.ResolveDisplayUserID(ctx, req.GetDisplayUserId())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &userv1.ResolveDisplayUserIDResponse{Identity: toProtoIdentity(identity)}, nil
}

// ChangeDisplayUserID 修改当前 active 短号并返回新绑定。
func (s *Server) ChangeDisplayUserID(ctx context.Context, req *userv1.ChangeDisplayUserIDRequest) (*userv1.ChangeDisplayUserIDResponse, error) {
	// 默认短号修改会检查占用和冷却期，具体事务由 service/repository 完成。
	identity, err := s.userSvc.ChangeDisplayUserID(ctx, req.GetUserId(), req.GetNewDisplayUserId(), req.GetReason(), req.GetOperatorUserId(), req.GetMeta().GetRequestId())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &userv1.ChangeDisplayUserIDResponse{Identity: toProtoIdentity(identity)}, nil
}

// ApplyPrettyDisplayUserID 申请临时靓号并覆盖当前展示号。
func (s *Server) ApplyPrettyDisplayUserID(ctx context.Context, req *userv1.ApplyPrettyDisplayUserIDRequest) (*userv1.ApplyPrettyDisplayUserIDResponse, error) {
	// 靓号申请要求 payment_receipt_id，user-service 只保存回执不处理账务。
	identity, leaseID, err := s.userSvc.ApplyPrettyDisplayUserID(ctx, req.GetUserId(), req.GetPrettyDisplayUserId(), req.GetLeaseDurationMs(), req.GetPaymentReceiptId(), req.GetMeta().GetRequestId())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &userv1.ApplyPrettyDisplayUserIDResponse{Identity: toProtoIdentity(identity), LeaseId: leaseID}, nil
}

// ExpirePrettyDisplayUserID 主动触发靓号过期恢复。
func (s *Server) ExpirePrettyDisplayUserID(ctx context.Context, req *userv1.ExpirePrettyDisplayUserIDRequest) (*userv1.ExpirePrettyDisplayUserIDResponse, error) {
	// 过期恢复可由定时任务、懒过期或人工 RPC 触发，事务语义一致。
	identity, err := s.userSvc.ExpirePrettyDisplayUserID(ctx, req.GetUserId(), req.GetLeaseId(), req.GetMeta().GetRequestId())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &userv1.ExpirePrettyDisplayUserIDResponse{Identity: toProtoIdentity(identity)}, nil
}