module Eco
  module API
    class UseCases
      class OozeSamples
        module Helpers
          # Class to ease the export process
          class ExportableOoze
            MERGE_DELIMITER = "#:#".freeze
            META_FIELDS     = {
              "id"         => "Internal ID",
              "uid"        => "Unique ID",
              "name"       => "Name of Page",
              "state"      => "State of Page",
              "time_zone"  => "Time Zone",
              "created_at" => "Page Created",
              "updated_at" => "Last updated",
              "tags"       => "Location Tags"
            }.freeze
            DEFAULT_OPTIONS = {
              delimiter:     "\n",
              only_indexed:  true,
              only_labeled:  true,
              only_with_ref: true
            }.freeze

            class << self
              def label?(field)
                !label(field).to_s.strip.empty?
              end

              def label(field, default: nil)
                value   = nil
                value ||= field.label.to_s.strip if field.respond_to?(:label)
                value   = nil unless value && !value.empty?
                return value if value || !default
                default || "Unnamed field:"
              end

              def key_ref_label(field, default: nil)
                "#{field_ref(field)}#{MERGE_DELIMITER}#{label(field, default: default)}"
              end

              def key_to_label(str)
                return str unless str.include?(MERGE_DELIMITER)
                str.split(MERGE_DELIMITER).last
              end

              def key_to_ref(str)
                return str unless str.include?(MERGE_DELIMITER)

                ref = str.split(MERGE_DELIMITER).first
                return ref unless ref.to_s.strip.empty?
                nil
              end

              def indexed?(field)
                !field.deindex
              end

              def with_ref?(field)
                !field.ref_backend.to_s.strip.empty?
              end

              def field_ref(field)
                field.ref_backend || field.ref(any_length: true)
              end
            end

            include Eco::API::UseCases::OozeSamples::Helpers::OozeHandlers

            attr_reader :ooze
            attr_reader :options

            def initialize(ooze, **options)
              msg = "Expecting Ecoportal::API::V2::Page. Given: #{ooze.class}"
              raise msg unless ooze.is_a?(Ecoportal::API::V2::Page)

              @ooze    = ooze
              @options = DEFAULT_OPTIONS.merge(options)
            end

            def delimiter
              options[:delimiter] || "\n"
            end

            # It offers an intermediate structure that can be aligned with other oozes
            # @note
            #   - This method merges indexed values
            #   - It overrides even between fields of different type
            # @param only_indexed: [Boolean]
            # @param only_labeled: [Boolean]
            # @param only_with_ref: [Boolean]
            # @return [Array[Hash]]
            def key_typed_data(**options)
              options.merge!(options)
              meta_fields.tap do |data|
                with_field_section_pairs do |field, section|
                  next unless export?(field)

                  key = self.class.key_ref_label(
                    field,
                    default: alternative_label(field, section)
                  )
                  data[key] = merge_values(
                    data[key],
                    to_value(field),
                    klass:     field.class,
                    delimiter: delimiter
                  )
                end
              end
            end

            # Helper to go through fields and sections in the order they appear.
            # @note
            #   1. It prevents duplicated sections
            # @yield [field, section] once per field and section.
            # @yieldparam field [Component] a field.
            # @yieldparam section [Section] the section that holds the field.
            # @return [Array<Array] Ordered `Array` of pairs of field and section thereof.
            def with_field_section_pairs
              sections = []
              ordered_sections.each_with_object([]) do |section, out|
                next if sections.include?(section)

                sections << section
                section.components.each do |field|
                  out << [field, section]
                  yield(field, section) if block_given?
                end
              end
            end

            private

            def meta_fields
              META_FIELDS.each_with_object({}) do |(attr, name), data|
                data[name] = ooze.respond_to?(attr)? ooze.send(attr).to_s : nil
              end
            end

            def ordered_sections
              if ooze.stages?
                ooze.stages.ordered.each_with_object([]) do |stage, sections|
                  sections.push(*stage.sections).uniq!
                end
              else
                ooze.sections.sort_by.with_index do |sec, index|
                  [sec.weight, index]
                end
              end
            end

            def export?(field, **opts)
              opts = options.merge(opts)
              return false unless field.respond_to?(:to_s)
              return false if opts[:only_indexed]  && !self.class.indexed?(field)
              return false if opts[:only_labeled]  && !self.class.label?(field)
              return false if opts[:only_with_ref] && !self.class.with_ref?(field)
              true
            end

            def alternative_label(field, section)
              "#{field.type.upcase}::#{section.heading}"
            end

            def to_value(field, delimiter: self.delimiter)
              return nil unless field.respond_to?(:to_s)
              return field.to_s unless offers_delimiter?(field.method(:to_s))
              field.to_s(delimiter: delimiter)
            end

            def offers_delimiter?(method)
              method.parameters.any? do |(type, name)|
                (type == :key) && name == :delimiter
              end
            end
          end
        end
      end
    end
  end
end