# require 'symphonia/bootstrap_link_render'
module Symphonia
  module ApplicationHelper
    include FontAwesome::Rails::IconHelper
    include FormHelper

    def bootstrap_class_for(flash_type)
      case flash_type.to_sym
      when :notice
        'alert-success'
      when :error, :alert
        'alert-danger'
      when :warning
        'alert-warning'
      when :info
        'alert-info'
      else
        flash_type.to_s
      end
    end

    # Renders flash messages
    def render_flash_messages(flash_messages = nil)
      s = ''
      Array(flash_messages || flash).each do |type, message|
        s << content_tag(:div, class: "d-print-none alert #{bootstrap_class_for(type)}") do
          content_tag(:button, '', class: 'fa fa-times-circle-o close', data: { dismiss: 'alert' }) + Array.wrap(message).collect { |m| fa_icon(type, text: m) }.join("<br>").html_safe
        end
      end

      return s.html_safe
    end

    def render_menu(menu, options = {})
      s = ''
      Symphonia::MenuManager.menu(menu).each do |name, item|
        s << render_menu_node(name, item).to_s
      end
      options[:container_class] ||= 'mr-auto'

      return content_tag(:ul, s.html_safe, itemscope: '', itemtype: 'http://schema.org/BreadcrumbList', class: "navbar-nav #{options[:container_class]}", id: menu.to_s)
    end

    def render_menu_node(menu, item, options = {})
      condition = item[:if] ? item[:if].call : true
      selected = @menu_item.to_sym == menu
      label = case item[:label].class.name
              when 'NilClass'
                '&nbsp;'.html_safe
              when 'String'
                item[:label]
              when 'Symbol'
                t(item[:label])
              when 'Proc'
                item[:label].call(controller)
              else
                raise "MenuManager error: Label is unknown type: #{item[:label].class}"
              end
      if item[:children].blank?
        return content_tag(:li, render_menu_link(item, label, options), class: "nav-item #{menu} #{'active' if selected} #{options[:class]}", id: item[:id]) if condition
      else
        children = ''
        item[:children].each do |child, subitem|
          children << render_menu_node(menu, subitem, class: 'dropdown-item').to_s
        end
        unless children.blank?
          return content_tag(:li, class: "nav-item dropdown #{menu}") do
            concat render_menu_link(item.merge({ class: 'dropdown-toggle', data: { toggle: 'dropdown' } }), label, { is_submenu: true })
            concat content_tag(:ul, children.html_safe, class: 'dropdown-menu')
          end
        end
      end
    end

    def render_menu_link(item, label, _options = {})
      url = case item[:url].class.name
            when 'Symbol'
              if item[:url].to_s.include?('.')
                endpoint, path = item[:url].to_s.split('.')
                send(endpoint).send(path)
              else
                main_app.send item[:url]
              end
            when 'Proc'
              item[:url].call(self)
            else
              item[:url]
            end
      link_to(
        (content_tag(:i, '', class: "#{item[:icon]}") + "\n" + content_tag(:span, label, itemprop: 'title')).html_safe,
        url,
        class: "nav-link #{item[:class]}",
        data: item[:data],
        method: item[:method],
        itemprop: 'url'
      )
    end

    def html_title(*args)
      if args.empty?
        title = @html_title || []
        title << t(:meta_title)
        title.reject(&:blank?).join(' — ')
      else
        @html_title ||= []
        @html_title += args
      end
    end

    def html_description(*args)
      if args.empty?
        desc = @html_description
        desc ||= t(:meta_description)
        desc.to_s
      else
        @html_description ||= []
        @html_description += args
      end
    end

    def title(*args, &block)
      options = args.extract_options!
      header = args.shift
      small = args.shift || ''
      header_text = if header.is_a?(Symbol)
                      t(header, default: header.to_s.humanize)
                    else
                      header.to_s.dup
                    end
      if @symphonia_modal_dialog
        ActiveSupport::Deprecation.warn "@symphonia_modal_dialog is no used anymore !"
        @symphonia_modal_dialog.title ||= header_text
        ''
      else
        html_title(header_text.dup)
        header_text << "\n" + content_tag(:small, small, class: 'text-muted') if small.present?
        s = ''
        if options[:back] && !request.xhr?
          back_url = options[:back] unless options[:back].is_a? TrueClass
          s << link_to_back(back_url)
        end
        s << capture(&block).to_s if block_given?
        header_tag = content_tag request.xhr? && :h5 || :h1, id: 'page_header', class: s.present? && "col-6" || nil do
          header_text.html_safe
        end
        return header_tag if s.blank?

        content_tag :div, class: "row" do
          header_tag + content_tag(:div, s.html_safe, class: "col-6 text-right")
        end
      end
    end

    alias_method :page_header, :title

    def render_no_data(message = nil)
      content_tag(:div, message || t(:text_no_data), class: 'nodata')
    end

    def content_for(name, content = nil, &block)
      @has_content ||= {}
      @has_content[name] = true
      super(name, content, &block)
    end

    def has_content?(name)
      !!(@has_content && @has_content[name])
    end

    def format_text(text, _options = {})
      return '' if text.nil?

      markdown = RDiscount.new(text, :smart, :filter_html)
      markdown.to_html.html_safe
    end

    def format_html(text)
      content_tag(:div, (defined?(Ckeditor) ? text.html_safe : format_text(text)), class: 'formatted-text')
    end

    def format_price(value, options = {})
      number_to_currency(value, { precision: 1, strip_insignificant_zeros: true }.merge(options))
    end

    def multiselect_toggler(id = nil)
      link_to(fa_icon(:plus), 'javascript:void(0);', onclick: "toggleMultiSelect(#{id || 'this'});return false", class: 'btn fa fa-border')
    end

    def link_to_back(url = nil)
      link_to(icon(:back, t(:button_back)), (params[:back_url] || url || :back), class: 'btn btn-link back')
    end

    def link_to_new_entity(options = {})
      return '' if !options.has_key?(:skip_permission_check) && !User.current.allowed_to?(:"manage_#{controller_name}")

      anchor = options.has_key?(:anchor) ? options.delete(:anchor) : 'page_header'
      label = options.delete(:label) || t("label_#{controller_name.singularize}_new")
      model = controller.try(:model) || controller_name.singularize
      url = options.delete(:url) || new_polymorphic_path(model, anchor: anchor)

      link_to(fa_icon('add', text: label), url, { class: 'btn btn-primary' }.merge(options))
    end

    # change the default link renderer for will_paginate
    def will_paginate(collection_or_options = nil, options = {})
      if collection_or_options.is_a? Hash
        options, collection_or_options = collection_or_options, nil
      end
      unless options[:renderer]
        options = options.merge renderer: Symphonia::BootstrapLinkRender
      end
      options[:query] ||= @query if @query
      super *[collection_or_options, options].compact
    end

    def ckeditor_for(field_id, options = {})
      return '' unless !!defined?(Ckeditor)

      inline = options.delete(:inline)
      opts = options.inject({}) do |mem, var|
        key = var[0].to_s.camelcase(:lower)
        key[0].downcase!
        mem[key] = var[1]

        mem
      end
      opts['toolbar'] ||= 'Basic'
      # opts['customConfig'] ||= 'Basic'
      js = if inline
             "CKEDITOR.inline('#{field_id}', {toolbar: 'Basic'});"
           else
             "
        var ta_editor = CKEDITOR.instances['#{field_id}'];
        if (ta_editor) {CKEDITOR.remove(ta_editor);}
        CKEDITOR.replace('#{field_id}', #{opts.to_json.html_safe});
      "
           end
      javascript_tag("$(document).ready(function() {#{js.html_safe}})".html_safe)
    end

    def icon(fa, text = nil, **options)
      fa_icon(fa, (text && { text: content_tag(:span, text, class: 'd-none d-sm-inline') } || {}).merge(options))
    end

    def render_symphonia_dialog(*args, &block)
      ActiveSupport::Deprecation.warn "Use `render_modal` instead"
      options = args.extract_options!
      title = options[:title] || args.shift # first arg possible `title`
      body = args.shift
      options[:form_disabled] = true
      size = options.delete(:size)
      size ||= '90%' if options.delete(:large)
      if size.to_s.match(%r(^\d+$))
        size = size.to_s + '%'
      end
      @symphonia_modal_dialog = SymphoniaModalDialog.new(self, options)
      @symphonia_modal_dialog.size = size
      if block_given?
        yield @symphonia_modal_dialog
      else
        raise ArgumentError if body.nil?
      end
      @symphonia_modal_dialog.title ||= title
      if @symphonia_modal_dialog.body.blank?
        if body.is_a?(Hash)
          body.merge!(formats: [:html])
        else
          body = { partial: body, formats: [:html] }
        end
        @symphonia_modal_dialog.body = render(body)
      end
      html = @symphonia_modal_dialog.to_html
      if options[:render_only]
        html
      else
        js = %Q(
        $('##{@symphonia_modal_dialog.modal_id}').modal('hide').remove();
        $('body').append('#{j html}');
        showModal('##{@symphonia_modal_dialog.modal_id}');
        $("##{@symphonia_modal_dialog.modal_id} .modal-dialog input:text").first().focus();
        $("##{@symphonia_modal_dialog.modal_id} .modal-dialog .modal-body div.buttons").remove();
      )
        js.concat("$('##{@symphonia_modal_dialog.modal_id} .modal-dialog').css({width: '#{size}'});") if size.present?
        js.html_safe
      end
    end

    # def render_modal_dialog(show = true, options = {}, &block)
    #   tags = SymphoniaModalDialog.new(self, options)
    #   yield tags if block_given?
    #   html = tags.to_html
    #   if show
    #     "$('##{tags.modal_id}').remove();$('body').append('#{j html}'); showModal('##{tags.modal_id}');".html_safe
    #   else
    #     html
    #   end
    # end

    class SymphoniaModalDialog

      attr_writer :title, :body, :footer
      attr_reader :modal_id, :title

      attr_accessor :size

      def initialize(controller, options = {})
        @c = controller
        @title = options.delete(:title)
        @modal_id = options.delete(:id) || 'modal-dialog'
        @form_options = options.delete(:form_options) || {}
        @options = options
      end

      alias_attribute :id, :modal_id

      def to_html
        html = "<div id='#{@modal_id}' style='' class='modal fade' role='dialog'><div class='modal-dialog #{'modal-lg' if size.present?}'><div class='modal-content'>"
        html << @c.content_tag(:div, class: 'modal-header') do
          @c.content_tag(:button, '', class: 'close fa fa-times', data: { dismiss: 'modal' }, 'aria-hidden' => true) + @c.content_tag(:h4, @title, class: 'modal-title') + @header.to_s
        end
        content = @c.content_tag(:div, @c.content_tag(:div, body.html_safe, class: 'modal-content-inner-container container-fluid'), class: 'modal-body')
        content << @c.content_tag(:div, footer.html_safe, class: 'modal-footer')

        html << content.html_safe
        html << '</div></div></div>'
        html.html_safe
      end

      def header(&block)
        if block_given?
          @header = @c.capture(&block)
        else
          @header = (@header.is_a?(Proc) ? @header.call.to_s : @header.to_s)
        end
      end

      def body(&block)
        if block_given?
          @body = @c.capture(&block)
        else
          @body = (@body.is_a?(Proc) ? @body.call.to_s : @body.to_s)
        end
      end

      def footer(&block)
        if block_given?
          @footer = @c.capture(&block)
        else
          @footer = (@footer.is_a?(Proc) ? @footer.call.to_s : @footer.to_s)
        end
      end

      def submit(name = nil, options = {})
        name ||= @c.t(:button_save)
        @footer = footer.to_s + @c.link_to(name, 'javascript:void(0)', { onclick: "$('##{@modal_id}').find('form').submit()", class: 'btn btn-primary' }.merge(options)).html_safe
      end

    end

    # Example of use
    # <%=
    # table_header_tag_for(User) do |t|
    #  t.th :login
    #  t.th :email
    # end
    # %>
    # options:
    # => column : DB full name of column
    #
    # def table_header_tag_for(model, &block)
    #   tags = TableHeaderTag.new(model, self)
    #   yield tags
    #   tags.to_html
    # end
    #
    # class TableHeaderTag
    #
    #   attr_reader :view, :model
    #
    #   def initialize(model, view)
    #     @model = model
    #     @tags = Array.new
    #     @view = view
    #   end
    #
    #   def th(*args)
    #     options = args.extract_options!
    #     attribute = args.first
    #     label = args[1]
    #     raise ArgumentError if attribute.nil?
    #
    #     sort_options = options.delete(:sort_options) || {}
    #     html_options = options.delete(:html_options) || {}
    #
    #     label ||= @model.send(:human_attribute_name, attribute, options[:i18n] || {})
    #     @tags << @view.content_tag(:th, html_options) do
    #       if options[:sort] === false
    #         label
    #       else
    #         sort_options[:column] ||= options.delete(:column)
    #         sort_options[:column] ||= "#{@model.send(:table_name)}.#{attribute}"
    #         # @view.sortable_column(label, sort_options) # TODO: Rails 5 error
    #         label
    #       end
    #     end
    #
    #   end
    #
    #   def to_html
    #     @tags.join("\n").html_safe
    #   end
    #
    # end

    # def render_share_buttons(url, name, options = {})
    #   options[:icon_css] ||= ''
    #   render(partial: 'common/share_links', locals: options.merge({ url: url, name: name }))
    # end
  end
end

#ApplicationHelper.send :include, Symphonia::ApplicationHelperExtension