# coding: utf-8
module ForemanTasks
  module ForemanTasksHelper

    def recurring_logic_state(recurring_logic)
      icon, status = case recurring_logic.state
             when 'active'
               'glyphicon-info-sign'
             when 'finished'
               ['glyphicon-ok-sign', 'status-ok']
             when 'cancelled'
               ['glyphicon-warning-sign', 'status-error']
             else
               'glyphicon-question-sign'
             end
      content_tag(:i, '&nbsp'.html_safe, :class => "glyphicon #{icon}") + content_tag(:span, recurring_logic.humanized_state, :class => status)
    end

    def task_result_icon_class(task)
      return 'task-status pficon-help' if task.state != 'stopped'

      icon_class = case task.result
                     when 'success'
                       'pficon-ok'
                     when 'error'
                       'pficon-error-circle-o'
                     when 'warning'
                       'pficon-ok status-warn'
                     else
                       'pficon-help'
                   end

      "task-status #{icon_class}"
    end

    def time_in_words_span(time)
      if time.nil?
        _('N/A')
      else
        content_tag :span, (time > Time.now.utc ? _('in %s') : _('%s ago')) % time_ago_in_words(time),
                    { :'data-original-title' => time.try(:in_time_zone), :rel => 'twipsy' }
      end
    end

    def duration_in_words_span(start, finish)
      if start.nil?
        _('N/A')
      else
        content_tag :span, distance_of_time_in_words(start, finish),
                    { :'data-original-title' => number_with_delimiter((finish - start).to_i) + _(' seconds'), :rel => 'twipsy' }
      end
    end

    def recurring_logic_action_buttons(recurring_logic)
      buttons = []
      if authorized_for(:permission => :edit_recurring_logics, :auth_object => recurring_logic)
        buttons << link_to(N_("Cancel"), cancel_foreman_tasks_recurring_logic_path(recurring_logic), :method => :post, :class => 'btn btn-danger') unless %w(cancelled finished).include? recurring_logic.state
      end
      button_group buttons
    end

    def recurring_logic_next_occurrence(recurring_logic)
      if %w(finished cancelled).include? recurring_logic.state
        '-'
      else
        recurring_logic.next_occurrence_time
      end
    end

    def time_f(f, attr, field_options = {}, time_options = {}, html_options = {})
      f.fields_for attr do |fields|
        field(fields, attr, field_options) do
          fields.time_select attr, time_options, html_options
        end
      end
    end

    def date_f(f, attr, field_options = {}, date_options = {}, html_options = {})
      f.fields_for attr do |fields|
        field(fields, attr, field_options) do
          fields.date_select attr, date_options, html_options
        end
      end
    end

    def datetime_f(f, attr, field_options = {}, datetime_options = {}, html_options = {})
      f.fields_for attr do |fields|
        field(fields, attr, field_options) do
          [
            content_tag(:span, nil, :class => 'date', :style => 'white-space: nowrap;') do
              fields.date_select(attr, datetime_options, html_options)
            end,
            ' &mdash; ',
            content_tag(:span, nil, :class => 'time', :style => 'white-space: nowrap;') do
              fields.time_select(attr, datetime_options.merge(:ignore_date => true), html_options)
            end
          ].join
        end
      end
    end

    def inline_checkboxes_f(f, attr, field_options = {}, checkboxes = {}, options = {})
      field(f, attr, field_options) do
        checkboxes.map do |key, name|
          [f.check_box(key, options), " #{name} "]
        end.flatten.join('')
      end
    end

    def trigger_selector(f, triggering = Triggering.new, options = {})
      render :partial => 'common/trigger_form', :locals => { :f => f, :triggering => triggering }
    end

    private

    def future_mode_fieldset(f, triggering)
      tags = []
      tags << text_f(f, :start_at_raw, :label => _('Start at'), :placeholder => 'YYYY-mm-dd HH:MM')
      tags << text_f(f, :start_before_raw, :label => _('Start before'), :placeholder => 'YYYY-mm-dd HH:MM', :help_inline => popover(_('Explanation'), _('Indicates that the action should be cancelled if it cannot be started before this time.')))
      content_tag(:fieldset, nil, :id => "trigger_mode_future", :class => "trigger_mode_form #{'hidden' unless triggering.future?}") do
        tags.join.html_safe
      end
    end

    def recurring_mode_fieldset(f, triggering)
      tags = []
      tags << selectable_f(f, :input_type, %w(cronline monthly weekly daily hourly), {}, :label => _("Repeats"), :id => 'input_type_selector')
      tags += [
        cronline_fieldset(f, triggering),
        monthly_fieldset(f, triggering),
        weekly_fieldset(f, triggering),
        time_picker_fieldset(f, triggering)
      ]

      content_tag(:fieldset, nil, :id => 'trigger_mode_recurring', :class => "trigger_mode_form #{'hidden' unless triggering.recurring?}") do
        tags.join.html_safe
      end
    end

    def cronline_fieldset(f, triggering)
      options = [
        # TRANSLATORS: this translation is referring to an option which is a time interval
        _('is minute (range: 0-59)'),
        # TRANSLATORS: this translation is referring to an option which is a time interval
        _('is hour (range: 0-23)'),
        # TRANSLATORS: this translation is referring to an option which is a time interval
        _('is day of month (range: 1-31)'),
        # TRANSLATORS: this translation is referring to an option which is a time interval
        _('is month (range: 1-12)'),
        # TRANSLATORS: this translation is referring to an option which is a time interval
        _('is day of week (range: 0-6)')
      ].map { |opt| content_tag(:li, opt) }.join
      help = content_tag(:span, nil, :class => 'help-inline') do
        popover(_('Explanation'),
                _("Cron line format 'a b c d e', where: %s") % ("<br><ol type=\"a\">#{options}</ol>"))
      end
      content_tag(:fieldset, nil, :class => "input_type_form #{'hidden' unless triggering.input_type == :cronline}", :id => "input_type_cronline") do
        text_f f, :cronline, :label => _('Cron line'), :placeholder => '* * * * *', :help_inline => help
      end
    end

    def monthly_fieldset(f, triggering)
      content_tag(:fieldset, nil, :id => "input_type_monthly", :class => "input_type_form #{'hidden' unless triggering.input_type == :monthly}") do
        text_f(f, :days, :label => _('Days'), :placeholder => '1,2...')
      end
    end

    def weekly_fieldset(f, triggering)
      content_tag(:fieldset, nil, :id => 'input_type_weekly', :class => "input_type_form #{'hidden' unless triggering.input_type == :weekly}") do
        f.fields_for :days_of_week do |days_of_week|
          inline_checkboxes_f(days_of_week,
                              :weekday,
                              { :label => _("Days of week") },
                              { 1 => _("Mon"),
                                2 => _("Tue"),
                                3 => _("Wed"),
                                4 => _("Thu"),
                                5 => _("Fri"),
                                6 => _("Sat"),
                                7 => _("Sun") })
        end
      end
    end

    def time_picker_fieldset(f, triggering)
      tags = []
      tags << content_tag(:fieldset, nil, :id => 'time_picker', :class => "input_type_form #{'hidden' if triggering.input_type == :cronline}") do
        # TRANSLATORS: Time widget for when a task should start
        time_f(f, :time, { :label => _("At"), :id => 'something' }, { :time_separator => '' })
      end
      tags << number_f(f, :max_iteration, :label => _('Repeat N times'), :min => 1, :placeholder => 'N')
      tags << field(f, :end_time_limit_select, :label => _("Ends"), :control_group_id => "end_time_limit_select") do
        radio_button_f(f, :end_time_limited, :value => false, :checked=> true, :text => _("Never"), :class => 'end_time_limit_selector') +
        # TRANSLATORS: Button text for saying when a task should end
        radio_button_f(f, :end_time_limited, :value => true, :text => _("On"), :class => 'end_time_limit_selector')
      end
      tags << content_tag(:fieldset, nil, :id => 'end_time_limit_form', :class => "input_type_form #{'hidden' unless triggering.end_time_limited}") do
        datetime_f f, :end_time, { :label => _("Ends at") }, { :use_month_numbers => true, :use_two_digit_numbers => true, :time_separator => '' }
      end
      tags.join.html_safe
    end
  end
end