module Eco
  module API
    module Common
      module People
        # TODO: EntryFactory should suppport multiple schemas itself
        #   (rather that being done on `Session`)
        # => currently, it's through session.entry_factory(schema: id),
        #   but this is wrong
        # => This way, Entries and PersonEntry will be able to refer to attr_map
        #   and person_parser linked to schema_id
        # => "schema_id" should be an optional column in the input file,
        #   or parsable via a custom parser to scope the schema
        # Helper factory class to generate entries (input entries).
        # @attr_reader schema [Ecoportal::API::V1::PersonSchema] person schema to
        #   be used in this entry factory
        class EntryFactory < Eco::API::Common::Session::BaseSession
          include Eco::Data::Files

          attr_reader :schema

          # @param e [Eco::API::Common::Session::Environment] requires a session environment,
          #   as any child of `Eco::API::Common::Session::BaseSession`
          # @param schema [Ecoportal::API::V1::PersonSchema] schema of person details that
          #   the parser will be based upon.
          # @param person_parser [nil, Eco::API::Common::People::PersonParser]
          #   set of attribute, type and format parsers/serializers.
          # @param attr_map [nil, Eco::Data::Mapper] attribute names mapper
          #   to translate external names into internal ones and _vice versa_.
          def initialize(e, schema:, person_parser: nil, default_parser: nil, attr_map: nil)
            super(e)

            msg = "Constructor needs a PersonSchema. Given: #{schema.class}"
            fatal msg unless schema.is_a?(Ecoportal::API::V1::PersonSchema)

            msg = "Expecting PersonParser. Given: #{person_parser.class}"
            fatal msg if person_parser && !person_parser.is_a?(Eco::API::Common::People::PersonParser)

            msg = "Expecting Mapper object. Given: #{attr_map.class}"
            fatal msg if attr_map && !attr_map.is_a?(Eco::Data::Mapper)

            @schema = Ecoportal::API::V1::PersonSchema.new(JSON.parse(schema.doc.to_json))
            @source_person_parser = person_parser

            # load default parser + custom parsers
            @default_parser = default_parser&.new(schema: @schema) || Eco::API::Common::People::DefaultParsers.new(schema: @schema)
            base_parser = @default_parser.merge(@source_person_parser)
            # new parser with linked schema
            @person_parser = @source_person_parser.new(schema: @schema).merge(base_parser)
            @person_parser_patch_version = @source_person_parser.patch_version
            @attr_map = attr_map
          end

          def newFactory(schema: nil) # rubocop:disable Naming/MethodName
            self.class.new(
              environment,
              schema:         schema,
              person_parser:  @source_person_parser,
              default_parser: @default_parser,
              attr_map:       @attr_map
            )
          end

          # provides with a Eco::API::Common::People::PersonParser object (collection of attribute parsers)
          # @note if the custom person parser has changed, it updates the copy of this EntryFactory instance
          # @return [Eco::API::Common::People::PersonParser] set of attribute, type and format parsers/serializers.
          def person_parser
            if @person_parser_patch_version < @source_person_parser.patch_version
              @person_parser.merge(@source_person_parser)
              @person_parser_patch_version = @source_person_parser.patch_version
            end
            @person_parser
          end

          # key method to generate objects of `PersonEntry` that share dependencies
          # via this `EntryFactory` environment.
          # @note this method is necessary to make the factory object work
          #   as a if it was a class `PersonEntry` you can call `new` on.
          # @param data [Hash, Person] data to be parsed/serialized.
          #   Parsed: the external hashed entry. Serialized: a Person object.
          # @return [Eco::API::Common::People::PersonEntry]
          def new(data, dependencies: {})
            PersonEntry.new(
              data,
              person_parser: person_parser,
              attr_map:      @attr_map,
              dependencies:  dependencies,
              logger:        logger
            )
          end

          # Helper that provides a collection of `Entries`, which in turn provides
          # with further helpers to find and exclude entries.
          # It accepts a `file:` and `format:` or `data:` but not both options together.
          # @raise Exception
          #   - if you try to provide `data:` and `file:` at the same time.
          #   - if you provide `file:` but omit `format:`.
          #   - if the `format:` you provide is not a `Symbol`.
          #   - if there is no _parser/serializer_ defined for `format:`.
          # @param data [Array<Hash>] data to be parsed. It cannot be used alongside with `file:`
          # @param file [String] absolute or relative path to the input file. It cannot be used alongside with `data:`.
          # @param format [Symbol] it must be used when you use the option `file:` (i.e. `:xml`, `:csv`), as it specifies the format of the input `file:`.
          # @param options [Hash] further options.
          # @option options [String] :encoding optional parameter to read `file:` by expecting certain encoding.
          # @option options [Boolean] :check_headers signals if the `csv` file headers should be expected.
          # @return [Eco::API::Common::People::Entries] collection of `Eco::API::Common::People::PersonEntry`.
          def entries(data: (no_data = true; nil), file: (no_file = true; nil), format: (no_format = true; nil), **options) # rubocop:disable Style/Semicolon
            msg = "You should at least use data: or file:, but not both"
            fatal msg if no_data == no_file

            msg = "You must specify a valid format: (symbol) when you use file."
            fatal msg if file && no_format

            msg = "Format should be a Symbol. Given '#{format}'"
            fatal msg if format && !format.is_a?(Symbol)

            msg = "There is no parser/serializer for format ':#{format}'"
            fatal msg unless no_format || @person_parser.defined?(format)

            options.merge!(content:  data)     unless no_data
            options.merge!(file:     file)     unless no_file
            options.merge!(format:   format)   unless no_format

            Entries.new(to_array_of_hashes(**options), klass: PersonEntry, factory: self)
          end

          def to_array_of_hashes(**kargs) # rubocop:disable Metrics/AbcSize
            content, file, encoding, format = kargs.values_at(:content, :file, :encoding, :format)

            # Support for multiple file
            if file.is_a?(Array)
              return file.each_with_object([]) do |f, out|
                log(:info) { "Parsing file '#{f}'" }
                curr = to_array_of_hashes(**kargs.merge(file: f))
                out.concat(curr)
              end
            end

            # Get content only when it's not :xls, nor :json
            # note: even if content was provided, file takes precedence
            if get_content?(format) && file # rubocop:disable Style/IfUnlessModifier
              content = get_file_content(file, encoding: encoding)
            end

            case content
            when Hash
              log(:error) {
                "Input data as 'Hash' not supported. Expecting 'Enumerable' or 'String'"
              }
              exit(1)
            when String
              deps = {check_headers: true} if kargs[:check_headers]
              to_array_of_hashes(content: person_parser.parse(format, content, deps: deps || {}))
            when Enumerable
              sample = content.to_a.first
              case sample
              when Hash, Array, ::CSV::Row
                Eco::CSV::Table.new(content).to_array_of_hashes
              when NilClass
                abort("There is NO input data")
              else
                abort("Input content 'Array' of '#{sample.class}' is not supported.")
              end
            else
              if file && format == :xls
                person_parser.parse(format, file)
              else
                abort("Could not obtain any data out of these: #{kargs}. Given content: '#{content.class}'")
              end
            end.tap do |out_array|
              start_from_two = (format == :csv) || format == :xls
              first_idx      = start_from_two ? 2 : 1

              out_array.each.with_index(first_idx) do |entry_hash, idx|
                entry_hash["idx"]         = idx
                entry_hash["source_file"] = file
              end
            end
          end

          # Helper that generates a file out of `data:`.
          # @raise Exception
          #   - if you try to provide `data:` in the wrong format.
          #   - if you `file:` is empty.
          #   - if the `format:` you provide is not a `Symbol`.
          #   - if there is no _parser/serializer_ defined for `format:`.
          # @param data [Eco::API::Organization::People] data to be parsed.
          # @param file [String] absolute or relative path to the ouput file.
          # @param format [Symbol] it specifies the format of the output `file:` (i.e. `:xml`, `:csv`).
          #   There must be a parser/serializer defined for it.
          # @param encoding [String] optional parameter to geneate `file:` content by unsing certain encoding.
          # @return [Void].
          def export(data:, file: "export", format: :csv, encoding: "utf-8", internal_names: false)
            msg = "data: Expected Eco::API::Organization::People object. Given: #{data.class}"
            fatal msg unless data.is_a?(Eco::API::Organization::People)

            fatal "A file should be specified."                   if file.to_s.strip.empty?
            fatal "Format should be a Symbol. Given '#{format}'"  if format && !format.is_a?(Symbol)

            msg = "There is no parser/serializer for format ':#{format}'"
            fatal msg unless @person_parser.defined?(format)

            run = true
            if self.class.file_exists?(file)
              prompt_user(
                "Do you want to overwrite it? (Y/n):",
                explanation: "The file '#{file}' already exists.",
                default:     "Y"
              ) do |response|
                run = (response == "") || response.upcase.start_with?("Y")
              end
            end

            return unless run

            deps         = {"supervisor_id" => {people: data}}
            data_entries = data.map do |person|
              new(person, dependencies: deps).then do |entry|
                internal_names ? entry.mapped_entry : entry.external_entry
              end
            end

            File.open(file, "w", enconding: encoding) do |fd|
              fd.write(person_parser.serialize(format, data_entries))
            end
          end

          private

          def get_content?(format)
            return false if format == :xls
            return false if format == :json

            true
          end

          def abort(message)
            log(:error) { message }
            exit(1)
          end

          def fatal(msg)
            log(:fatal) { msg }
            raise msg
          end
        end
      end
    end
  end
end