Yimaru-BackEnd/internal/repository/user.go

package repository

import (
	dbgen "Yimaru-Backend/gen/db"
	"Yimaru-Backend/internal/domain"
	"Yimaru-Backend/internal/ports"
	"Yimaru-Backend/internal/services/authentication"
	"context"
	"database/sql"
	"errors"
	"fmt"
	"strings"
	"time"

	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/pgtype"
)

func NewUserStore(s *Store) ports.UserStore { return s }

func (s *Store) GetUserDeviceTokens(ctx context.Context, userID int64) ([]string, error) {
	return s.queries.GetActiveDeviceTokens(ctx, userID)
}

func (s *Store) RegisterDevice(ctx context.Context, userID int64, deviceToken, platform string) error {
	_, err := s.queries.CreateDevice(ctx, dbgen.CreateDeviceParams{
		UserID:      userID,
		DeviceToken: deviceToken,
		Platform:    pgtype.Text{String: platform, Valid: platform != ""},
	})
	return err
}

func (s *Store) DeactivateDevice(ctx context.Context, userID int64, deviceToken string) error {
	return s.queries.DeactivateDeviceByToken(ctx, dbgen.DeactivateDeviceByTokenParams{
		UserID:      userID,
		DeviceToken: deviceToken,
	})
}

func (s *Store) DeactivateAllUserDevices(ctx context.Context, userID int64) error {
	return s.queries.DeactivateUserDevices(ctx, userID)
}

func (s *Store) LinkGoogleAccount(
	ctx context.Context,
	userID int64,
	googleID string,
) error {

	return s.queries.LinkGoogleAccount(ctx, dbgen.LinkGoogleAccountParams{
		ID:       userID,
		GoogleID: pgtype.Text{String: googleID, Valid: true},
	})
}

func (s *Store) CreateGoogleUser(
	ctx context.Context,
	gUser domain.GoogleUser,
) (domain.User, error) {

	res, err := s.queries.CreateGoogleUser(ctx, dbgen.CreateGoogleUserParams{
		FirstName:           pgtype.Text{String: gUser.GivenName, Valid: true},
		LastName:            pgtype.Text{String: gUser.FamilyName, Valid: true},
		Email:               pgtype.Text{String: gUser.Email, Valid: true},
		GoogleID:            pgtype.Text{String: gUser.ID, Valid: true},
		GoogleEmailVerified: pgtype.Bool{Bool: gUser.VerifiedEmail, Valid: true},
		Role:                string(domain.RoleStudent),
		Status:              string(domain.UserStatusActive),
		ProfilePictureUrl: pgtype.Text{
			String: gUser.Picture,
			Valid:  gUser.Picture != "",
		},
	})
	if err != nil {
		return domain.User{}, err
	}

	return mapDBUser(res, nil, nil), nil
}

func (s *Store) GetProfileCompletionStatus(ctx context.Context, userId int64) (ports.ProfileCompletionStatus, error) {
	result, err := s.queries.GetProfileCompletionStatus(ctx, userId)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return ports.ProfileCompletionStatus{}, authentication.ErrUserNotFound
		}
		return ports.ProfileCompletionStatus{}, err
	}
	return ports.ProfileCompletionStatus{
		IsCompleted: result.ProfileCompleted.Bool,
		Percentage:  int(result.ProfileCompletionPercentage),
	}, nil
}

func (s *Store) UpdateUserKnowledgeLevel(ctx context.Context, userID int64, knowledgeLevel string) error {
	return s.queries.UpdateUserKnowledgeLevel(ctx, dbgen.UpdateUserKnowledgeLevelParams{
		ID:             userID,
		KnowledgeLevel: pgtype.Text{String: knowledgeLevel, Valid: true},
	})
}

func (s *Store) IsUserPending(ctx context.Context, userID int64) (bool, error) {
	isPending, err := s.queries.IsUserPending(ctx, userID)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return false, authentication.ErrUserNotFound
		}
		return false, err
	}
	return isPending, nil
}

func (s *Store) IsUserNameUnique(ctx context.Context, userID int64) (bool, error) {
	isUnique, err := s.queries.IsUserNameUnique(ctx, userID)
	if err != nil {
		return false, err
	}
	return isUnique, nil
}

func (s *Store) UpdateUserStatus(ctx context.Context, req domain.UpdateUserStatusReq) error {
	return s.queries.UpdateUserStatus(ctx, dbgen.UpdateUserStatusParams{
		Status: req.Status,
		ID:     req.UserID,
	})
}

