module Polyblock
  module ViewHelpers

    def pb(name, options={})
      options = {
          # :editable => false,
          :tag => :div,
          :tag_options => {},
          :condensed => false,
          :length => 250,
          :omission => '... (continued)'
      }.deep_merge(options)

      # Fetch or create Polyblock
      pb = Block.fetch_or_initialize(name)
      pb_id = pb.new_record? ? Block.next_id : pb.id
      name = pb.name if name.is_a? Block
      random_id = Block.random_id

      # Build output tag
      content = pb.content.present? ? pb.content : pb.settings[:default_text]
      tag_options = options[:tag_options].deep_merge({:id => "pb-#{pb_id}-#{random_id}", :data => {:pbid => pb_id, :pbname => name}})
      tag_options[:contenteditable] = if options[:condensed]
                                        'false'
                                      elsif options.has_key?(:editable)
                                        options[:editable] ? 'true' : 'false'
                                      elsif respond_to?(:can?) && can?(:manage, pb)
                                        'true'
                                      elsif respond_to?(:user_signed_in?) && user_signed_in?
                                        if current_user.respond_to?(:admin?) && current_user.admin?
                                          'true'
                                        elsif pb.contentable.present? &&
                                            pb.contentable.respond_to?(:user_id) &&
                                            pb.contentable.user_id == current_user.id
                                          'true'
                                        else
                                          'false'
                                        end
                                      else
                                        'false'
                                      end
      tag_options.delete(:contenteditable) if tag_options[:contenteditable] == 'false'
      tag_options[:class] = (tag_options.key?(:class) ? "#{tag_options[:class]} ": '') + 'polyblock'
      tag_options[:data][:pb_exists] = pb.new_record?

      # Truncation
      if options[:condensed]
        tag_options[:class] += ' polyblock-condensed'
        truncate(Block.strip_html(content), :length => options[:length], :omission => options[:omission])
      else
        content_tag(options[:tag], content, tag_options, false)
      end
    end

    def fields_for_polyblock(name, f, options={})
      options = {}.deep_merge(options)
      pb = pb_from_name(name, f)
      render :partial => 'polyblock/fields_for', :locals => {:f => f, :pb => pb, :name => name, :options => options}
    end

    def simple_fields_for_polyblock(name, f, settings={})
      pb = pb_from_name(name, f)
      options = {
        :field => {
          :as => :ckeditor,
          :label => name.to_s.titleize,
          :input_html => {
            :value => pb.present? ? pb.content : nil
          }
        },
        :use_input_field => false
      }.deep_merge(settings)
      # Merge in legacy fields
      [:label, :input_html].each{|o| options[:field][o] = options[o] if options[o].present? }
      render :partial => 'polyblock/simple_fields_for',
             :locals => {:f => f, :pb => pb, :name => name, :options => options}
    end

    def simple_form_for_polyblocks(options={})
      options = {
          :url => '/polyblock/update'
      }.deep_merge(options)
      simple_form_for(:polyblocks, options) do |f| yield(f) end
    end

    def polyblock_editor_bar
      render :partial => 'polyblock/editor_bar'
    end

    private
    def pb_from_name(name, f)
      if name.is_a?(Polyblock::Block) then name
      elsif name.is_a?(String)
        Block.fetch_or_initialize(name)
      elsif name.is_a?(Symbol)
        if f.object.is_a? Block
          f.object
        else
          f.object.send(name)
        end
      else
        raise 'Invalid name passed to Polyblock pb helper!'
      end
    end

  end
end