ユースケース：EC・小売 — パーソナライゼーションエンジンの導入

class UserBehaviorTracker
  BEHAVIOR_TYPES = %w[view cart_add cart_remove purchase search wishlist].freeze
 
  def initialize(user:, session_id:)
    @user = user
    @session_id = session_id
    @redis = Redis.current
  end
 
  def track(event_type, product_id:, metadata: {})
    raise ArgumentError, "Unknown event: #{event_type}" unless BEHAVIOR_TYPES.include?(event_type)
 
    event = {
      user_id: @user&.id,
      session_id: @session_id,
      event_type: event_type,
      product_id: product_id,
      metadata: metadata,
      occurred_at: Time.current.iso8601
    }
 
    # リアルタイム処理用に Redis に書き込み（TTL 24時間）
    redis_key = "behavior:#{@session_id}:#{Time.current.to_i}"
    @redis.setex(redis_key, 86_400, event.to_json)
 
    # 分析用に PostgreSQL にも非同期で保存
    UserBehaviorEvent.insert(event.except(:metadata).merge(
      metadata: metadata.to_json
    ))
  end
 
  def recent_views(limit: 20)
    UserBehaviorEvent
      .where(user_id: @user.id, event_type: "view")
      .order(occurred_at: :desc)
      .limit(limit)
      .pluck(:product_id)
  end
 
  def viewed_categories
    Product
      .where(id: recent_views(limit: 50))
      .distinct
      .pluck(:category_id)
  end
end

class AbTest < ApplicationRecord
  has_many :ab_test_assignments, dependent: :delete_all
  has_many :ab_test_conversions, dependent: :delete_all
 
  enum :status, { draft: 0, running: 1, completed: 2, cancelled: 3 }
 
  validates :name, presence: true, uniqueness: true
  validates :traffic_percentage, inclusion: { in: 1..100 }
 
  def assign_variant(user)
    # 一貫性のあるハッシュで同一ユーザーには常に同じバリアントを返す
    existing = ab_test_assignments.find_by(user_id: user.id)
    return existing.variant if existing
 
    hash_value = Digest::SHA256.hexdigest("#{id}:#{user.id}").to_i(16)
    variant = (hash_value % 100) < traffic_percentage ? "variant_b" : "variant_a"
 
    ab_test_assignments.create!(user_id: user.id, variant: variant)
    variant
  end
 
  def conversion_rate(variant)
    assigned = ab_test_assignments.where(variant: variant).count
    return 0.0 if assigned.zero?
 
    converted = ab_test_conversions
      .joins(:ab_test_assignment)
      .where(ab_test_assignments: { variant: variant })
      .select(:ab_test_assignment_id)
      .distinct
      .count
 
    (converted.to_f / assigned * 100).round(2)
  end
 
  def statistical_significance?
    rate_a = conversion_rate("variant_a")
    rate_b = conversion_rate("variant_b")
    n_a = ab_test_assignments.where(variant: "variant_a").count
    n_b = ab_test_assignments.where(variant: "variant_b").count
 
    return false if [n_a, n_b].min < 100
 
    # カイ二乗検定で有意差を判定（p < 0.05）
    conv_a = (rate_a / 100.0 * n_a).round
    conv_b = (rate_b / 100.0 * n_b).round
 
    observed = [[conv_a, n_a - conv_a], [conv_b, n_b - conv_b]]
    total = n_a + n_b
    total_conv = conv_a + conv_b
 
    expected_rate = total_conv.to_f / total
    chi_squared = observed.each_with_index.sum do |row, i|
      n = i.zero? ? n_a : n_b
      expected_conv = (expected_rate * n).round(2)
      expected_non = n - expected_conv
 
      ((row[0] - expected_conv)**2 / expected_conv) +
        ((row[1] - expected_non)**2 / expected_non)
    end
 
    chi_squared > 3.841 # 自由度1、p < 0.05 の臨界値
  end
end