func (s *Store) CreateUserWithoutOtp(
	ctx context.Context,
	user domain.User,
) (domain.User, error) {

	userRes, err := s.queries.CreateUser(ctx, dbgen.CreateUserParams{
		FirstName: pgtype.Text{String: user.FirstName},
		LastName:  pgtype.Text{String: user.LastName},
		Gender: pgtype.Text{
			String: user.Gender,
			Valid:  user.Gender != "",
		},
		BirthDay: pgtype.Date{
			Time:  user.BirthDay,
			Valid: true,
		},
		// UserName:  user.UserName,

		Email:       pgtype.Text{String: user.Email, Valid: user.Email != ""},
		PhoneNumber: pgtype.Text{String: user.PhoneNumber, Valid: user.PhoneNumber != ""},

		Role:     string(user.Role),
		Password: user.Password,

		AgeGroup:       pgtype.Text{String: user.AgeGroup, Valid: user.AgeGroup != ""},
		EducationLevel: pgtype.Text{String: user.EducationLevel, Valid: user.EducationLevel != ""},
		Country:        pgtype.Text{String: user.Country, Valid: user.Country != ""},
		Region:         pgtype.Text{String: user.Region, Valid: user.Region != ""},

		NickName: pgtype.Text{
			String: user.NickName,
			Valid:  user.NickName != "",
		},
		Occupation: pgtype.Text{
			String: user.Occupation,
			Valid:  user.Occupation != "",
		},
		LearningGoal: pgtype.Text{
			String: user.LearningGoal,
			Valid:  user.LearningGoal != "",
		},
		LanguageGoal: pgtype.Text{
			String: user.LanguageGoal,
			Valid:  user.LanguageGoal != "",
		},
		LanguageChallange: pgtype.Text{
			String: user.LanguageChallange,
			Valid:  user.LanguageChallange != "",
		},
		FavouriteTopic: pgtype.Text{
			String: user.FavouriteTopic,
			Valid:  user.FavouriteTopic != "",
		},

		EmailVerified: user.EmailVerified,
		PhoneVerified: user.PhoneVerified,

		ProfilePictureUrl: pgtype.Text{
			String: user.ProfilePictureURL,
			Valid:  user.ProfilePictureURL != "",
		},
		Status: string(user.Status),
		ProfileCompleted: pgtype.Bool{
			Bool:  user.ProfileCompleted,
			Valid: true,
		},
		PreferredLanguage: pgtype.Text{
			String: user.PreferredLanguage,
			Valid:  user.PreferredLanguage != "",
		},
	})
	if err != nil {
		return domain.User{}, err
	}

	var updatedAt *time.Time
	if userRes.UpdatedAt.Valid {
		updatedAt = &userRes.UpdatedAt.Time
	}

	return mapCreateUserResult(userRes, user.Password, updatedAt), nil
}

// CreateUser inserts a new user into the database
func (s *Store) CreateUser(
	ctx context.Context,
	user domain.User,
	usedOtpId int64,
) (domain.User, error) {

	if usedOtpId > 0 {
		if err := s.queries.MarkOtpAsUsed(ctx, dbgen.MarkOtpAsUsedParams{
			ID:     usedOtpId,
			UsedAt: pgtype.Timestamptz{Time: time.Now(), Valid: true},
		}); err != nil {
			return domain.User{}, err
		}
	}

	userRes, err := s.queries.CreateUser(ctx, dbgen.CreateUserParams{
		FirstName: pgtype.Text{String: user.FirstName},
		LastName:  pgtype.Text{String: user.LastName},
		Gender: pgtype.Text{
			String: user.Gender,
			Valid:  user.Gender != "",
		},
		BirthDay: pgtype.Date{
			Time:  user.BirthDay,
			Valid: true,
		},
		// UserName:  user.UserName,

		Email:       pgtype.Text{String: user.Email, Valid: user.Email != ""},
		PhoneNumber: pgtype.Text{String: user.PhoneNumber, Valid: user.PhoneNumber != ""},

		Role:     string(user.Role),
		Password: user.Password,

		AgeGroup:       pgtype.Text{String: user.AgeGroup, Valid: user.AgeGroup != ""},
		EducationLevel: pgtype.Text{String: user.EducationLevel, Valid: user.EducationLevel != ""},
		Country:        pgtype.Text{String: user.Country, Valid: user.Country != ""},
		Region:         pgtype.Text{String: user.Region, Valid: user.Region != ""},

		NickName:          pgtype.Text{String: user.NickName, Valid: user.NickName != ""},
		Occupation:        pgtype.Text{String: user.Occupation, Valid: user.Occupation != ""},
		LearningGoal:      pgtype.Text{String: user.LearningGoal, Valid: user.LearningGoal != ""},
		LanguageGoal:      pgtype.Text{String: user.LanguageGoal, Valid: user.LanguageGoal != ""},
		LanguageChallange: pgtype.Text{String: user.LanguageChallange, Valid: user.LanguageChallange != ""},
		FavouriteTopic:    pgtype.Text{String: user.FavouriteTopic, Valid: user.FavouriteTopic != ""},

		EmailVerified: user.EmailVerified,
		PhoneVerified: user.PhoneVerified,

		ProfilePictureUrl: pgtype.Text{
			String: user.ProfilePictureURL,
			Valid:  user.ProfilePictureURL != "",
		},
		Status: string(user.Status),
		ProfileCompleted: pgtype.Bool{
			Bool:  user.ProfileCompleted,
			Valid: true,
		},
		PreferredLanguage: pgtype.Text{
			String: user.PreferredLanguage,
			Valid:  user.PreferredLanguage != "",
		},
	})
	if err != nil {
		return domain.User{}, err
	}

	var updatedAt *time.Time
	if userRes.UpdatedAt.Valid {
		updatedAt = &userRes.UpdatedAt.Time
	}

	return mapCreateUserResult(userRes, user.Password, updatedAt), nil
}

