module Eco
  module API
    module Common
      module People

        # Class to define a parser/serializer.
        class PersonAttributeParser < Eco::Language::Models::ParserSerializer

          # @note
          #   - This was introduced at a later stage and might not be available for certain org-parsers configs
          # @return [RequiredAttrs]
          def required_attrs
            @required_attrs ||= @dependencies[:required_attrs]
            #@required_attrs ||= RequiredAttrs.new(attr, :unknown, [attr])
          end

          # @see Eco::Language::Models::ParserSerializer#def_parser
          # @note
          #  - additionally, you can declare a callback `active:` to determine if when the
          # parser will be active/used.
          #  - this is important to help avoiding to set values that are not present in the input entry.
          #  - if you have doubts about using it or not, do not use it.
          # @param phase [Symbol] the phase when this parser should be active.
          #   Must be one of [`:internal`, `:final`]
          # @param active_when [Proc] that expects a list of internal attributes or the internal entry itself.
          # By default, an attribute paraser is active if in the entry to parse the internal attribute is present.
          def def_parser(phase = :internal, active_when: nil, &block)
            @active_when = attribute_present(active_when)
            super(phase, &block)
          end

          # @param phase [Symbol] the phase when this serializer should be active.
          #   Must be one of [`:person,` `:final`, `:internal`]
          def def_serializer(phase = :person, &block)
            super(phase, &block)
          end

          # Determines if for a given source data to parse, this parser should be active or not.
          # @param phase [Symbol] the phase when this parser should be active.
          #   Must be one of [`:internal`, `:final`]
          # @return [Boolean] `true` if there's parser defined and `source_data` activates it.
          def parser_active?(source_data, phase = :any)
            (phase == :any || parser_category?(phase)) && @active_when.call(source_data)
          end

          # Determines a serializer should be active or not.
          # @param phase [Symbol] the phase when this serializer should be active.
          #   Must be one of [`:person,` `:final`, `:internal`]
          # @return [Boolean] `true` if there's serializer defined.
          def serializer_active?(phase = :any)
            (phase == :any) || serializer_category?(phase)
          end


          # Helper to build the `active_when` condition.
          def active_when_any?(*attrs)
            Proc.new do |source_data|
              keys = data_keys(source_data)
              attrs.any? {|key| keys.include?(key)}
            end
          end

          # Helper to build the `active_when` condition.
          def active_when_all?(*attrs)
            Proc.new do |source_data|
              keys = data_keys(source_data)
              attrs.all? {|key| keys.include?(key)}
            end
          end

          private

          # By default, an attribute paraser is active if in the entry to parse
          # the internal attribute is present
          def attribute_present(active_when)
            Proc.new do |source_data|
              data_keys(source_data).include?(self.attr) ||
              (active_when && active_when.call(source_data))
            end
          end

          # Helper to obtain the current internal named attributes of the data
          # @param source_data [Array<String>, Hash] if `Array` those are already the `keys`, if `Hash` it gets the `keys`
          # @return [Array<String>] `keys` of `source_data`
          def data_keys(source_data)
            case source_data
            when Array
              keys = source_data
            when Hash
              keys = source_data.keys
            else
              keys = []
            end
          end

        end
      end
    end
  end
end