module Eco
  module API
    class Session < Common::Session::BaseSession
      attr_reader :batch, :policy_groups, :tagtree
      attr_reader :job_groups
      attr_reader :schemas
      attr_accessor :schema

      def initialize(init = {})
        e = init
        msg = "Expected object Eco::API::Session::Config or Eco::API::Common::Session::Environment. Given: #{init}"
        raise msg  unless e.is_a?(Session::Config) || e.is_a?(Eco::API::Common::Session::Environment)
        e = Eco::API::Common::Session::Environment.new(init, session: self) if !e.is_a?(Eco::API::Common::Session::Environment)
        super(e)

        logger.debug("LINE COMMAND: #{$0} #{ARGV.join(" ")}")

        @batch        = Batch.new(enviro)
        @task         = Task.new(enviro)
        @job_groups   = JobGroups.new(enviro)

        @use_cases    = Eco::API::UseCases::DefaultCases.new.merge(config.usecases.use_group)

        @schemas      = config.schemas
        self.schema = config.people.default_schema || @schemas.first
        @policy_groups = config.policy_groups

        @tagtree = nil
        if tree_file = config.dig('org', 'tagtree')
          tree = file_manager.load_json(tree_file) unless !tree_file
          @tagtree = Eco::API::Organization::TagTree.new(tree, enviro: enviro)
        end

        presets_custom_file = config.people.presets_custom
        presets_map_file    = config.people.presets_map

        @presets_factory = Eco::API::Organization::PresetsFactory.new({
          #policy_groups:  @policy_groups,
          presets_custom: file_manager.dir.file(presets_custom_file, should_exist: true),
          presets_map:    file_manager.dir.file(presets_map_file, should_exist: true),
          enviro:         enviro
        })
      end

      def self.configure
        Session::Config.new.tap do |conf|
          yield(conf) if block_given?
        end
      end

      # TASKS & JOBS
      def do
        @task
      end

      def mail_to(**kargs)
        @mailer ||= Eco::API::Common::Session::Mailer.new(enviro: enviro)
        @mailer.mail(**kargs)
      end

      def s3upload(content: nil, file: nil, directory: nil)
        @s3uploader ||= Eco::API::Common::Session::S3Uploader.new(enviro: enviro)
        if content && file
          @s3uploader.upload(file, content)
        elsif file
          @s3uploader.upload_file(file)
        elsif directory
          @s3uploader.upload_directory(directory)
        else
          logger.error("To use Session.s3upload, you must specify either directory, file or content and file name")
        end
      end

      def job_group(name, order: :last)
        case
        when job_groups.exists?(name)
          job_groups[name]
        else
          job_groups.new(name, order: order)
        end
      end

      def jobs_launch(simulate: false)
        job_groups.launch(simulate: simulate)
      end

      def policy_groups
        @policy_groups ||= config.policy_groups
      end

      def schema=(value)
        case value
        when String
          unless @schema = @schemas.schema(value)
            fatal "The schema with id or name '#{value}' does not exist"
          end
        when Ecoportal::API::V1::PersonSchema
          @schema = value
        else
          logger.error("Session: Missuse of 'schema=' method. Given: #{value}")
          return
        end

        @person_factory = Eco::API::Common::People::PersonFactory.new(schema: @schema)

        # TODO: check PersonEntry#to_internal and #to_external in init_attr_trackers
        # => when attr_map is avoided, it doesn't work as it should
        if map_file = config.people.fields_mapper
          mappings = map_file ? file_manager.load_json(map_file) : []
        else
          mappings = []
        end
        attr_map = Eco::Data::Mapper.new(mappings)

        @entry_factory = Eco::API::Common::People::EntryFactory.new({
          schema:        @schema,
          person_parser: config.people.parser,
          attr_map:      attr_map,
          logger:        logger
        })
        self
      end

      def new_preset(input)
        case input
        when Ecoportal::API::Internal::Person
          @presets_factory.new(*input&.account&.policy_group_ids)
        when Array
          @presets_factory.new(*input)
        else
          @presets_factory.new(input)
        end
      end

      def new_person(**keyed_args)
        @person_factory.new(**keyed_args)
      end

      def new_entry(data, dependencies: {})
        @entry_factory.new(data, dependencies: dependencies)
      end

      def entries(*args)
        @entry_factory.entries(*args)
      end

      def export(*args)
        @entry_factory.export(*args)
      end

      def csv_entries(file)
        return entries(file: file, format: :csv)
      end

      def discarded_entries
        file = config.people.discarded_file
        file = file_manager.dir.file(file)
        csv_entries(file)
      end

      def process_case(name, type: nil, **params)
        args = { session: self }.merge(params)
        fatal("Undefined usecase '#{name}' of type '#{type.to_s}'") if !@use_cases.defined?(name, type: type)
        logger.debug("Session: going to process '#{name}' defined case")
        @use_cases.case(name, type: type).launch(**args)
      end

    end
  end
end

require_relative 'session/config'
require_relative 'session/batch'
require_relative 'session/batch_status'
require_relative 'session/task'
require_relative 'session/batch_job'
require_relative 'session/batch_jobs'
require_relative 'session/job_groups'