class RecommendationEngine
  def initialize(user)
    @user = user
    @strategies = [
      CollaborativeFilteringStrategy.new(weight: 0.4),
      ContentBasedStrategy.new(weight: 0.35),
      TrendingStrategy.new(weight: 0.15),
      PersonalTrendStrategy.new(weight: 0.1)
    ]
  end
 
  def recommend(limit: 20, context: :home)
    scores = Hash.new(0.0)
 
    @strategies.each do |strategy|
      candidates = strategy.candidates(@user, context: context)
      candidates.each do |product_id, score|
        scores[product_id] += score * strategy.weight
      end
    end
 
    # 既に購入済みの商品を除外
    purchased_ids = @user.orders
      .where("created_at > ?", 90.days.ago)
      .joins(:order_items)
      .pluck("order_items.product_id")
 
    scores.except(*purchased_ids)
      .sort_by { |_, score| -score }
      .first(limit)
      .map(&:first)
  end
end
 
class CollaborativeFilteringStrategy
  attr_reader :weight
 
  def initialize(weight:)
    @weight = weight
  end
 
  def candidates(user, context: :home)
    # 類似ユーザーの購買履歴からレコメンド
    similar_users = find_similar_users(user, limit: 50)
 
    OrderItem
      .where(order: Order.where(user_id: similar_users))
      .group(:product_id)
      .count
      .transform_values { |count| count.to_f / similar_users.size }
  end
 
  private
 
  def find_similar_users(user, limit:)
    # ユーザーの購買カテゴリベクトルのコサイン類似度で上位を取得
    user_categories = user.orders
      .joins(order_items: :product)
      .group("products.category_id")
      .count
 
    return [] if user_categories.empty?
 
    User.find_by_sql([<<~SQL, user.id, limit])
      WITH user_vector AS (
        SELECT products.category_id, COUNT(*) as cnt
        FROM orders
        JOIN order_items ON order_items.order_id = orders.id
        JOIN products ON products.id = order_items.product_id
        WHERE orders.user_id = ?
        GROUP BY products.category_id
      )
      SELECT u.id
      FROM users u
      JOIN orders o ON o.user_id = u.id
      JOIN order_items oi ON oi.order_id = o.id
      JOIN products p ON p.id = oi.product_id
      GROUP BY u.id
      ORDER BY COUNT(DISTINCT p.category_id) DESC
      LIMIT ?
    SQL
      .map(&:id)
  end
end
 
class ContentBasedStrategy
  attr_reader :weight
 
  def initialize(weight:)
    @weight = weight
  end
 
  def candidates(user, context: :home)
    tracker = UserBehaviorTracker.new(user: user, session_id: nil)
    viewed_categories = tracker.viewed_categories
 
    return {} if viewed_categories.empty?
 
    Product
      .where(category_id: viewed_categories)
      .where("created_at > ?", 30.days.ago)
      .order(rating: :desc)
      .limit(100)
      .pluck(:id)
      .each_with_index
      .to_h { |id, i| [id, 1.0 - (i * 0.01)] }
  end
end

class FeatureFlag
  CACHE_TTL = 5.minutes
 
  def self.enabled?(flag_name, user:)
    config = Rails.cache.fetch("feature_flag:#{flag_name}", expires_in: CACHE_TTL) do
      FeatureFlagConfig.find_by(name: flag_name)&.attributes || {}
    end
 
    return false if config.empty?
    return false unless config["enabled"]
 
    # ロールアウト率に基づく判定（一貫性のあるハッシュ）
    percentage = config["rollout_percentage"] || 0
    hash = Digest::MD5.hexdigest("#{flag_name}:#{user.id}").to_i(16) % 100
    hash < percentage
  end
end

class HomeController < ApplicationController
  def index
    @trending_products = Product.trending(limit: 12)
 
    if current_user && FeatureFlag.enabled?("home_recommendation", user: current_user)
      engine = RecommendationEngine.new(current_user)
      @recommended_products = Product.where(id: engine.recommend(limit: 12))
      @recommendation_variant = "personalized"
    else
      @recommended_products = @trending_products
      @recommendation_variant = "popular"
    end
 
    track_impression(@recommendation_variant)
  end
 
  private
 
  def track_impression(variant)
    UserBehaviorTracker.new(
      user: current_user,
      session_id: session.id
    ).track("view", product_id: nil, metadata: {
      page: "home",
      variant: variant
    })
  end