// GetUserByID retrieves a user by ID
func (s *Store) GetUserByID(
	ctx context.Context,
	id int64,
) (domain.User, error) {

	u, err := s.queries.GetUserByID(ctx, id)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return domain.User{}, domain.ErrUserNotFound
		}
		return domain.User{}, err
	}

	var lastLogin *time.Time
	if u.LastLogin.Valid {
		lastLogin = &u.LastLogin.Time
	}

	var updatedAt *time.Time
	if u.UpdatedAt.Valid {
		updatedAt = &u.UpdatedAt.Time
	}

	return domain.User{
		ID:        u.ID,
		FirstName: u.FirstName.String,
		LastName:  u.LastName.String,
		Gender:    u.Gender.String,
		BirthDay:  u.BirthDay.Time,
		// UserName:    u.UserName,
		Email:       u.Email.String,
		PhoneNumber: u.PhoneNumber.String,
		Role:        domain.Role(u.Role),

		AgeGroup:       u.AgeGroup.String,
		EducationLevel: u.EducationLevel.String,
		Country:        u.Country.String,
		Region:         u.Region.String,

		NickName:          u.NickName.String,
		Occupation:        u.Occupation.String,
		LearningGoal:      u.LearningGoal.String,
		LanguageGoal:      u.LanguageGoal.String,
		LanguageChallange: u.LanguageChallange.String,
		FavouriteTopic:    u.FavouriteTopic.String,

		EmailVerified: u.EmailVerified,
		PhoneVerified: u.PhoneVerified,
		Status:        domain.UserStatus(u.Status),

		LastLogin:                   lastLogin,
		ProfileCompleted:            u.ProfileCompleted.Bool,
		ProfileCompletionPercentage: int(u.ProfileCompletionPercentage),
		ProfilePictureURL:           u.ProfilePictureUrl.String,
		PreferredLanguage:           u.PreferredLanguage.String,

		CreatedAt: u.CreatedAt.Time,
		UpdatedAt: updatedAt,
	}, nil
}

func (s *Store) GetUserByGoogleID(
	ctx context.Context,
	googleId string,
) (domain.User, error) {

	u, err := s.queries.GetUserByGoogleID(ctx, pgtype.Text{String: googleId, Valid: googleId != ""})
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return domain.User{}, domain.ErrUserNotFound
		}
		return domain.User{}, err
	}

	var lastLogin *time.Time
	if u.LastLogin.Valid {
		lastLogin = &u.LastLogin.Time
	}

	var updatedAt *time.Time
	if u.UpdatedAt.Valid {
		updatedAt = &u.UpdatedAt.Time
	}

	return domain.User{
		ID:        u.ID,
		FirstName: u.FirstName.String,
		LastName:  u.LastName.String,
		Gender:    u.Gender.String,
		BirthDay:  u.BirthDay.Time,
		// UserName:    u.UserName,
		Email:       u.Email.String,
		PhoneNumber: u.PhoneNumber.String,
		Role:        domain.Role(u.Role),

		AgeGroup:       u.AgeGroup.String,
		EducationLevel: u.EducationLevel.String,
		Country:        u.Country.String,
		Region:         u.Region.String,

		NickName:          u.NickName.String,
		Occupation:        u.Occupation.String,
		LearningGoal:      u.LearningGoal.String,
		LanguageGoal:      u.LanguageGoal.String,
		LanguageChallange: u.LanguageChallange.String,
		FavouriteTopic:    u.FavouriteTopic.String,

		EmailVerified: u.EmailVerified,
		PhoneVerified: u.PhoneVerified,
		Status:        domain.UserStatus(u.Status),

		LastLogin:         lastLogin,
		ProfileCompleted:  u.ProfileCompleted.Bool,
		ProfilePictureURL: u.ProfilePictureUrl.String,
		PreferredLanguage: u.PreferredLanguage.String,

		CreatedAt: u.CreatedAt.Time,
		UpdatedAt: updatedAt,
	}, nil
}

