require 'real_page/utils/array_fetcher'
require 'real_page/validator/prospects_data'

require_relative 'base'

module RealPage
  module DocumentParser
    # Parse the ProspectSearch response
    class GuestCards < Base
      MULTIPLE_CHILDREN = {
        'Activities'   => { model: Model::Activity,    key: 'Activity'    },
        'FollowUps'    => { model: Model::FollowUp,    key: 'FollowUp'    },
        'LeaseActions' => { model: Model::LeaseAction, key: 'LeaseAction' },
        'Quotes'       => { model: Model::Quote,       key: 'Quote'       },
        'Screenings'   => { model: Model::Screening,   key: 'Screening'   },
        'UnitsShown'   => { model: Model::UnitShown,   key: 'UnitShown'   }
      }
      SINGLE_CHILDREN = %w[Appointment Preferences]
      private_constant :MULTIPLE_CHILDREN, :SINGLE_CHILDREN

      private

      # @param body [Hash<String, Object>] the body of the XML response parsed
      #   into a Hash
      # @return [Array<RealPage::Model::GuestCard>] the guest_cards contained
      #   in the response
      # @raise [RealPage::Error::Base] if the response is invalid
      def parse_body(body)
        guest_cards(body).map do |guest_card|
          attrs = guest_card.merge(children(guest_card))
          attrs.delete('Amentities') # Remove the misspelled version
          Model::GuestCard.new(attrs)
        end
      end

      # @return [Hash<String,RealPage::Model] the guest_card's children that
      #   require more specialized parsing
      def custom_children(guest_card)
        {}.tap do |kids|
          if guest_card['Amentities']
            kids['Amenities'] = Amenities.new.parse(guest_card['Amentities'])
          end
          if guest_card['Prospects']
            kids['Prospects'] = Prospects.new.parse(guest_card['Prospects'])
          end
        end
      end

      # @return [Hash] the guest_card's children, parsed into RealPage::Models
      def children(guest_card)
        single_children(guest_card)
          .merge(multiple_children(guest_card))
          .merge(custom_children(guest_card))
      end

      # @return [Array<Hash<String, Object>>] an array of all GuestCard
      #   attributes
      def guest_cards(body)
        response        = body['prospectsearchResponse']
        result          = response['prospectsearchResult']
        prospect_search = result['ProspectSearch'] if result
        return [] unless prospect_search
        guest_cards     = prospect_search['GuestCards']
        Utils::ArrayFetcher.new(hash: guest_cards, key: 'GuestCard').fetch
      end

      # @return [Hash<String, Array<RealPage::Model>] the guest_card's children
      #   that can have multiple entries
      def multiple_children(guest_card)
        Hash[
          MULTIPLE_CHILDREN.map do |key, definition|
            fetcher =
              Utils::ArrayFetcher.new(definition.merge(hash: guest_card[key]))
            [key, fetcher.fetch]
          end
        ]
      end

      # @return [Hash<String,RealPage::Model] the guest_card's children that
      #   have  single entries
      def single_children(guest_card)
        Hash[
          SINGLE_CHILDREN.map do |kid|
            [kid, Model.const_get(kid).new(guest_card[kid])] if guest_card[kid]
          end.compact
        ]
      end

      def validator_classes
        [Validator::ProspectsData]
      end
    end
  end
end

# This file has a circular dependency with its sub-parsers. They file uses
# the others to help parse the inner objects of the XML, and that file's class
# definition is nested within this class.
#
# Having the require at the bottom of the file keeps the class loader happy
require_relative 'guest_cards/prospects'
require_relative 'guest_cards/amenities'