end

class ProductRecommendationService
  def related_products(product, user:, limit: 8)
    candidates = []
 
    # 同じ商品を見た人が買った商品（協調フィルタリング）
    co_purchased = OrderItem
      .where(product_id: co_viewed_product_ids(product))
      .where.not(product_id: product.id)
      .group(:product_id)
      .order("COUNT(*) DESC")
      .limit(limit * 2)
      .pluck(:product_id)
 
    candidates.concat(co_purchased)
 
    # 同じカテゴリの高評価商品（コンテンツベース）
    same_category = Product
      .where(category_id: product.category_id)
      .where.not(id: product.id)
      .order(rating: :desc)
      .limit(limit)
      .pluck(:id)
 
    candidates.concat(same_category)
 
    # ユーザーの嗜好で重み付け
    if user
      scored = score_by_user_preference(candidates.uniq, user)
      scored.first(limit)
    else
      candidates.uniq.first(limit)
    end
  end
 
  private
 
  def co_viewed_product_ids(product)
    UserBehaviorEvent
      .where(product_id: product.id, event_type: "view")
      .where("occurred_at > ?", 30.days.ago)
      .distinct
      .pluck(:session_id)
      .then do |session_ids|
        UserBehaviorEvent
          .where(session_id: session_ids, event_type: "view")
          .where.not(product_id: product.id)
          .group(:product_id)
          .order("COUNT(*) DESC")
          .limit(50)
          .pluck(:product_id)
      end
  end
 
  def score_by_user_preference(product_ids, user)
    tracker = UserBehaviorTracker.new(user: user, session_id: nil)
    preferred_categories = tracker.viewed_categories
 
    Product.where(id: product_ids).sort_by do |product|
      preferred_categories.include?(product.category_id) ? 0 : 1
    end.map(&:id)
  end
end

class CartCrossSellService
  def suggestions(cart, user:, limit: 4)
    cart_product_ids = cart.cart_items.pluck(:product_id)
    cart_categories = Product.where(id: cart_product_ids).pluck(:category_id)
 
    # カート内商品とよく一緒に購入される商品
    frequently_bought = Order
      .joins(:order_items)
      .where(order_items: { product_id: cart_product_ids })
      .joins("JOIN order_items oi2 ON oi2.order_id = orders.id")
      .where.not("oi2.product_id" => cart_product_ids)
      .group("oi2.product_id")
      .order("COUNT(*) DESC")
      .limit(limit * 2)
      .pluck("oi2.product_id")
 
    # 補完カテゴリの商品を優先（例：シャツ → ネクタイ）
    complementary = ComplementaryCategory
      .where(source_category_id: cart_categories)
      .pluck(:target_category_id)
 
    scored = frequently_bought.sort_by do |pid|
      product = Product.find(pid)
      complementary.include?(product.category_id) ? 0 : 1
    end
 
    scored.first(limit)
  end
end

class RecommendationMetrics
  def self.weekly_report
    period = 1.week.ago..Time.current
 
    orders = Order.where(created_at: period)
    sessions = UserBehaviorEvent
      .where(occurred_at: period)
      .select(:session_id)
      .distinct
      .count
 
    cvr = orders.count.to_f / sessions * 100
    aov = orders.average(:total_amount)&.round || 0
 
    cart_created = UserBehaviorEvent
      .where(event_type: "cart_add", occurred_at: period)
      .select(:session_id).distinct.count
    cart_purchased = orders.count
    cart_abandonment = ((1 - cart_purchased.to_f / cart_created) * 100).round(1)
 
    # レコメンデーション経由の売上
    rec_revenue = OrderItem
      .joins(:order)
      .where(orders: { created_at: period })
      .where(source: "recommendation")
      .sum("order_items.price * order_items.quantity")
 
    {
      period: period,
      total_sessions: sessions,
      total_orders: orders.count,
      cvr: cvr.round(2),
      aov: aov,
      cart_abandonment_rate: cart_abandonment,
      recommendation_revenue: rec_revenue,
      recommendation_contribution: (rec_revenue.to_f / orders.sum(:total_amount) * 100).round(1)
    }
  end
end