// GetAllUsers retrieves users with optional filters
func (s *Store) GetAllUsers(
	ctx context.Context,
	role *string,
	status *string,
	query *string,
	createdBefore, createdAfter *time.Time,
	limit, offset int32,
) ([]domain.User, int64, error) {

	var roleParam pgtype.Text
	if role != nil && *role != "" {
		roleParam = pgtype.Text{String: *role, Valid: true}
	}

	var statusParam pgtype.Text
	if status != nil && *status != "" {
		statusParam = pgtype.Text{String: *status, Valid: true}
	}

	var queryParam pgtype.Text
	if query != nil && *query != "" {
		queryParam = pgtype.Text{String: *query, Valid: true}
	}

	var createdAfterParam pgtype.Timestamptz
	if createdAfter != nil {
		createdAfterParam = pgtype.Timestamptz{Time: *createdAfter, Valid: true}
	}

	var createdBeforeParam pgtype.Timestamptz
	if createdBefore != nil {
		createdBeforeParam = pgtype.Timestamptz{Time: *createdBefore, Valid: true}
	}

	params := dbgen.GetAllUsersParams{
		Role:          roleParam,
		Status:        statusParam,
		Query:         queryParam,
		CreatedAfter:  createdAfterParam,
		CreatedBefore: createdBeforeParam,
		Limit: pgtype.Int4{
			Int32: limit,
			Valid: true,
		},
		Offset: pgtype.Int4{
			Int32: offset,
			Valid: true,
		},
	}

	rows, err := s.queries.GetAllUsers(ctx, params)
	if err != nil {
		return nil, 0, err
	}

	if len(rows) == 0 {
		return []domain.User{}, 0, nil
	}

	totalCount := rows[0].TotalCount
	users := make([]domain.User, 0, len(rows))

	for _, u := range rows {

		var updatedAt *time.Time
		if u.UpdatedAt.Valid {
			updatedAt = &u.UpdatedAt.Time
		}

		users = append(users, domain.User{
			ID:        u.ID,
			FirstName: u.FirstName.String,
			LastName:  u.LastName.String,
			Gender:    u.Gender.String,
			BirthDay:  u.BirthDay.Time,
			// UserName:    u.UserName,
			Email:       u.Email.String,
			PhoneNumber: u.PhoneNumber.String,
			Role:        domain.Role(u.Role),

			AgeGroup:       u.AgeGroup.String,
			EducationLevel: u.EducationLevel.String,
			Country:        u.Country.String,
			Region:         u.Region.String,

			NickName:          u.NickName.String,
			Occupation:        u.Occupation.String,
			LearningGoal:      u.LearningGoal.String,
			LanguageGoal:      u.LanguageGoal.String,
			LanguageChallange: u.LanguageChallange.String,
			FavouriteTopic:    u.FavouriteTopic.String,

			EmailVerified: u.EmailVerified,
			PhoneVerified: u.PhoneVerified,
			Status:        domain.UserStatus(u.Status),

			ProfilePictureURL: u.ProfilePictureUrl.String,
			ProfileCompleted:  u.ProfileCompleted.Bool,
			PreferredLanguage: u.PreferredLanguage.String,

			CreatedAt: u.CreatedAt.Time,
			UpdatedAt: updatedAt,
		})
	}

	return users, totalCount, nil
}

// GetTotalUsers counts users with optional filters
func (s *Store) GetUserSummary(ctx context.Context) (domain.UserSummary, error) {
	res, err := s.queries.GetUserSummary(ctx)
	if err != nil {
		return domain.UserSummary{}, err
	}

	return domain.UserSummary{
		TotalUsers:      res.TotalUsers,
		ActiveUsers:     res.ActiveUsers,
		JoinedThisMonth: res.JoinedThisMonth,
	}, nil
}

func (s *Store) GetTotalUsers(ctx context.Context, role *string) (int64, error) {
	count, err := s.queries.GetTotalUsers(ctx, *role)
	if err != nil {
		return 0, err
	}
	return count, nil
}

