module Eco
  module API
    class Session
      class Batch < Common::Session::BaseSession

        DEFAULT_BATCH_BLOCK = 50
        VALID_METHODS =  [:get, :create, :update, :upsert, :delete]

        class << self
          # @return [Boolean] `true` if the method is supported, `false` otherwise.
          def valid_method?(value)
            VALID_METHODS.include?(value)
          end
        end

        # Gets the _people_ of the organization according `params`.
        #   If `people` is not `nil`, scopes to only the people specified.
        # @note
        #   - If `people` is given keys `page:` and `q` of `params:`.
        # @param people [Nil, People, Enumerable<Person>, Enumerable<Hash>] target _People_ to launch the batch against.
        # @param params [Hash] api request options.
        # @option params [String] :page the page number `page` based on `:per_page`.
        # @option params [String] :per_page the number of people included per each batch api request.
        # @option params [String] :q some text to search. Omit this parameter to target all the people.
        # @return [Array<People>] all the people based on `params`
        def get_people(people = nil, params: {}, silent: false)
          return launch(people, method: :get, params: params, silent: silent).people if people.is_a?(Enumerable)
          return get(params: params, silent: silent)
        end

        # launches a batch of `method` type using `people` and the specified `params`
        # @raise Exception
        #    - if `people` is `nil` or is not an `Enumerable`.
        #    - if there's no `api` connection linked to the current `Batch`.
        # @param people [People, Enumerable<Person>, Enumerable<Hash>] target _People_ to launch the batch against.
        # @param method [Symbol] the method to launch the batch api request with.
        # @param params [Hash] api request options.
        # @option params [String] :per_page the number of people included per each batch api request.
        # @return [Batch::Status] the `status` of this batch launch.
        def launch(people, method:, params: {} , silent: false)
          batch_from(people, method: method, params: params, silent: silent)
        end

        def search(data, silent: false, params: {})
          params = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)

          launch(data, method: :get, params: params, silent: silent).tap do |status|
            status.mode = :search

            entries = status.queue
            puts "\n"
            entries.each_with_index do |entry, i|
              if (i % 10 == 0)
                percent = i * 100 / entries.length
                print "Searching: #{percent.round}% (#{i}/#{entries.length} entries)\r"
                $stdout.flush
              end

              unless status.success?(entry)
                email = nil
                case
                when entry.respond_to?(:email)
                  email = entry.email
                when entry.respond_to?(:to_h)
                  email = entry.to_h["email"]
                end

                people_matching = []
                email = email.to_s.strip.downcase
                unless email.empty?
                  people_matching = get(params: params.merge(q: email), silent: silent).select do |person|
                    person.email == email
                  end
                end

                case people_matching.length
                when 1
                  status.set_person_match(entry, people_matching.first)
                when 2..Float::INFINITY
                  status.set_people_match(entry, people_matching)
                end
              end
            end
          end
        end

        private

        def get(params: {}, silent: false)
          fatal "cannot batch get without api connnection, please provide a valid api connection!" unless people_api = api&.people

          params = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
          client = people_api.client

          return people_api.get_all(params: params, silent: silent)
        end

        def batch_from(data, method:, params: {}, silent: false)
          fatal "Invalid batch method: #{method}." if !self.class.valid_method?(method)
          return nil if !data || !data.is_a?(Enumerable)
          fatal "cannot batch #{method} without api connnection, please provide a valid api connection!" unless people_api = api&.people

          # param q does not make sense here, even for GET method
          params   = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
          per_page = params[:per_page] || DEFAULT_BATCH_BLOCK

          iteration  = 1; done = 0
          iterations = (data.length.to_f / per_page).ceil

          Eco::API::Session::Batch::Status.new(enviro, queue: data, method: method).tap do |status|
            data.each_slice(per_page) do |slice|
              msg = "starting batch '#{method}' iteration #{iteration}/#{iterations}, with #{slice.length} entries of #{data.length} -- #{done} done"
              logger.info(msg) unless silent

              people_api.batch do |batch|
                slice.each do |person|
                  batch.public_send(method, person) do |response|
                    faltal("Request with no response") unless !!response
                    status[person] = response
                  end
                end
              end # next batch

              iteration += 1
              done += slice.length
            end # next slice
          end
        end

      end
    end
  end
end

require_relative 'batch/job'
require_relative 'batch/feedback'
require_relative 'batch/request_stats'
require_relative 'batch/base_policy'
require_relative 'batch/policies'
require_relative 'batch/status'
require_relative 'batch/errors'
require_relative 'batch/jobs'
require_relative 'batch/jobs_groups'