ActivityPub実装には手を出すな！

def auto_link_urls(text)
    return ''.html_safe if text.blank?

    if text.include?('<') && text.include?('>')
      # HTML混在コンテンツの処理
      linked_text = apply_url_links_to_html(text)
      mention_linked_text = apply_mention_links_to_html(linked_text)
    else
      # プレーンテキストの処理
      escaped_text = escape_and_format_text(text)
      linked_text = apply_url_links(escaped_text)
      mention_linked_text = apply_mention_links(linked_text)
    end
    mention_linked_text.html_safe
  end

  def escape_and_format_text(text)
    plain_text = ActionView::Base.full_sanitizer.sanitize(text).strip
    ERB::Util.html_escape(plain_text).gsub("\n", '<br>')
  end

def apply_url_links(text)
  link_pattern = /(https?:\/\/[^\s]+)/
  text.gsub(link_pattern) do
    url = ::Regexp.last_match(1)
    display_text = mask_protocol(url)
    "<a href=\"#{url}\" target=\"_blank\" rel=\"noopener noreferrer\" " \
      "class=\"text-gray-500 hover:text-gray-700 transition-colors\">#{display_text}</a>"
  end
end

def fix_split_url_links(html_text)
  html_text.gsub(/<a\s+([^>]*href=['"]([^'"]+)['"][^>]*)>(.+?)<\/a>/m) do |match|
    attributes = ::Regexp.last_match(1)
    href_url = ::Regexp.last_match(2)
    link_content = ::Regexp.last_match(3)

    if link_content.include?('class="invisible"') || link_content.include?('class="ellipsis"')
      cleaned_content = link_content.gsub(/<span class="invisible">[^<]*<\/span>/, '')
                                    .gsub(/<span class="ellipsis">([^<]*)<\/span>/, '\1')
      display_text = cleaned_content.empty? ? mask_protocol(href_url) : "#{cleaned_content}..."
      "<a #{attributes}>#{display_text}</a>"
    else
      match
    end
  end
end

