module Eco
  module API
    module UseCases
      class UseCase
        TYPES = [:import, :filter, :transform, :sync, :export]
        ALL_PARAMS = [:input, :people, :session, :options]
        TYPE_PARAMS = {
          import:    [:input, :session],
          filter:    [:people, :session, :options],
          transform: [:people, :session],
          export:    [:people, :session, :options]
        }

        class << self
          def valid_type?(type)
            TYPES.include?(type)
          end

          def type_params(type)
            raise "Invalid type '#{type.to_s}'" if !valid_type?(type)
            TYPE_PARAMS[type]
          end
        end

        attr_reader :name, :type, :times_launched
        attr_reader :options

        def initialize(name, type:, root:, &block)
          raise "Undefined usecase type #{type}, when creating '#{name}'. Please, use any of #{TYPES}" unless self.class.valid_type?(type)

          self.root = root
          @callback = block
          @name     = name
          @type     = type
          @times_launched = 0
        end

        def chainer
          # TODO: root is a UseGroup that will not point to this new case.
          # => Moreover, the name and type will be the same as self
          Eco::API::UseCases::UseCaseChain.new(usecase: self, root: @root)
        end

        def root=(value)
          raise "Root should be a UseGroup. Given: #{value}" if !value.is_a?(UseGroup)
          @root = value
        end

        def launch(input: nil, people: nil, session:, options: {})
          @options = options
          data = UseCaseIO.new(usecase: self, input: input, people: people, session: session, options: options)

          data.output = @callback.call(data.params)
          @times_launched += 1

          data_model = {
            self => {
              io: data
            }
          }
        end

        protected

        def callback
          @callback
        end

      end

    end
  end
end