How to Use Different Attribution Models by Funnel Stage

class TofuAttribution
  def initialize(journey, lookback_days: 60)
    @journey = journey
    @lookback_days = lookback_days
  end

  def attribute
    first_touchpoint = relevant_touchpoints.first
    return nil unless first_touchpoint

    {
      stage: :tofu,
      channel: first_touchpoint.channel,
      source: first_touchpoint.source,
      medium: first_touchpoint.medium,
      campaign: first_touchpoint.campaign,
      credit: 1.0,
      touchpoint_at: first_touchpoint.occurred_at
    }
  end

  private

  def relevant_touchpoints
    @journey.touchpoints
      .where("occurred_at >= ?", @journey.conversion_at - @lookback_days.days)
      .order(:occurred_at)
  end
end

class MofuAttribution
  def initialize(journey, model: :linear, lookback_days: 30)
    @journey = journey
    @model = model
    @lookback_days = lookback_days
  end

  def attribute
    mid_funnel_touchpoints = get_mid_funnel_touchpoints
    return [] if mid_funnel_touchpoints.empty?

    case @model
    when :linear
      linear_attribution(mid_funnel_touchpoints)
    when :participation
      participation_attribution(mid_funnel_touchpoints)
    end
  end

  private

  def get_mid_funnel_touchpoints
    # All touchpoints between first and last
    all_touchpoints = @journey.touchpoints.order(:occurred_at)
    return [] if all_touchpoints.size <= 2

    all_touchpoints[1..-2]  # Exclude first (ToFU) and last (BoFU)
  end

  def linear_attribution(touchpoints)
    credit_per_touch = 1.0 / touchpoints.count

    touchpoints.map do |tp|
      {
        stage: :mofu,
        channel: tp.channel,
        credit: credit_per_touch,
        touchpoint_at: tp.occurred_at
      }
    end
  end

  def participation_attribution(touchpoints)
    touchpoints.map do |tp|
      {
        stage: :mofu,
        channel: tp.channel,
        credit: 1.0,  # Full credit to each participant
        touchpoint_at: tp.occurred_at
      }
    end
  end
end

class BofuAttribution
  def initialize(journey, lookback_days: 14)
    @journey = journey
    @lookback_days = lookback_days
  end

  def attribute
    last_touchpoint = relevant_touchpoints.last
    return nil unless last_touchpoint

    {
      stage: :bofu,
      channel: last_touchpoint.channel,
      source: last_touchpoint.source,
      medium: last_touchpoint.medium,
      campaign: last_touchpoint.campaign,
      credit: 1.0,
      revenue: @journey.conversion_value,
      touchpoint_at: last_touchpoint.occurred_at
    }
  end

  private

  def relevant_touchpoints
    @journey.touchpoints
      .where("occurred_at >= ?", @journey.conversion_at - @lookback_days.days)
      .where("occurred_at <= ?", @journey.conversion_at)
      .order(:occurred_at)
  end
end

class FullFunnelAttribution
  def initialize(journey)
    @journey = journey
  end

  def attribute
    {
      tofu: tofu_attribution.attribute,
      mofu: mofu_attribution.attribute,
      bofu: bofu_attribution.attribute,
      journey_id: @journey.id,
      conversion_value: @journey.conversion_value
    }
  end

  def full_funnel_credit
    # Combine stages for channel-level view
    combine_stage_credits
  end

  private

  def tofu_attribution
    TofuAttribution.new(@journey)
  end

  def mofu_attribution
    MofuAttribution.new(@journey, model: :linear)
  end

  def bofu_attribution
    BofuAttribution.new(@journey)
  end

  def combine_stage_credits
    credits = {}

    # Weight each stage (customize based on your funnel value)
    stage_weights = { tofu: 0.30, mofu: 0.30, bofu: 0.40 }

    [tofu_attribution.attribute].flatten.compact.each do |credit|
      channel = credit[:channel]
      credits[channel] ||= { tofu: 0, mofu: 0, bofu: 0, total: 0 }
      credits[channel][:tofu] += credit[:credit] * stage_weights[:tofu]
      credits[channel][:total] += credit[:credit] * stage_weights[:tofu]
    end

    mofu_attribution.attribute.each do |credit|
      channel = credit[:channel]
      credits[channel] ||= { tofu: 0, mofu: 0, bofu: 0, total: 0 }
      credits[channel][:mofu] += credit[:credit] * stage_weights[:mofu]
      credits[channel][:total] += credit[:credit] * stage_weights[:mofu]
    end

    [bofu_attribution.attribute].flatten.compact.each do |credit|
      channel = credit[:channel]
      credits[channel] ||= { tofu: 0, mofu: 0, bofu: 0, total: 0 }
      credits[channel][:bofu] += credit[:credit] * stage_weights[:bofu]
      credits[channel][:total] += credit[:credit] * stage_weights[:bofu]
    end

    credits
  end
end

# Example: Testing stage weight accuracy
class StageWeightOptimizer
  def initialize(historical_data, stage_weights)
    @data = historical_data
    @weights = stage_weights
  end

  def evaluate
    predicted = calculate_predicted_contribution(@data, @weights)
    actual = calculate_actual_performance(@data)

    @data.channels.each do |channel|
      error = (predicted[channel] - actual[channel]).abs
      puts "#{channel}: Predicted #{predicted[channel]}%, Actual #{actual[channel]}%, Error #{error}%"
    end
  end

  # Adjust weights to minimize prediction error
  def optimize
    # ... gradient descent or grid search over weight combinations
  end
end