sure/app/models/snaptrade_account/processor.rb

class SnaptradeAccount::Processor
  include SnaptradeAccount::DataHelpers

  attr_reader :snaptrade_account

  def initialize(snaptrade_account)
    @snaptrade_account = snaptrade_account
  end

  def process
    account = snaptrade_account.current_account
    return unless account

    Rails.logger.info "SnaptradeAccount::Processor - Processing account #{snaptrade_account.id} -> Sure account #{account.id}"

    # Update account balance FIRST (before processing holdings/activities)
    # This creates the current_anchor valuation needed for reverse sync
    update_account_balance(account)

    # Process holdings
    holdings_count = snaptrade_account.raw_holdings_payload&.size || 0
    Rails.logger.info "SnaptradeAccount::Processor - Holdings payload has #{holdings_count} items"

    # Run the holdings processor when there are security holdings OR
    # non-primary-currency cash to surface as synthetic cash holdings (#1809).
    if snaptrade_account.raw_holdings_payload.present? || snaptrade_account.non_primary_cash_entries.any?
      Rails.logger.info "SnaptradeAccount::Processor - Processing holdings..."
      SnaptradeAccount::HoldingsProcessor.new(snaptrade_account).process
    else
      Rails.logger.warn "SnaptradeAccount::Processor - No holdings payload to process"
    end

    # Process activities (trades, dividends, etc.)
    activities_count = snaptrade_account.raw_activities_payload&.size || 0
    Rails.logger.info "SnaptradeAccount::Processor - Activities payload has #{activities_count} items"

    if snaptrade_account.raw_activities_payload.present?
      Rails.logger.info "SnaptradeAccount::Processor - Processing activities..."
      SnaptradeAccount::ActivitiesProcessor.new(snaptrade_account).process
    else
      Rails.logger.warn "SnaptradeAccount::Processor - No activities payload to process"
    end

    # Trigger immediate UI refresh so entries appear in the activity feed
    # This is critical for fresh account links where the sync complete broadcast
    # might be delayed by child syncs (balance calculations)
    account.broadcast_sync_complete
    Rails.logger.info "SnaptradeAccount::Processor - Broadcast sync complete for account #{account.id}"

    { holdings_processed: holdings_count > 0, activities_processed: activities_count > 0 }
  end

  private

    def update_account_balance(account)
      # Calculate total balance and cash balance from SnapTrade data
      total_balance = calculate_total_balance
      cash_balance = calculate_cash_balance

      Rails.logger.debug "SnaptradeAccount::Processor - Balance update: total=#{total_balance}, cash=#{cash_balance}"

      # Update the cached fields on the account
      account.assign_attributes(
        balance: total_balance,
        cash_balance: cash_balance,
        currency: snaptrade_account.currency || account.currency
      )
      account.save!

      # Create or update the current balance anchor valuation for linked accounts
      # This is critical for reverse sync to work correctly
      account.set_current_balance(total_balance)
    end

    def calculate_total_balance
      if use_api_total_balance?
        Rails.logger.debug "SnaptradeAccount::Processor - Using API total for multi-currency holdings for snaptrade_account=#{snaptrade_account.id}"
        return snaptrade_account.current_balance || 0
      end

      # Calculate total from holdings + cash for accuracy
      # SnapTrade's current_balance can sometimes be stale or just the cash value
      holdings_value = calculate_holdings_value
      cash_value = calculate_cash_balance

      calculated_total = holdings_value + cash_value

      # Use calculated total if we have holdings, otherwise trust API value
      if holdings_value > 0
        Rails.logger.debug "SnaptradeAccount::Processor - Using calculated total: holdings=#{holdings_value} + cash=#{cash_value} = #{calculated_total}"
        calculated_total
      elsif snaptrade_account.current_balance.present?
        Rails.logger.debug "SnaptradeAccount::Processor - Using API total: #{snaptrade_account.current_balance}"
        snaptrade_account.current_balance
      else
        calculated_total
      end
    end

    def calculate_cash_balance
      # Memoized: called for both the total and the cash figure, and the
      # cash-equivalent exclusion should only be recorded once per sync.
      @calculate_cash_balance ||= begin
        # Note: Can be negative for margin accounts
        cash = snaptrade_account.cash_balance
        Rails.logger.debug "SnaptradeAccount::Processor - Cash balance from API: #{cash.inspect}"

        if cash.nil?
          BigDecimal("0")
        else
          # SnapTrade includes money market / sweep funds (e.g. Fidelity SPAXX) in
          # the balances endpoint's `cash` figure while ALSO reporting them as
          # positions with `cash_equivalent: true`. Those positions are imported as
          # holdings, so their value must come out of cash here — otherwise the
          # account total counts the same money twice. Subtract in the currency the
          # stored cash is actually denominated in (upsert_balances! can fall back
          # to a USD/first entry), not the account currency.
          cash_currency = snaptrade_account.primary_cash_currency
          cash_equivalent_value = snaptrade_account.cash_equivalent_position_value(cash_currency)

          # No floor: negative cash is legitimate for margin accounts, and
          # clamping would silently skew the calculated total. The before/after
          # values in the debug entry let support distinguish real margin from
          # a stale holdings snapshot over-subtracting.
          adjusted_cash = cash - cash_equivalent_value

          if cash_equivalent_value.nonzero?
            DebugLogEntry.capture(
              category: "provider_sync",
              level: "info",
              message: "Excluded cash-equivalent (money market) positions already counted in SnapTrade cash balance",
              source: self.class.name,
              provider_key: "snaptrade",
              family: snaptrade_account.snaptrade_item.family,
              account_provider: snaptrade_account.account_provider,
              metadata: {
                snaptrade_account_id: snaptrade_account.id,
                currency: cash_currency,
                cash_equivalent_value: cash_equivalent_value.to_s("F"),
                cash_balance_before: cash.to_s("F"),
                cash_balance_after: adjusted_cash.to_s("F")
              }
            )
          end

          adjusted_cash
        end
      end
    end

    def calculate_holdings_value
      holdings_data = snaptrade_account.raw_holdings_payload || []
      return 0 if holdings_data.empty?

      holdings_data.sum do |holding|
        data = holding.is_a?(Hash) ? holding.with_indifferent_access : {}
        units = parse_decimal(data[:units]) || 0
        price = parse_decimal(data[:price]) || 0
        units * price
      end
    end

    def use_api_total_balance?
      return false unless snaptrade_account.current_balance.present?

      holdings_currencies.any? { |currency| currency.present? && currency != snaptrade_account.currency }
    end

    def holdings_currencies
      Array(snaptrade_account.raw_holdings_payload).filter_map do |holding|
        data = holding.respond_to?(:with_indifferent_access) ? holding.with_indifferent_access : {}
        extract_currency(data, extract_symbol_data(data), snaptrade_account.currency)
      end.uniq
    end
end