def apply_url_links_to_html(html_text)
  # 既存のHTMLタグ位置を記録
  tags = []
  html_text.scan(/<[^>]+>/) { |match| tags << { content: match, start: $LAST_MATCH_INFO.begin(0), end: $LAST_MATCH_INFO.end(0) } }

  url_pattern = /(https?:\/\/[^\s<>"']+)/
  result = html_text.dup
  offset = 0

  html_text.scan(url_pattern) do |url|
    url_start = $LAST_MATCH_INFO.begin(0)
    url_end = $LAST_MATCH_INFO.end(0)

    # URLが既存のHTMLタグ内にないかチェック
    inside_tag = tags.any? do |tag|
      url_start >= tag[:start] && url_end <= tag[:end]
    end

    unless inside_tag
      # リンク化処理
      display_text = mask_protocol(url[0])
      linked_url = "<a href=\"#{url[0]}\" target=\"_blank\" rel=\"noopener noreferrer\" " \
                   "class=\"text-gray-500 hover:text-gray-700 transition-colors\">#{display_text}</a>"

      actual_start = url_start + offset
      actual_end = url_end + offset
      result[actual_start...actual_end] = linked_url
      offset += linked_url.length - url[0].length
    end
  end

  result
end

def apply_mention_links(text)
  mention_pattern = /@([a-zA-Z0-9_.-]+)@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/
  text.gsub(mention_pattern) do
    username = ::Regexp.last_match(1)
    domain = ::Regexp.last_match(2)
    mention_url = build_mention_url(username, domain)
    %(<a href="#{mention_url}" class="h-card u-url mention"><span class="p-nickname">@#{username}</span></a>)
  end
end

def build_mention_url(username, domain)
  safe_username = username.gsub(/[^a-zA-Z0-9_.-]/, '')
  safe_domain = domain.gsub(/[^a-zA-Z0-9.-]/, '')

  local_domain = Rails.application.config.activitypub.domain

  if domain == local_domain
    # ローカルユーザの場合
    "#{Rails.application.config.activitypub.base_url}/users/#{ERB::Util.url_encode(safe_username)}"
  else
    # リモートユーザの場合、Actorレコードから正しいURLを取得
    actor = Actor.find_by(username: safe_username, domain: safe_domain)
    if actor&.ap_id.present?
      actor_url = actor.ap_id
      actor_url.start_with?('http') ? actor_url : "https://#{actor_url}"
    else
      "https://#{ERB::Util.url_encode(safe_domain)}/users/#{ERB::Util.url_encode(safe_username)}"
    end
  end
end

class WebPushSubscription < ApplicationRecord
  belongs_to :actor
  belongs_to :access_token, class_name: 'Doorkeeper::AccessToken', foreign_key: 'access_token_id', optional: true

  validates :endpoint, presence: true, uniqueness: true
  validates :p256dh_key, presence: true
  validates :auth_key, presence: true

def default_alerts
  {
    'follow' => true,
    'follow_request' => true,
    'favourite' => true,
    'reblog' => true,
    'mention' => true,
    'poll' => true,
    'status' => false,
    'update' => false,
    'quote' => true,
    'admin.sign_up' => false,
    'admin.report' => false
  }
end

def should_receive_notification_from?(from_actor, target_actor, notification_type)
  return false unless should_send_alert?(notification_type)

  case policy
  when 'none'
    false
  when 'followed'
    Follow.exists?(actor: target_actor, target_actor: from_actor, accepted: true)
  when 'follower'
    Follow.exists?(actor: from_actor, target_actor: target_actor, accepted: true)
  else
    true
  end
end

def build_vapid_headers(endpoint)
  audience = URI.parse(endpoint).then { |uri| "#{uri.scheme}://#{uri.host}" }

  private_key = OpenSSL::PKey::EC.new(vapid_private_key)
  public_key_uncompressed = private_key.public_key.to_bn.to_s(2)
  public_key_base64 = Base64.urlsafe_encode64(public_key_uncompressed).tr('=', '')

  token = JWT.encode(
    {
      aud: audience,
      exp: 24.hours.from_now.to_i,
      sub: "mailto:#{instance_contact_email}"
    },
    private_key,
    'ES256'
  )

  {
    'Authorization' => "vapid t=#{token},k=#{public_key_base64}",
    'Crypto-Key' => "p256ecdsa=#{public_key_base64}"
  }
end

def perform_webpush_send(subscription, payload)
  encrypted_payload = WebPush::Encryption.encrypt(payload.to_json, subscription.p256dh_key, subscription.auth_key)

  uri = URI.parse(subscription.endpoint)
  http = Net::HTTP.new(uri.host, uri.port)

  request = Net::HTTP::Post.new(uri.request_uri)
  request['Content-Type'] = 'application/octet-stream'
  request['Content-Encoding'] = 'aes128gcm'
  request['TTL'] = '2592000'

  vapid_headers = build_vapid_headers(subscription.endpoint)
  vapid_headers.each { |key, value| request[key] = value }

  request.body = encrypted_payload
  response = http.request(request)

def valid_preview_url?(url)
  begin
    uri = URI.parse(url)
    return false unless %w[http https].include?(uri.scheme)
    return false if uri.host.blank?

    # Blueskyドメインは除外
    bluesky_domains = ['bsky.app', 'bsky.social', 'bsky.brid.gy']
    return false if bluesky_domains.any? { |domain| uri.host&.include?(domain) }

    # その他のバリデーション...
    true
  rescue URI::InvalidURIError
    false
  end
end

def public_url
  if object.ap_id.present? && !object.local?
    # bsky.brid.gyの場合はBlueskyの実際のURLに変換
    return convert_bsky_bridge_url(object.ap_id) if object.ap_id.include?('bsky.brid.gy')

    return object.ap_id
  end

  # ローカル投稿の場合の処理...
end

private

def convert_bsky_bridge_url(bridge_url)
  # bsky.brid.gyのブリッジURLを実際のBlueskyURLに変換
  post_id = extract_bluesky_post_id(bridge_url)
  return bridge_url unless post_id

  # ActorからBlueskyハンドルを取得
  bluesky_handle = extract_bluesky_handle_from_actor
  return bridge_url unless bluesky_handle

  # BlueskyのURLを構築
  "https://bsky.app/profile/#{bluesky_handle}/post/#{post_id}"
rescue StandardError => e
  Rails.logger.warn "Failed to convert bsky.brid.gy URL #{bridge_url}: #{e.message}"
  bridge_url
end

def extract_bluesky_post_id(bridge_url)
  # URLの最後の部分（post ID）を抽出
  match = bridge_url.match(/\/app\.bsky\.feed\.post\/([^\/\?#]+)/)
  match&.[](1)
end

def extract_bluesky_handle_from_actor
  actor = object.actor
  return nil unless actor

  # まずusernameを試す
  username = actor.username
  if username&.exclude?('did:plc:')
    return username
  end

  # preferredUsernameがあれば使用
  return actor.preferred_username if actor.respond_to?(:preferred_username) && actor.preferred_username.present?

  nil
end

def base_timeline_query
  query = ActivityPubObject.joins(:actor)
                           .includes(:actor, :media_attachments, :poll)
                           .where(object_type: %w[Note Question])
                           .where(is_pinned_only: false)
                           .order('objects.id DESC')
  query
end

def fetch_reblogs(followed_ids)
  reblogs = Reblog.joins(:actor, :object)
                  .where(actor_id: followed_ids)
                  .where(objects: { visibility: %w[public unlisted] })
                  .includes(object: %i[actor media_attachments poll], actor: {})
                  .order('reblogs.created_at DESC')
  apply_reblog_pagination_filters(reblogs).limit(limit * 10)
end

def load_user_post_objects
  ActivityPubObject
    .joins(:actor)
    .where(actor: @actor)
    .where(visibility: %w[public unlisted])
    .where(object_type: 'Note')
    .where(local: true)
    .includes(:actor)
end

def load_user_reblog_objects
  Reblog.joins(:actor, :object)
        .where(actor: @actor)
        .where(objects: { visibility: %w[public unlisted] })
        .includes(:actor, object: %i[actor media_attachments])
end

def load_pinned_posts
  @actor.pinned_statuses
        .includes(object: %i[actor media_attachments mentions tags])
        .ordered
end