module Eco
  module API
    class Session
      class Batch
        # @attr_reader name [String] the name of this `batch job`
        # @attr_reader type [Symbol] a valid batch operation
        # @attr_reader sets [Array<Symbol>] the parts of the person model this batch is supposed to affect
        # @attr_reader usecase [Eco::API::UseCases::UseCase, nil] when provided: `usecase` that generated this `batch job`
        # @attr_reader status [Eco::API::Session::Batch::Status] if launched: the `status` of the `batch`
        # @attr_reader feedback [Eco::API::Session::Batch::Feedback] helper class for feedback and decision making
        class Job < Eco::API::Common::Session::BaseSession
          @types = [:get, :create, :update, :delete]
          @sets  = [:core, :details, :account]

          class << self
            attr_reader :types, :sets

            def valid_type?(value)
              types.include?(value)
            end

            def valid_sets?(value)
              sts = [value].flatten
              sts.all? { |s| sets.include?(s) }
            end
          end

          attr_reader :name, :type, :sets
          attr_reader :usecase
          attr_reader :status, :feedback

          # @param e [Eco::API::Common::Session::Environment] requires a session environmen, as any child of `Eco::API::Common::Session::BaseSession`
          # @param name [String] the name of this `batch job`
          # @param type [Symbol] a valid batch operation
          # @param usecase [Eco::API::UseCases::UseCase, nil] when provided: `usecase` that generated this `batch job`
          def initialize(e, name:, type:, sets:, usecase: nil)
            raise "A name is required to refer a job. Given: #{name}" if !name
            raise "Type should be one of #{self.class.types}. Given: #{type}"    unless self.class.valid_type?(type)
            raise "Sets should be some of #{self.class.sets}. Given: #{sets}"    unless self.class.valid_sets?(sets)
            raise "usecase must be a Eco::API::UseCases::UseCase object. Given: #{usecase.class}" if usecase && !usecase.is_a?(Eco::API::UseCases::UseCase)
            super(e)

            @name     = name
            @type     = type
            @sets     = [sets].flatten.compact
            @usecase  = usecase
            @feedback = Eco::API::Session::Batch::Feedback.new(job: self)
            reset
          end

          def reset
            @queue      = []
            @queue_hash = {}
            @callbacks  = {}
            @pending    = true
            @status     = nil
          end

          # @return [Boolean] was this `batch job` generated by a `usecase`? (`Eco::API::UseCases::UseCase`)
          def usecase?
            !!usecase
          end

          # @return [Hash] options the root `usecase` is run with
          def options
            usecase?? usecase.options : {}
          end

          # Adds an entry(ies) to the job queue.
          # @param entry [Person, Enumberable<Person>] the person(s) we want to update, carrying the changes to be done.
          # @param unique [Boolean] specifies if repeated entries should be avoided in the queue.
          # @yield [person] callback before launching the batch job request against the server.
          # @yeldparam param [Person] current person object that that should be treated by the callback before launching the batch.
          # @return [Void]
          def add(entry, unique: true, &block)
            case entry
            when Enumerable
              entry.each {|e| add(e, unique: unique, &block)}
            else
              unless !entry
                unless unique && @queue_hash.key?(entry)
                  @queue_hash[entry] = true
                  @queue.push(entry)
                  @callbacks[entry]  = Proc.new if block_given?
                end
              end
            end
          end

          #def match?(type:, sets:)
          #  sets = [sets].flatten
          #  type == self.type && (sets.order == self.sets.order)
          #end

          # @return [Boolean] has been this `batch job` launched?
          def pending?
            @pending
          end

          # @note it requires launch to be firstly invoked
          # @raise [Exception] if 'launch' has not firstly invoked
          # @return [Enumbrable<Hash>] the last requests that the queue will generate
          def requests
            raise "Method missuse. Firstly 'launch' should be invoked" unless instance_variable_defined?(:@requests)
            @requests
          end

          # @see Eco::API::Session::Batch::Feedback#request_stats
          def request_stats(requests = nil)
            feedback.request_stats(requests || self.requests)
          end

          # @see Eco::API::Session::Batch::Status#errors?
          # @return [Boolean] `true` if there were Server errors, `false` otherwise
          def errors?
            status && status.errors?
          end

          # Helper/shortcut to obtain a people object out of `input`
          # @note if `input` is not provided, it will use `queue`
          # @return [Eco::API::Organization::People]
          def people(input = @queue)
            Eco::API::Organization::People.new(input)
          end

          # Processes the `queue` and, unless `simulate` is `true`, launches against the server:
          #   1. pre_processes the queue obtaining the `requests`:
          #     - if the entries of `queue` got pending _callbacks_ (delayed changes), it processes them
          #     - unless type == `:create`: if there's a defined `api_excluded` _callback_ it calls it (see `Eco::API::Session::Config::People#api_excluded`)
          #     - transforms the result to a `Eco::API::Organization::People` object
          #     - if there are `api policies` defined, it passes the entries through them in order (see `Eco::API::Session::Config#policies`)
          #       - this step is **skipped** if the option `-skip-api-policies` was used in the command line
          #     - at this point all the transformations have taken place...
          #     - only include the entries that, after all above, still hold pending changes (`!as_update.empty?`) to be launched as update
          #   2. pre launch checks against the `requests`:
          #     - it generates `stats` (`Eco::API::Session::Batch::RequestStats`) out of the requests
          #     - if there is a batch policy declared for the current job `type`, it checks compliance against `stats` (`Eco::API::Session::Batch::Policies`),
          #       - a non-compliant batch will stop the current session by raising an `Exception`
          #       - this setp is **skipped** if the option `-skip-batch-policy` was used in the command line
          #   3. if we are **not** in `dry-run` (or `simulate`), it:
          #     - backs up the raw queries (`requests`) launched to the Server, if we are **not** in `dry-run` (or `simulate`)
          #     - **launches the batch** request against the _Server_ (see `Eco::API::Session::Batch#launch`)
          #     - links the resulting batch `status` to this `Batch::Job` (see `Eco::API::Session::Batch::Status`)
          #     - prints any `errors` replied by the _Server_
          #   4. the post launch kicks in, and:
          #     - for success requests, it consolidates the associated entries (see `Ecoportal::API::V1::Person#consolidate!`)
          #     - launches specific error handlers, if there were **errors** from the Server as a result of the `batch.launch`, and there are `Error::Handlers` defined
          # @return [Eco::API::Session::Batch::Status]
          def launch(simulate: false)
            pqueue    = processed_queue
            @requests = pqueue.map {|e| as_update(e)}

            pre_checks(requests, simulate: simulate)

            unless simulate
              if pqueue.length > 0
                backup_update(requests)
                session.batch.launch(pqueue, method: type).tap do |job_status|
                  @status     = job_status
                  status.root = self
                  status.errors.print
                end
              end
            end

            unless requests.empty?
              logger.info("--- simulate mode (dry-run) --  job '#{name}' -- this would have launched #{type.to_s.upcase}") if simulate
            end

            post_launch(queue: pqueue, simulate: simulate)
            @pending = false
            return status
          end

          # Provides a text summary of the current status
          # @note if `launch` was not invoked, it specifies so
          # @return [String] the summary
          def summary
            [].tap do |msg|
              if pending?
                msg << "PENDING - Batch #{type.to_s.upcase} - job '#{name}' - length: #{@queue.length}"
              else
                msg  << feedback.generate(requests, only_stats: true)
                if batch_policy && !batch_policy.compliant?(request_stats)
                  msg << "Batch Policy Uncompliance:"
                  msg << batch_policy.uncompliance(request_stats)
                end

                msg << status.errors.message unless !status
              end
            end.join("\n")
          end

          private

          def as_update(*args)
            feedback.as_update(*args)
          end

          def processed_queue
            @queue.each {|e| @callbacks[e].call(e) if @callbacks.key?(e) }
            apply_policies(api_included(@queue)).select {|e| !as_update(e).empty?}
          end

          # if there is a config definition to exclude entries
          # and the current batch is not a creation batch
          # - filter out excluded entries from the api update
          def api_included(full_queue)
            return full_queue if type == :create
            return full_queue unless excluded = session.config.people.api_excluded
            full_queue.select {|entry| !excluded.call(entry, session, options, self)}
          end

          def apply_policies(pre_queue)
            people(pre_queue).tap do |entries|
              policies = session.config.policies
              unless policies.empty? || options.dig(:skip, :api_policies)
                policies.launch(people: entries, session: session, options: options)
              end
            end
          end

          def batch_policy
            unless options.dig(:skip, :batch_policy)
              @batch_policy ||= session.config.batch_policies[self.type]
            end
          end

          def pre_checks(requests, simulate: false)
            only_stats = options.dig(:feedback, :only_stats)
            max_chars  = simulate ? 2500 : 800
            msg        = feedback.generate(requests, max_chars: max_chars, only_stats: only_stats)
            logger.info(msg)

            # batch_policy
            stats      = request_stats(requests)
            if simulate && batch_policy && !batch_policy.compliant?(stats)
              logger.warn("Batch Policy Uncompliance: this and next batches will be aborted!")
              logger.warn(batch_policy.uncompliance(stats))
            elsif batch_policy
              # will throw an Exception if the policy request_stats is not compliant
              batch_policy.validate!(stats)
            end
          end

          def post_launch(queue: [], simulate: false)
            if !simulate && status
              status.queue.map do |entry|
                if status.success?(entry)
                  entry.consolidate! if entry.respond_to?(:consolidate!)
                #else # do not entry.reset! (keep track on changes still)
                end
              end
              # launch_error handlers
              handlers = session.config.error_handlers
              if status.errors.any? && !handlers.empty?
                err_types = status.errors.by_type
                handlers.each do |handler|
                  if entries = err_types[handler.name]
                    handler.launch(people: people(entries), session: session, options: options)
                  end
                end
              end
            elsif simulate
              queue.map do |entry|
                entry.consolidate! if entry.respond_to?(:consolidate!)
              end
            end
          end

          def backup_update(requests)
            dir       = config.people.requests_folder
            file      = File.join(dir, "#{type}_data.json")
            file_manager.save_json(requests, file, :timestamp)
          end

        end
      end
    end
  end
end