func (s *Store) ListAccountDeletionRequests(ctx context.Context, filter domain.AccountDeletionRequestFilter) ([]domain.AccountDeletionRequest, int64, error) {
	page := filter.Page
	if page < 0 {
		page = 0
	}
	pageSize := filter.PageSize
	if pageSize <= 0 {
		pageSize = 10
	}
	if pageSize > 100 {
		pageSize = 100
	}
	offset := page * pageSize

	baseQuery := `
	FROM users u
	WHERE (
		u.deletion_requested_at IS NOT NULL
		OR u.deletion_cancelled_at IS NOT NULL
	)
	`
	args := make([]interface{}, 0, 16)
	argPos := 1

	if filter.Query != "" {
		baseQuery += fmt.Sprintf(`
		AND (
			COALESCE(u.first_name, '') ILIKE $%d
			OR COALESCE(u.last_name, '') ILIKE $%d
			OR COALESCE(u.email, '') ILIKE $%d
			OR COALESCE(u.phone_number, '') ILIKE $%d
		)
		`, argPos, argPos, argPos, argPos)
		args = append(args, "%"+filter.Query+"%")
		argPos++
	}

	if filter.Role != "" {
		baseQuery += fmt.Sprintf(" AND u.role = $%d", argPos)
		args = append(args, filter.Role)
		argPos++
	}
	if filter.Status != "" {
		baseQuery += fmt.Sprintf(" AND u.status = $%d", argPos)
		args = append(args, filter.Status)
		argPos++
	}
	if filter.RequestedAfter.Valid {
		baseQuery += fmt.Sprintf(" AND u.deletion_requested_at >= $%d", argPos)
		args = append(args, filter.RequestedAfter.Value)
		argPos++
	}
	if filter.RequestedBefore.Valid {
		baseQuery += fmt.Sprintf(" AND u.deletion_requested_at <= $%d", argPos)
		args = append(args, filter.RequestedBefore.Value)
		argPos++
	}
	if filter.ScheduledAfter.Valid {
		baseQuery += fmt.Sprintf(" AND u.deletion_scheduled_at >= $%d", argPos)
		args = append(args, filter.ScheduledAfter.Value)
		argPos++
	}
	if filter.ScheduledBefore.Valid {
		baseQuery += fmt.Sprintf(" AND u.deletion_scheduled_at <= $%d", argPos)
		args = append(args, filter.ScheduledBefore.Value)
		argPos++
	}

	state := strings.ToUpper(strings.TrimSpace(filter.State))
	switch state {
	case string(domain.AccountDeletionStatePending):
		baseQuery += " AND u.deletion_scheduled_at > CURRENT_TIMESTAMP AND u.deletion_cancelled_at IS NULL"
	case string(domain.AccountDeletionStateDue):
		baseQuery += " AND u.deletion_scheduled_at <= CURRENT_TIMESTAMP AND u.deletion_cancelled_at IS NULL"
	case string(domain.AccountDeletionStateCancelled):
		baseQuery += " AND u.deletion_cancelled_at IS NOT NULL"
	}

	countQuery := "SELECT COUNT(*) " + baseQuery
	var total int64
	if err := s.conn.QueryRow(ctx, countQuery, args...).Scan(&total); err != nil {
		return nil, 0, err
	}

	selectQuery := fmt.Sprintf(`
	SELECT
		u.id,
		COALESCE(u.first_name, '') AS first_name,
		COALESCE(u.last_name, '') AS last_name,
		COALESCE(u.email, '') AS email,
		COALESCE(u.phone_number, '') AS phone_number,
		u.role,
		u.status,
		u.deletion_requested_at,
		u.deletion_scheduled_at,
		u.deletion_cancelled_at,
		CASE
			WHEN u.deletion_cancelled_at IS NOT NULL THEN 'CANCELLED'
			WHEN u.deletion_scheduled_at <= CURRENT_TIMESTAMP THEN 'DUE'
			ELSE 'PENDING'
		END AS deletion_state
	%s
	ORDER BY u.deletion_requested_at DESC, u.id DESC
	LIMIT $%d OFFSET $%d
	`, baseQuery, argPos, argPos+1)

	queryArgs := append(args, pageSize, offset)
	rows, err := s.conn.Query(ctx, selectQuery, queryArgs...)
	if err != nil {
		return nil, 0, err
	}
	defer rows.Close()

	out := make([]domain.AccountDeletionRequest, 0, pageSize)
	for rows.Next() {
		var (
			item        domain.AccountDeletionRequest
			role        string
			status      string
			stateVal    string
			requestedAt pgtype.Timestamptz
			scheduledAt pgtype.Timestamptz
			cancelledAt pgtype.Timestamptz
		)

		if err := rows.Scan(
			&item.UserID,
			&item.FirstName,
			&item.LastName,
			&item.Email,
			&item.PhoneNumber,
			&role,
			&status,
			&requestedAt,
			&scheduledAt,
			&cancelledAt,
			&stateVal,
		); err != nil {
			return nil, 0, err
		}

		item.Role = domain.Role(role)
		item.Status = domain.UserStatus(status)
		item.DeletionState = domain.AccountDeletionState(stateVal)
		if requestedAt.Valid {
			t := requestedAt.Time
			item.DeletionRequestedAt = &t
		}
		if scheduledAt.Valid {
			t := scheduledAt.Time
			item.DeletionScheduledAt = &t
		}
		if cancelledAt.Valid {
			t := cancelledAt.Time
			item.DeletionCancelledAt = &t
		}

		out = append(out, item)
	}
	if err := rows.Err(); err != nil {
		return nil, 0, err
	}

	return out, total, nil
}

