gohorsejobs/backend/internal/infrastructure/persistence/postgres/user_repository.go

package postgres

import (
	"context"
	"database/sql"
	"time"

	"github.com/rede5/gohorsejobs/backend/internal/core/domain/entity"
)

type UserRepository struct {
	db *sql.DB
}

func NewUserRepository(db *sql.DB) *UserRepository {
	return &UserRepository{db: db}
}

func (r *UserRepository) Save(ctx context.Context, user *entity.User) (*entity.User, error) {
	tx, err := r.db.BeginTx(ctx, nil)
	if err != nil {
		return nil, err
	}
	defer tx.Rollback()

	// TenantID is string (UUID) or empty
	var tenantID *string
	if user.TenantID != "" {
		tenantID = &user.TenantID
	}

	// 1. Insert User - users table has UUID id
	query := `
		INSERT INTO users (identifier, password_hash, role, full_name, email, name, tenant_id, status, created_at, updated_at, avatar_url)
		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
		RETURNING id
	`

	var id string
	// Map the first role to the role column, default to 'candidate'
	role := "candidate"
	if len(user.Roles) > 0 {
		role = user.Roles[0].Name
	}

	err = tx.QueryRowContext(ctx, query,
		user.Email, // identifier = email for now
		user.PasswordHash,
		role,
		user.Name,
		user.Email,
		user.Name,
		tenantID,
		user.Status,
		user.CreatedAt,
		user.UpdatedAt,
		user.AvatarUrl,
	).Scan(&id)

	if err != nil {
		return nil, err
	}
	user.ID = id

	// 2. Insert Roles into user_roles table
	if len(user.Roles) > 0 {
		roleQuery := `INSERT INTO user_roles (user_id, role) VALUES ($1, $2) ON CONFLICT DO NOTHING`
		for _, role := range user.Roles {
			_, err := tx.ExecContext(ctx, roleQuery, id, role.Name)
			if err != nil {
				return nil, err
			}
		}
	}

	if err := tx.Commit(); err != nil {
		return nil, err
	}

	return user, nil
}

func (r *UserRepository) FindByEmail(ctx context.Context, email string) (*entity.User, error) {
	query := `SELECT id, COALESCE(tenant_id::text, ''), COALESCE(name, full_name, ''),
		COALESCE(email, identifier), password_hash, COALESCE(status, 'active'), created_at, updated_at, COALESCE(avatar_url, ''),
		phone, bio
		FROM users WHERE email = $1 OR identifier = $1`
	row := r.db.QueryRowContext(ctx, query, email)

	u := &entity.User{}
	var dbID string
	var phone sql.NullString
	var bio sql.NullString
	err := row.Scan(
		&dbID,
		&u.TenantID,
		&u.Name,
		&u.Email,
		&u.PasswordHash,
		&u.Status,
		&u.CreatedAt,
		&u.UpdatedAt,
		&u.AvatarUrl,
		&phone,
		&bio,
	)
	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil // Return nil if not found
		}
		return nil, err
	}
	u.ID = dbID
	u.Phone = nullStringPtr(phone)
	u.Bio = nullStringPtr(bio)
	u.Roles, _ = r.getRoles(ctx, dbID)
	return u, nil
}

func (r *UserRepository) FindByID(ctx context.Context, id string) (*entity.User, error) {
	query := `SELECT id, COALESCE(tenant_id::text, ''), COALESCE(name, full_name, ''),
		COALESCE(email, identifier), password_hash, COALESCE(status, 'active'), created_at, updated_at, COALESCE(avatar_url, ''),
		phone, bio
		FROM users WHERE id = $1`
	row := r.db.QueryRowContext(ctx, query, id)

	u := &entity.User{}
	var dbID string
	var phone sql.NullString
	var bio sql.NullString
	err := row.Scan(
		&dbID,
		&u.TenantID,
		&u.Name,
		&u.Email,
		&u.PasswordHash,
		&u.Status,
		&u.CreatedAt,
		&u.UpdatedAt,
		&u.AvatarUrl,
		&phone,
		&bio,
	)
	if err != nil {
		return nil, err
	}
	u.ID = dbID
	u.Phone = nullStringPtr(phone)
	u.Bio = nullStringPtr(bio)
	u.Roles, _ = r.getRoles(ctx, dbID)
	return u, nil
}

