include Card::Set::Type::Pointer

def raw_content
  item_names.map { |name| "[[#{name}]]" }
end

def item_names _args={}
  if (user = left)
    Card.preference_names user.name, "follow"
  else
    []
  end
end

def virtual?
  !real?
end

format { include Card::Set::Type::Pointer::Format }

format :html do
  include Card::Set::Type::Pointer::HtmlFormat

  view :closed_content do |_args|
    ""
  end

  view :core do |args|
    <<-HTML
      <div role="tabpanel">
        <ul class="nav nav-tabs" role="tablist" id="myTab">
          <li role="presentation" class="active">
             <a href="#following" aria-controls="following"
                role="tab" data-toggle="tab">Follow</a>
          </li>
          <li role="presentation">
            <a href="#ignoring" aria-controls="ignoring"
               role="tab" data-toggle="tab">Ignore</a>
          </li>
        </ul>
        <div class="tab-content">
          <div role="tabpanel" class="tab-pane active" id="following">
            #{render_following_list args}
          </div>
          <div role="tabpanel" class="tab-pane" id="ignoring">
            #{render_ignoring_list}
          </div>
        </div>
      </div>
    HTML
  end

  def followed_by_option
    hash = Hash.new { |h, k| h[k] = [] }
    card.known_item_cards.each do |follow_rule|
      follow_rule.item_cards.each do |follow_option|
        hash[follow_option.codename.to_sym] << follow_rule
      end
    end
  end

  def each_suggestion
    return unless (suggestions = Card["follow suggestions"])
    suggestions.item_names.each do |sug|
      set_card = Card.fetch sug.to_name.left
      if set_card && set_card.type_code == :set
        sugtag = sug.to_name.right
        option_card = Card.fetch(sugtag) || Card[sugtag.to_sym]
        option = option_card.follow_option? ? option_card.name : "*always"
        yield(set_card, option)
      elsif (set_card = Card.fetch sug) && set_card.type_code == :set
        yield(set_card, "*always")
      end
    end
  end

  # returns hashes with existing and suggested follow options
  # structure:
  # set_pattern_class =>
  #  [ {card: rule_card, options: ['*always', '*created'] },.... ]
  def followed_by_set
    res = Hash.new { |h, k| h[k] = [] }
    never = Card[:never].name
    card.known_item_cards.each do |follow_rule|
      options = follow_rule.item_names.reject { |item| item == never }
      res[follow_rule.rule_set.subclass_for_set] << { card: follow_rule,
                                                      options: options }
    end

    if Auth.signed_in? && Auth.current_id == card.left.id
      each_suggestion do |set_card, option|
        suggested_rule_name = set_card.follow_rule_name(card.trunk)
        rule = res[set_card.subclass_for_set].find do |rule|
          rule[:card].name == suggested_rule_name
        end
        if rule
          rule[:options] << option unless rule[:options].include? option
        else
          rule_card = Card.new(name: suggested_rule_name)
          res[set_card.subclass_for_set] << { card: rule_card,
                                              options: [option] }
        end
      end
    end
    res
  end

  view :following_list, cache: :never do |_args|
    if !Auth.signed_in? || Auth.current_id != card.left.id
      hide_buttons = %i[delete_follow_rule_button add_follow_rule_button]
    end

    sets = followed_by_set
    wrap_with :div, class: "pointer-list-editor" do
      wrap_with :ul, class: "delete-list list-group" do
        Card.set_patterns.select { |p| sets[p] }.reverse.map do |set_pattern|
          sets[set_pattern].map do |rule|
            rule[:options].map do |option|
              wrap_with :li, class: "list-group-item" do
                subformat(rule[:card]).render_follow_item condition: option,
                                                          hide: hide_buttons
              end
            end
          end
        end
      end
    end
  end

  view :ignoring_list, cache: :never do |_args|
    ignore_list = []
    card.known_item_cards.each do |follow_rule|
      follow_rule.item_cards.each do |follow_option|
        ignore_list << follow_rule if follow_option.codename.to_sym == :never
      end
    end
    if !Auth.signed_in? || Auth.current_id != card.left.id
      hide_buttons = %i[delete_follow_rule_button add_follow_rule_button]
    end
    never = Card[:never].name
    wrap_with :div, class: "pointer-list-editor" do
      wrap_with :ul, class: "delete-list list-group" do
        ignore_list.map do |rule_card|
          wrap_with :li, class: "list-group-item" do
            subformat(rule_card).render_follow_item condition: never,
                                                    hide: hide_buttons
          end
        end.join "\n"
      end
    end
  end

  def pointer_items args
    voo.items[:view] ||= :link
    super(args)
  end

  view :errors, perms: :none do |args|
    if card.errors.any?
      if card.errors.find { |attrib, _msg| attrib == :permission_denied }
        Env.save_interrupted_action(request.env["REQUEST_URI"])
        voo.title = "Problems with #{card.name}"
        class_up "d0-card-frame", "card card-warning card-inverse"
        frame do
          "Please #{link_to_card :signin, 'sign in'}" # " #{to_task}"
        end
      else
        super(args)
      end
    end
  end
end

format(:css) { include Card::Set::Type::Pointer::CssFormat }