// SearchUserByNameOrPhone searches users by name or phone
func (s *Store) SearchUserByNameOrPhone(
	ctx context.Context,
	search string,
	role *string,
) ([]domain.User, error) {

	params := dbgen.SearchUserByNameOrPhoneParams{
		Column1: pgtype.Text{
			String: search,
			Valid:  search != "",
		},
	}

	if role != nil {
		params.Role = pgtype.Text{
			String: *role,
			Valid:  true,
		}
	}

	rows, err := s.queries.SearchUserByNameOrPhone(ctx, params)
	if err != nil {
		return nil, err
	}

	if len(rows) == 0 {
		return []domain.User{}, nil
	}

	users := make([]domain.User, 0, len(rows))

	for _, u := range rows {

		var updatedAt *time.Time
		if u.UpdatedAt.Valid {
			updatedAt = &u.UpdatedAt.Time
		}

		users = append(users, domain.User{
			ID:        u.ID,
			FirstName: u.FirstName.String,
			LastName:  u.LastName.String,
			Gender:    u.Gender.String,
			BirthDay:  u.BirthDay.Time,
			// UserName:    u.UserName,
			Email:       u.Email.String,
			PhoneNumber: u.PhoneNumber.String,
			Role:        domain.Role(u.Role),

			AgeGroup:       u.AgeGroup.String,
			EducationLevel: u.EducationLevel.String,
			Country:        u.Country.String,
			Region:         u.Region.String,

			NickName:          u.NickName.String,
			Occupation:        u.Occupation.String,
			LearningGoal:      u.LearningGoal.String,
			LanguageGoal:      u.LanguageGoal.String,
			LanguageChallange: u.LanguageChallange.String,
			FavouriteTopic:    u.FavouriteTopic.String,

			EmailVerified: u.EmailVerified,
			PhoneVerified: u.PhoneVerified,
			Status:        domain.UserStatus(u.Status),

			ProfileCompleted:  u.ProfileCompleted.Bool,
			ProfilePictureURL: u.ProfilePictureUrl.String,
			PreferredLanguage: u.PreferredLanguage.String,

			CreatedAt: u.CreatedAt.Time,
			UpdatedAt: updatedAt,
		})
	}

	return users, nil
}

// UpdateUser updates basic user info
func (s *Store) UpdateUser(
	ctx context.Context,
	req domain.UpdateUserReq,
) error {

	var birthDate pgtype.Date
	if req.BirthDay != nil && *req.BirthDay != "" {
		t, err := time.Parse("2006-01-02", *req.BirthDay)
		if err != nil {
			return err
		}
		birthDate = pgtype.Date{Time: t, Valid: true}
	}

	var ageGroup pgtype.Text
	if req.AgeGroup != nil {
		ageGroup = pgtype.Text{String: string(*req.AgeGroup), Valid: true}
	}

	return s.queries.UpdateUser(ctx, dbgen.UpdateUserParams{
		FirstName: pgtype.Text{String: req.FirstName, Valid: req.FirstName != ""},
		LastName:  pgtype.Text{String: req.LastName, Valid: req.LastName != ""},

		KnowledgeLevel: pgtype.Text{String: req.KnowledgeLevel, Valid: req.KnowledgeLevel != ""},
		AgeGroup:       ageGroup,

		EducationLevel: pgtype.Text{String: req.EducationLevel, Valid: req.EducationLevel != ""},
		Country:        pgtype.Text{String: req.Country, Valid: req.Country != ""},
		Region:         pgtype.Text{String: req.Region, Valid: req.Region != ""},

		NickName:          pgtype.Text{String: req.NickName, Valid: req.NickName != ""},
		Occupation:        pgtype.Text{String: req.Occupation, Valid: req.Occupation != ""},
		LearningGoal:      pgtype.Text{String: req.LearningGoal, Valid: req.LearningGoal != ""},
		LanguageGoal:      pgtype.Text{String: req.LanguageGoal, Valid: req.LanguageGoal != ""},
		LanguageChallange: pgtype.Text{String: req.LanguageChallange, Valid: req.LanguageChallange != ""},
		FavouriteTopic:    pgtype.Text{String: req.FavouriteTopic, Valid: req.FavouriteTopic != ""},

		InitialAssessmentCompleted: req.InitialAssessmentCompleted,

		ProfilePictureUrl: pgtype.Text{String: req.ProfilePictureURL, Valid: req.ProfilePictureURL != ""},
		PreferredLanguage: pgtype.Text{String: req.PreferredLanguage, Valid: req.PreferredLanguage != ""},

		Gender:   pgtype.Text{String: req.Gender, Valid: req.Gender != ""},
		BirthDay: birthDate,

		ID: req.UserID,
	})
}

