module ProtocolsIoHelper
  #=============================================================================
  # Protocols.io limits
  #=============================================================================
  TEXT_MAX_LENGTH = Constants::TEXT_MAX_LENGTH

  PIO_ELEMENT_RESERVED_LENGTH_BIG = TEXT_MAX_LENGTH * 0.015
  PIO_ELEMENT_RESERVED_LENGTH_MEDIUM = TEXT_MAX_LENGTH * 0.01
  PIO_ELEMENT_RESERVED_LENGTH_SMALL = TEXT_MAX_LENGTH * 0.005

  # PROTOCOLS.IO PROTOCOL ATTRIBUTES
  PIO_P_AVAILABLE_LENGTH =
    TEXT_MAX_LENGTH -
    (PIO_ELEMENT_RESERVED_LENGTH_SMALL * 2 +
    PIO_ELEMENT_RESERVED_LENGTH_MEDIUM * 8 +
    PIO_ELEMENT_RESERVED_LENGTH_BIG * 2)
  # -- 2 small = created at , publish date PROTOCOL ATTRIBUTES
  # -- 8 medium = description,tags,before_start,warning,guidelines,
  # manuscript_citation,keywords,vendor_name PROTOCOL ATTRIBUTES
  # -- 2 big = vendor_link, link PROTOCOL ATTRIBUTES

  # PROTOCOLS.IO STEP ATTRIBUTES
  PIO_S_AVAILABLE_LENGTH =
    TEXT_MAX_LENGTH -
    (PIO_ELEMENT_RESERVED_LENGTH_SMALL * 20)
  # -- 20 small = description,expected_result,safety_information
  # software_package version, software_package os_name,
  # software_package os_version,software_package link,
  # software_package repository,software_package developer,software_package name
  # commands os_version,commands os_name, commands name,commands description,
  # sub protocol full name (author), sub protocol name, sub protocol link,
  # dataset link,dataset name, safety_information link,
  # -- 0 medium =
  # -- 0 big =

  PIO_TITLE_TOOLONG_LEN =
    I18n.t('protocols.protocols_io_import.title_too_long').length + 5
  PIO_STEP_TOOLONG_LEN =
    I18n.t('protocols.protocols_io_import.too_long').length
  # The + 2 above (in title) is there because if the length was at the limit,
  # the cutter method had issues, this gives it some space

  # below are default min table settings (minimum 5x5)
  PIO_TABLE_MIN_WIDTH = 5
  PIO_TABLE_MIN_HEIGHT = 5

  def protocolsio_string_to_table_element(description_string)
    string_without_tables = string_html_table_remove(description_string)
    table_regex = %r{<table\b[^>]*>(.*?)<\/table>}m
    tr_regex = %r{<tr\b[^>]*>(.*?)<\/tr>}m
    td_regex = %r{<td\b[^>]*>(.*?)<\/td>}m
    tables = {}
    description_string.gsub! '<th>', '<td>'
    description_string.gsub! '</th>', '</td>'
    table_strings = description_string.scan(table_regex)
    table_strings.each_with_index do |table, table_counter|
      tables[table_counter.to_s] = {}
      tr_number = table[0].scan(tr_regex).count
      diff = PIO_TABLE_MIN_HEIGHT - tr_number # always tables have atleast 5 row
      table_fix_str = table[0]
      table_fix_str += '<tr></tr>' * diff if tr_number < PIO_TABLE_MIN_HEIGHT
      tr_strings = table_fix_str.scan(tr_regex)
      contents = {}
      contents['data'] = []
      tr_strings.each_with_index do |tr, tr_counter|
        td_strings = tr[0].scan(td_regex)
        contents['data'][tr_counter] = []
        td_counter = td_strings.count
        diff = PIO_TABLE_MIN_WIDTH - td_counter
        td_strings.each do |td|
          td_stripped = ActionController::Base.helpers.strip_tags(td[0])
          contents['data'][tr_counter].push(td_stripped)
        end
        next if td_counter >= PIO_TABLE_MIN_WIDTH
        diff.times { contents['data'][tr_counter].push(' ') }
      end
      tables[table_counter.to_s]['contents'] = Base64.encode64(
        contents.to_s.sub('=>', ':')
      )
      tables[table_counter.to_s]['name'] = ' '
    end
    return tables, string_without_tables
  end

  def string_html_table_remove(description_string)
    description_string.remove!("\n", "\t", "\r", "\f")
    table_whole_regex = %r{(<table\b[^>]*>.*?<\/table>)}m
    table_pattern_array = description_string.scan(table_whole_regex)
    string_without_tables = description_string
    table_pattern_array.each do |table_pattern|
      string_without_tables = string_without_tables.gsub(
        table_pattern[0],
        t('protocols.protocols_io_import.comp_append.table_moved').html_safe
      )
    end
    string_without_tables
  end

  def pio_eval_prot_desc(text, attribute_name)
    case attribute_name
    when 'published_on'
      pio_eval_len(text, ProtocolsIoHelper::PIO_ELEMENT_RESERVED_LENGTH_SMALL)
    when 'vendor_link', 'link'
      pio_eval_len(text, ProtocolsIoHelper::PIO_ELEMENT_RESERVED_LENGTH_BIG)
    else
      pio_eval_len(text, ProtocolsIoHelper::PIO_ELEMENT_RESERVED_LENGTH_MEDIUM)
    end
  end

  def pio_eval_title_len(text)
    if text
      text += ' ' if text.length < Constants::NAME_MIN_LENGTH
      if text.length > Constants::NAME_MAX_LENGTH
        text =
          text[0..(Constants::NAME_MAX_LENGTH - PIO_TITLE_TOOLONG_LEN)] +
          t('protocols.protocols_io_import.title_too_long')
        @toolong = true
      end
      text
    else
      ''
    end
  end

  def pio_eval_len(text, reserved)
    if text
      text_end = reserved + @remaining - PIO_STEP_TOOLONG_LEN
      text_end = 2 if text_end < 2
      # Since steps have very low reserved values now (below 100),
      # the above sets their index to 1 if its negative
      # (length of toolong text is about 90 chars, and if remaining is 0,
      # then the negative index just gets set to 1. this is a workaround

      # it would also be possible to not count the length of the "too long" text
      # or setting the import reserved value to 95,but then available characters
      # will be like before (around 7600)
      if text.length - reserved > @remaining
        text =
          close_open_html_tags(
            text[0..text_end] + t('protocols.protocols_io_import.too_long')
          )
        @toolong = true
        @remaining = 0
      elsif (text.length - reserved) > 0
        @remaining -= text.length - reserved
      end
      text
    else
      ''
    end
  end

  def pio_eval_authors(text)
    # Extract authors names from the JSON
    text.map { |auth| auth['name'] }.join(', ')
  rescue StandardError
    []
  end

  def eval_last_modified(steps)
    timestamps = steps.map do |step|
      step['modified_on'] if step['modified_on'].present?
    end
    I18n.l(Time.at(timestamps.max), format: :full)
  rescue StandardError
    I18n.l(Time.at(0), format: :full)
  end

  # Checks so that null values are returned as zero length strings
  # Did this so views arent as ugly (i avoid using if present statements)
  def not_null(attribute)
    if attribute
      attribute
    else
      ''
    end
  end

  def close_open_html_tags(text)
    Nokogiri::HTML::DocumentFragment.parse(text).to_html
  end

  def step_hash_null?(step_json)
    step_json.dig(
      0, 'components', 0, 'type_id'
    ).nil? && step_json.dig(
      0, 'components', '0', 'type_id'
    ).nil?
  end

  # Images are allowed in:
  # Step: description, expected result
  # Protocol description : description before_start warning
  # guidelines manuscript_citation

  def prepare_for_view(
    attribute_text1, size, table = 'no_table', image_allowed = false
  )
    image_tag = image_allowed ? Array('img') : Array(nil)
    image_tag.push('br')
    if table == 'no_table'
      attribute_text = sanitize_input(not_null(attribute_text1), image_tag)
    elsif table == 'table'
      attribute_text = sanitize_input(
        string_html_table_remove(not_null(attribute_text1)), image_tag
      )
    end
    pio_eval_len(
      attribute_text,
      size
    )
  end

  def fill_attributes(attribute_name, attribute_text, step_component)
    output_string = ''
    trans_string = step_component
    trans_string +=
      if attribute_name != 'os_name' && attribute_name != 'os_version'
        attribute_name
      else
        'os'
      end
    output_string +=
      if attribute_name != 'os_version'
        t(trans_string)
      else
        ' , '
      end
    if attribute_name == 'protocol_name'
      output_string += pio_eval_title_len(attribute_text)
    else
      output_string += prepare_for_view(
        attribute_text, ProtocolsIoHelper::PIO_ELEMENT_RESERVED_LENGTH_SMALL
      )
    end
    output_string
  end

  # pio_stp_x means protocols io step (id of component) parser
  # protocols io description parser
  def pio_stp_1(iterating_key)
    br = '<br>'
    append =
      if iterating_key.present?
        br +
        prepare_for_view(
          iterating_key,
          ProtocolsIoHelper::PIO_ELEMENT_RESERVED_LENGTH_SMALL,
          'table',
          true
          ) +
        br
      else
        t('protocols.protocols_io_import.comp_append.missing_desc')
      end
    append
  end

  def pio_stp_6(iterating_key)
    if iterating_key.present?
      # protocols io section(title) parser
      return pio_eval_title_len(CGI.unescapeHTML(sanitize_input(iterating_key)))
    end
    t('protocols.protocols_io_import.comp_append.missing_step')
  end

  def pio_stp_17(iterating_key)
    # protocols io expected result parser
    if iterating_key.present?
      append =
        t('protocols.protocols_io_import.comp_append.expected_result') +
        prepare_for_view(
          iterating_key,
          ProtocolsIoHelper::PIO_ELEMENT_RESERVED_LENGTH_SMALL,
          'table',
          true
        ) +
        '<br>'
      return append
    end
    ''
  end
  # protocols io software package,dataset,commands,
  # sub_protocol and safety_information  parser

  def pio_stp(iterating_key, parse_elements_array, en_local_text)
    append = ''
    parse_elements_array.each do |element|
      next unless iterating_key[element]
      append += fill_attributes(
        element,
        iterating_key[element],
        en_local_text
      )
    end
    append
  end

  def protocols_io_fill_desc(json_hash)
    unshortened_string_for_tables = ''
    description_array = %w[
      ( before_start warning guidelines manuscript_citation published_on
      vendor_name vendor_link keywords tags link created_on )
    ]
    allowed_image_attributes = %w[
      ( before_start warning guidelines manuscript_citation )
    ]
    if json_hash['description'].present?
      unshortened_string_for_tables += json_hash['description']
      description_string =
        '<strong>' +
        t('protocols.protocols_io_import.preview.description') +
        '</strong>' +
        prepare_for_view(
          json_hash['description'],
          ProtocolsIoHelper::PIO_ELEMENT_RESERVED_LENGTH_MEDIUM,
          'table',
          true
        ).html_safe
    else
      description_string =
        '<strong>' +
        t('protocols.protocols_io_import.preview.description') +
        '</strong>' +
        t('protocols.protocols_io_import.comp_append.missing_desc')
    end
    description_string += '<br>'
    description_array.each do |e|
      if e == 'created_on' && json_hash[e].present?
        new_e = '<strong>' + e.humanize + '</strong>'
        description_string +=
          new_e.to_s + ':  ' +
          prepare_for_view(
            params['protocol']['created_at'].to_s,
            ProtocolsIoHelper::PIO_ELEMENT_RESERVED_LENGTH_SMALL
          ) +
          + '<br>'
      elsif e == 'tags' && json_hash[e].present? \
            && json_hash[e].any? && json_hash[e] != ''
        new_e = '<strong>' + e.humanize + '</strong>'
        description_string +=
          new_e.to_s + ': '
        tags_length_checker = ''
        json_hash[e].each do |tag|
          tags_length_checker +=
            sanitize_input(tag['tag_name']) + ' , '
        end
        description_string += prepare_for_view(
          tags_length_checker,
          ProtocolsIoHelper::PIO_ELEMENT_RESERVED_LENGTH_MEDIUM
        )
        description_string += '<br>'
      elsif json_hash[e].present?
        data =
          if e == 'published_on'
            Time.at(json_hash[e]).utc.to_datetime.to_s
          else
            json_hash[e]
          end
        unshortened_string_for_tables += data
        new_e = '<strong>' + e.humanize + '</strong>'
        image_tag = allowed_image_attributes.include?(e) ? Array('img') : Array(nil)
        description_string +=
          new_e.to_s + ':  ' + # intercept tables here, before cut
          pio_eval_prot_desc(
            sanitize_input(data, image_tag),
            e
          ).html_safe + '<br>'
      end
    end
    return description_string, unshortened_string_for_tables
  end

  def protocols_io_guid_reorder_step_json(unordered_step_json)
    return '' if unordered_step_json.blank?
    base_step = unordered_step_json.find { |step| step['previous_guid'].nil? }
    return unordered_step_json if base_step.nil?
    number_of_steps = unordered_step_json.size
    return unordered_step_json if number_of_steps == 1
    step_order = []
    step_counter = 0
    step_order[step_counter] = base_step
    step_counter += 1
    while step_order.length != number_of_steps
      step_order[step_counter] =
        unordered_step_json.find do |step|
          step['previous_guid'] == base_step['guid']
        end
      base_step = step_order[step_counter]
      step_counter += 1
    end
    step_order
  end

  def protocols_io_fill_step(original_json, newj)
    # newj = new json
    # (simple to map) id 1= step description, id 6= section (title),
    # id 17= expected result
    # (complex mapping with nested hashes) id 8 = software package,
    # id 9 = dataset, id 15 = command, id 18 = attached sub protocol
    # id 19= safety information ,
    # id 20= regents (materials, like scinote inventories kind of)

    original_json['steps'] = protocols_io_guid_reorder_step_json(
      original_json['steps']
    )
    newj['0'] = {}
    newj['0']['position'] = 0
    newj['0']['name'] = 'Protocol info'
    @remaining = ProtocolsIoHelper::PIO_P_AVAILABLE_LENGTH
    shortened_string, unshortened_tables_string = protocols_io_fill_desc(
      original_json
    )
    newj['0']['tables'] = protocolsio_string_to_table_element(
      sanitize_input(unshortened_tables_string)
    )[0]
    table_str = protocolsio_string_to_table_element(
      sanitize_input(shortened_string, Array('img'))
    )[1]
    newj['0']['description'] = table_str
    original_json['steps'].each_with_index do |step, pos_orig| # loop over steps
      i = pos_orig + 1
      @remaining = ProtocolsIoHelper::PIO_S_AVAILABLE_LENGTH
      # position of step (first, second.... etc),
      newj[i.to_s] = {} # the json we will insert into db
      newj[i.to_s]['position'] = i
      newj[i.to_s]['description'] = '' unless newj[i.to_s].key?('description')
      newj[i.to_s]['name'] = '' unless newj[i.to_s].key?('name')
      unshortened_step_table_string = ''
      step['components'].each do |key, value|
        # sometimes there are random index values as keys
        # instead of hashes, this is a workaround to that buggy json format
        key = value if value.class == Hash
        # append is the string that we append values into for description
        # pio_stp_x means protocols io step (id of component) parser
        case key['type_id']
        # intercept tables in all of below before cutting
        when 1
          unshortened_step_table_string += key['source']['description']
          newj[i.to_s]['description'] += pio_stp_1(key['source']['description'])
        when 6
          newj[i.to_s]['name'] = pio_stp_6(key['source']['title'])
        when 17
          unshortened_step_table_string += key['source']['body']
          newj[i.to_s]['description'] += pio_stp_17(key['source']['body'])
        when 8
          pe_array = %w(
            name developer version link repository os_name os_version
          )
          trans_text = 'protocols.protocols_io_import.comp_append.soft_packg.'
          newj[i.to_s]['description'] += pio_stp(
            key['source'], pe_array, trans_text
          )
        when 9
          pe_array = %w(
            name link
          )
          trans_text = 'protocols.protocols_io_import.comp_append.dataset.'
          newj[i.to_s]['description'] += pio_stp(
            key['source'], pe_array, trans_text
          )
        when 15
          pe_array = %w(
            name description os_name os_version
          )
          key['source']['name'] =
            '<pre><code>' +
            not_null(key['source']['name'].gsub(/\n/, '<br>')) +
            '</code></pre>'
          trans_text = 'protocols.protocols_io_import.comp_append.command.'
          newj[i.to_s]['description'] += pio_stp(
            key['source'], pe_array, trans_text
          )
        when 18
          pe_array = %w(
            title title_html uri
          )
          trans_text = 'protocols.protocols_io_import.comp_append.sub_protocol.'
          newj[i.to_s]['description'] += pio_stp(
            key['source'], pe_array, trans_text
          )
        when 19
          pe_array = %w(
            body link
          )
          trans_text = 'protocols.protocols_io_import.comp_append.safety_infor.'
          newj[i.to_s]['description'] += pio_stp(
            key['source'], pe_array, trans_text
          )
        end # case end
      end # finished looping over step components
      table_str = protocolsio_string_to_table_element(
        newj[i.to_s]['description']
      )[1]
      newj[i.to_s]['description'] = table_str
      newj[i.to_s]['tables'] = protocolsio_string_to_table_element(
        sanitize_input(unshortened_step_table_string)
      )[0]
    end # steps
    newj
  end

  def get_steps(json)
    # Get steps of the given json_object
    if json.key?('steps') && json['steps'].respond_to?('each')
      json['steps']
    else
      []
    end
  end

  def get_components(step_json)
    # Get components of given step_json
    if step_json.key?('components') &&
       step_json['components'].respond_to?('each')
      step_json['components']
    else
      []
    end
  end
end