func (r *UserRepository) FindAllByTenant(ctx context.Context, tenantID string, limit, offset int) ([]*entity.User, int, error) {
	var total int
	countQuery := `SELECT COUNT(*) FROM users WHERE tenant_id = $1`
	if err := r.db.QueryRowContext(ctx, countQuery, tenantID).Scan(&total); err != nil {
		return nil, 0, err
	}

	query := `SELECT id, COALESCE(tenant_id::text, ''), COALESCE(name, full_name, ''),
		COALESCE(email, identifier), password_hash, COALESCE(status, 'active'), created_at, updated_at, COALESCE(avatar_url, ''),
		phone, bio
		FROM users
		WHERE tenant_id = $1
		ORDER BY created_at DESC
		LIMIT $2 OFFSET $3`
	rows, err := r.db.QueryContext(ctx, query, tenantID, limit, offset)
	if err != nil {
		return nil, 0, err
	}
	defer rows.Close()

	var users []*entity.User
	for rows.Next() {
		u := &entity.User{}
		var dbID string
		var phone sql.NullString
		var bio sql.NullString
		if err := rows.Scan(
			&dbID,
			&u.TenantID,
			&u.Name,
			&u.Email,
			&u.PasswordHash,
			&u.Status,
			&u.CreatedAt,
			&u.UpdatedAt,
			&u.AvatarUrl,
			&phone,
			&bio,
		); err != nil {
			return nil, 0, err
		}
		u.ID = dbID
		u.Phone = nullStringPtr(phone)
		u.Bio = nullStringPtr(bio)
		u.Roles, _ = r.getRoles(ctx, dbID)
		users = append(users, u)
	}
	return users, total, nil
}

func (r *UserRepository) Update(ctx context.Context, user *entity.User) (*entity.User, error) {
	user.UpdatedAt = time.Now()

	tx, err := r.db.BeginTx(ctx, nil)
	if err != nil {
		return nil, err
	}
	defer tx.Rollback()

	// 1. Update basic fields + legacy role column
	// We use the first role as the "legacy" role for compatibility
	primaryRole := ""
	if len(user.Roles) > 0 {
		primaryRole = user.Roles[0].Name
	}

	query := `UPDATE users SET name=$1, full_name=$2, email=$3, status=$4, role=$5, updated_at=$6, avatar_url=$7, phone=$8, bio=$9, password_hash=$10 WHERE id=$11`
	_, err = tx.ExecContext(
		ctx,
		query,
		user.Name,
		user.Name,
		user.Email,
		user.Status,
		primaryRole,
		user.UpdatedAt,
		user.AvatarUrl,
		user.Phone,
		user.Bio,
		user.PasswordHash,
		user.ID,
	)
	if err != nil {
		return nil, err
	}

	// 2. Update user_roles (Delete all and re-insert)
	_, err = tx.ExecContext(ctx, `DELETE FROM user_roles WHERE user_id=$1`, user.ID)
	if err != nil {
		return nil, err
	}

	if len(user.Roles) > 0 {
		stmt, err := tx.PrepareContext(ctx, `INSERT INTO user_roles (user_id, role) VALUES ($1, $2)`)
		if err != nil {
			return nil, err
		}
		defer stmt.Close()

		for _, role := range user.Roles {
			if _, err := stmt.ExecContext(ctx, user.ID, role.Name); err != nil {
				return nil, err
			}
		}
	}

	if err := tx.Commit(); err != nil {
		return nil, err
	}

	return user, nil
}

func (r *UserRepository) Delete(ctx context.Context, id string) error {
	_, err := r.db.ExecContext(ctx, `DELETE FROM users WHERE id=$1`, id)
	return err
}

func (r *UserRepository) getRoles(ctx context.Context, userID string) ([]entity.Role, error) {
	// Query both user_roles table AND legacy role column from users table
	// This ensures backward compatibility with users who have role set in users.role
	query := `
		SELECT role FROM user_roles WHERE user_id = $1
		UNION
		SELECT role FROM users WHERE id = $1 AND role IS NOT NULL AND role != ''
	`
	rows, err := r.db.QueryContext(ctx, query, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var roles []entity.Role
	for rows.Next() {
		var roleName string
		rows.Scan(&roleName)
		roles = append(roles, entity.Role{Name: roleName})
	}
	return roles, nil
}

func nullStringPtr(value sql.NullString) *string {
	if value.Valid {
		return &value.String
	}
	return nil
}