// DeleteUser removes a user
func (s *Store) DeleteUser(ctx context.Context, userID int64) error {
	return s.queries.DeleteUser(ctx, userID)
}

func (s *Store) RequestUserDeletion(ctx context.Context, userID int64, gracePeriod time.Duration) (time.Time, error) {
	scheduledAt := time.Now().UTC().Add(gracePeriod)
	const query = `
	UPDATE users
	SET
		deletion_requested_at = CURRENT_TIMESTAMP,
		deletion_scheduled_at = $1,
		deletion_cancelled_at = NULL,
		updated_at = CURRENT_TIMESTAMP
	WHERE id = $2;
	`
	tag, err := s.conn.Exec(ctx, query, scheduledAt, userID)
	if err != nil {
		return time.Time{}, err
	}
	if tag.RowsAffected() == 0 {
		return time.Time{}, domain.ErrUserNotFound
	}
	return scheduledAt, nil
}

func (s *Store) CancelUserDeletion(ctx context.Context, userID int64) error {
	const query = `
	UPDATE users
	SET
		deletion_requested_at = NULL,
		deletion_scheduled_at = NULL,
		deletion_cancelled_at = CURRENT_TIMESTAMP,
		updated_at = CURRENT_TIMESTAMP
	WHERE id = $1;
	`
	tag, err := s.conn.Exec(ctx, query, userID)
	if err != nil {
		return err
	}
	if tag.RowsAffected() == 0 {
		return domain.ErrUserNotFound
	}
	return nil
}

func (s *Store) PurgeDueUserDeletions(ctx context.Context, limit int32) (int64, error) {
	if limit <= 0 {
		limit = 100
	}
	if limit > 1000 {
		limit = 1000
	}

	tx, err := s.conn.Begin(ctx)
	if err != nil {
		return 0, err
	}
	defer tx.Rollback(ctx)

	const query = `
	WITH due AS (
		SELECT id
		FROM users
		WHERE deletion_scheduled_at IS NOT NULL
		  AND deletion_scheduled_at <= CURRENT_TIMESTAMP
		ORDER BY deletion_scheduled_at ASC
		FOR UPDATE SKIP LOCKED
		LIMIT $1
	),
	deleted AS (
		DELETE FROM users u
		USING due
		WHERE u.id = due.id
		RETURNING u.id
	)
	SELECT COUNT(*)::BIGINT
	FROM deleted;
	`
	var deletedCount int64
	if err := tx.QueryRow(ctx, query, limit).Scan(&deletedCount); err != nil {
		return 0, err
	}
	if err := tx.Commit(ctx); err != nil {
		return 0, err
	}
	return deletedCount, nil
}

// CheckPhoneEmailExist checks if phone or email exists in an organization
func (s *Store) CheckPhoneEmailExist(ctx context.Context, phone, email string) (phoneExists, emailExists bool, err error) {
	res, err := s.queries.CheckPhoneEmailExist(ctx, dbgen.CheckPhoneEmailExistParams{
		PhoneNumber: pgtype.Text{String: phone},
		Email:       pgtype.Text{String: email},
	})
	if err != nil {
		return false, false, err
	}

	return res.PhoneExists, res.EmailExists, nil
}

// GetUserByEmail retrieves a user by email and organization
func (s *Store) GetUserByEmailPhone(
	ctx context.Context,
	email string,
	phone string,
) (domain.User, error) {

	u, err := s.queries.GetUserByEmailPhone(ctx, dbgen.GetUserByEmailPhoneParams{
		Email: pgtype.Text{
			String: email,
			Valid:  email != "",
		},
		PhoneNumber: pgtype.Text{
			String: phone,
			Valid:  phone != "",
		},
	})
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) || errors.Is(err, pgx.ErrNoRows) {
			return domain.User{}, domain.ErrUserNotFound
		}
		return domain.User{}, err
	}

	var lastLogin *time.Time
	if u.LastLogin.Valid {
		lastLogin = &u.LastLogin.Time
	}

	var updatedAt *time.Time
	if u.UpdatedAt.Valid {
		updatedAt = &u.UpdatedAt.Time
	}

	return domain.User{
		ID:        u.ID,
		FirstName: u.FirstName.String,
		LastName:  u.LastName.String,
		Gender:    u.Gender.String,
		BirthDay:  u.BirthDay.Time,
		// UserName:    u.UserName,
		Email:       u.Email.String,
		PhoneNumber: u.PhoneNumber.String,
		Password:    u.Password,
		Role:        domain.Role(u.Role),

		AgeGroup:       u.AgeGroup.String,
		EducationLevel: u.EducationLevel.String,
		Country:        u.Country.String,
		Region:         u.Region.String,

		NickName:          u.NickName.String,
		Occupation:        u.Occupation.String,
		LearningGoal:      u.LearningGoal.String,
		LanguageGoal:      u.LanguageGoal.String,
		LanguageChallange: u.LanguageChallange.String,
		FavouriteTopic:    u.FavouriteTopic.String,

		EmailVerified: u.EmailVerified,
		PhoneVerified: u.PhoneVerified,
		Status:        domain.UserStatus(u.Status),

		ProfilePictureURL: u.ProfilePictureUrl.String,
		LastLogin:         lastLogin,
		ProfileCompleted:  u.ProfileCompleted.Bool,
		PreferredLanguage: u.PreferredLanguage.String,

		CreatedAt: u.CreatedAt.Time,
		UpdatedAt: updatedAt,
	}, nil
}

