global

def self.read_map(maps_files_paths, output_path, logging, game_type, processing_type)
    maps_output_path = File.join(output_path, 'maps.txt')
    names_output_path = File.join(output_path, 'names.txt')
    maps_trans_output_path = File.join(output_path, 'maps_trans.txt')
    names_trans_output_path = File.join(output_path, 'names_trans.txt')

    if processing_type == :default && (File.exist?(maps_trans_output_path) || File.exist?(names_trans_output_path))
        puts 'maps_trans.txt or names_trans.txt file already exists. If you want to forcefully re-read all files, use --force flag, or --append if you want append new text to already existing files.'
        return
    end

    maps_object_map = Hash[maps_files_paths.map do |filename|
        [File.basename(filename), Marshal.load(File.binread(filename))]
    end]

    maps_lines = IndexSet.new
    names_lines = IndexSet.new

    maps_translation_map = nil
    names_translation_map = nil

    if processing_type == :append
        if File.exist?(maps_trans_output_path)
            maps_translation_map = Hash[File.readlines(maps_output_path, chomp: true)
                                            .zip(File.readlines(maps_trans_output_path, chomp: true))]
            names_translation_map = Hash[File.readlines(names_output_path, chomp: true)
                                             .zip(File.readlines(names_trans_output_path, chomp: true))]
        else
            puts "Files aren't already parsed. Continuing as if --append flag was omitted."
            processing_type = :default
        end
    end

    # 401 - dialogue lines
    # 102 - dialogue choices array
    # 402 - one of the dialogue choices from the array
    # 356 - system lines/special texts (do they even exist before mv?)
    allowed_codes = [401, 102, 402, 356].freeze

    maps_object_map.each do |filename, object|
        display_name = object.display_name

        if display_name.is_a?(String)
            display_name = display_name.strip

            unless display_name.empty?
                names_translation_map.insert_at_index(names_lines.length, display_name, '') if processing_type == :append &&
                    !names_translation_map.include?(display_name)

                names_lines.add(display_name)
            end
        end

        events = object.events
        next if events.nil?

        events.each_value do |event|
            pages = event.pages
            next if pages.nil?

            pages.each do |page|
                list = page.list
                next if list.nil?

                in_sequence = false
                line = []

                list.each do |item|
                    code = item.code

                    unless allowed_codes.include?(code)
                        if in_sequence
                            joined = line.join('\#').strip
                            parsed = parse_parameter(401, joined, game_type)

                            maps_translation_map.insert_at_index(maps_lines.length, parsed, '') if processing_type == :append &&
                                !maps_translation_map.include?(parsed)

                            maps_lines.add(parsed)

                            line.clear
                            in_sequence = false
                        end
                        next
                    end

                    parameters = item.parameters

                    if code == 401
                        next unless parameters[0].is_a?(String) && !parameters[0].empty?

                        in_sequence = true
                        line.push(parameters[0])
                    elsif parameters[0].is_a?(Array)
                        parameters[0].each do |subparameter|
                            next unless subparameter.is_a?(String)

                            subparameter = subparameter.strip
                            next if subparameter.empty?

                            parsed = parse_parameter(code, subparameter, game_type)
                            next if parsed.nil?

                            maps_translation_map.insert_at_index(maps_lines.length, parsed, '') if processing_type == :append &&
                                !maps_translation_map.include?(parsed)

                            maps_lines.add(parsed)
                        end
                    elsif parameters[0].is_a?(String)
                        parameter = parameters[0].strip
                        next if parameter.empty?

                        parsed = parse_parameter(code, parameter, game_type)
                        next if parsed.nil?

                        parsed = parsed.gsub(/\r?\n/, '\#')

                        maps_translation_map.insert_at_index(maps_lines.length, parsed, '') if processing_type == :append &&
                            !maps_translation_map.include?(parsed)

                        maps_lines.add(parsed)
                    end
                end
            end
        end

        puts "Parsed #{filename}" if logging
    end

    maps_original_content,
        maps_translated_content,
        names_original_content,
        names_translated_content = if processing_type == :append
                                       [maps_translation_map.keys.join("\n"),
                                        maps_translation_map.values.join("\n"),
                                        names_translation_map.keys.join("\n"),
                                        names_translation_map.values.join("\n")]
                                   else
                                       [maps_lines.join("\n"),
                                        "\n" * (maps_lines.empty? ? 0 : maps_lines.length - 1),
                                        names_lines.join("\n"),
                                        "\n" * (names_lines.empty? ? 0 : names_lines.length - 1)]
                                   end

    File.binwrite(maps_output_path, maps_original_content)
    File.binwrite(maps_trans_output_path, maps_translated_content)
    File.binwrite(names_output_path, names_original_content)
    File.binwrite(names_trans_output_path, names_translated_content)
end