// UpdatePassword updates a user's password (deprecated - use UpdatePasswordHash)
func (s *Store) UpdatePassword(ctx context.Context, password string, userID int64) error {
	return s.queries.UpdatePassword(ctx, dbgen.UpdatePasswordParams{
		Password: []byte(password),
		ID:       userID,
	})
}

// UpdatePasswordHash updates a user's password with a pre-hashed value
func (s *Store) UpdatePasswordHash(ctx context.Context, hashedPassword []byte, userID int64) error {
	return s.queries.UpdatePassword(ctx, dbgen.UpdatePasswordParams{
		Password: hashedPassword,
		ID:       userID,
	})
}

// mapUser converts dbgen.User to domain.User
func mapCreateUserResult(
	userRes dbgen.CreateUserRow,
	password []byte,
	updatedAt *time.Time,
) domain.User {

	return domain.User{
		ID:        userRes.ID,
		FirstName: userRes.FirstName.String,
		LastName:  userRes.LastName.String,
		Gender:    userRes.Gender.String,
		BirthDay:  userRes.BirthDay.Time,
		// UserName:    userRes.UserName,
		Email:       userRes.Email.String,
		PhoneNumber: userRes.PhoneNumber.String,
		Role:        domain.Role(userRes.Role),
		Password:    password,

		AgeGroup:       userRes.AgeGroup.String,
		EducationLevel: userRes.EducationLevel.String,
		Country:        userRes.Country.String,
		Region:         userRes.Region.String,

		NickName:          userRes.NickName.String,
		Occupation:        userRes.Occupation.String,
		LearningGoal:      userRes.LearningGoal.String,
		LanguageGoal:      userRes.LanguageGoal.String,
		LanguageChallange: userRes.LanguageChallange.String,
		FavouriteTopic:    userRes.FavouriteTopic.String,

		EmailVerified: userRes.EmailVerified,
		PhoneVerified: userRes.PhoneVerified,
		Status:        domain.UserStatus(userRes.Status),

		ProfileCompleted:  userRes.ProfileCompleted.Bool,
		PreferredLanguage: userRes.PreferredLanguage.String,

		CreatedAt: userRes.CreatedAt.Time,
		UpdatedAt: updatedAt,
	}
}

// mapDBUser converts dbgen.User to domain.User (used by CreateGoogleUser)
func mapDBUser(
	userRes dbgen.User,
	password []byte,
	updatedAt *time.Time,
) domain.User {

	return domain.User{
		ID:        userRes.ID,
		FirstName: userRes.FirstName.String,
		LastName:  userRes.LastName.String,
		Gender:    userRes.Gender.String,
		BirthDay:  userRes.BirthDay.Time,
		// UserName:    userRes.UserName,
		Email:       userRes.Email.String,
		PhoneNumber: userRes.PhoneNumber.String,
		Role:        domain.Role(userRes.Role),
		Password:    password,

		AgeGroup:       userRes.AgeGroup.String,
		EducationLevel: userRes.EducationLevel.String,
		Country:        userRes.Country.String,
		Region:         userRes.Region.String,

		NickName:          userRes.NickName.String,
		Occupation:        userRes.Occupation.String,
		LearningGoal:      userRes.LearningGoal.String,
		LanguageGoal:      userRes.LanguageGoal.String,
		LanguageChallange: userRes.LanguageChallange.String,
		FavouriteTopic:    userRes.FavouriteTopic.String,

		EmailVerified: userRes.EmailVerified,
		PhoneVerified: userRes.PhoneVerified,
		Status:        domain.UserStatus(userRes.Status),

		ProfilePictureURL: userRes.ProfilePictureUrl.String,
		ProfileCompleted:  userRes.ProfileCompleted.Bool,
		PreferredLanguage: userRes.PreferredLanguage.String,

		CreatedAt: userRes.CreatedAt.Time,
		UpdatedAt: updatedAt,
	}
}