class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::UseCase
  name "to-csv"
  type :export

  attr_reader :session, :options, :people

  def main(people, session, options, usecase)
    options[:end_get] = false
    @session = session; @options = options; @people = people

    unless people && !people.empty?
      session.logger.warn("No source people to create the file... aborting!")
      return false
    end

    session.logger.info("going to create file: #{file}")
    header = spot_header

    CSV.open(file, "w") do |csv|
      csv << header
      people.each do |person|
        csv << to_row(person)
      end
    end
  end

  private

  def to_row(person)
    entry = to_entry_type(person)
    entry.values_at(*keys(entry))
  end

  def spot_header
    header = keys(to_entry_type(people.first))
    header = yield(header) if block_given?
    header = nice_header_names(header) if nice_header_names?
    header
  end

  def keys(entry)
    entry.keys - ["freemium", "send_invites"]
  end

  def nice_header_names?
     options.dig(:nice_header) || options.dig(:export, :options, :nice_header)
  end

  def nice_header_names(header)
    name_maps = session.schema.fields_by_alt_id.each_with_object({}) do |(alt_id, fld), mappings|
      mappings[alt_id] = fld.name
    end.merge({
      "policy_group_ids"   => "User Group(s)",
      "email"              => "Email",
      "name"               => "Name",
      "supervisor_id"      => "Manager ID",
      "filter_tags"        => "Locations",
      "default_tag"        => "Default Location",
      "id"                 => "ecoPortal ID",
      "external_id"        => "Reference ID (ext_id)",
      "login_provider_ids" => "Login Methods",
      "landing_page_id"    => "Landing Page ID",
      "show_sidebar"       => "(pref) Sidebar Open?",
      "show_shortcuts"     => "(pref) Link to Registers?",
      "show_coming_soon"   => "(pref) Coming Soon List?",
      "show_recently_visited_forms" => "(pref) Recently Visited Forms List?",
      "show_tasks"         => "(pref) Tasks List?",
      "show_task_bubbles"  => "(pref) Task Count Bubbles",
      "kiosk_enabled"      => "Kiosk User?",
      "freemium"           => "Freemium User?",
      "files"              => "(able) on Files",
      "reports"            => "(able) on Report Structures",
      "data"               => "(able) on Data (hours, datasets)",
      "organization"       => "(able) on Organization Config",
      "pages"              => "(able) on Page/Entries",
      "page_editor"        => "(able) page Editor Level",
      "registers"          => "(able) on Registers",
      "tasks"              => "(able) on Tasks",
      "person_core"        => "(able) on People",
      "person_core_create" => "(able) Create People?",
      "person_core_edit"   => "(able) Edit People?",
      "person_details"     => "(able) on People Schema Details",
      "person_account"     => "(able) on Users",
      "person_abilities"   => "(able) on Users' Abilities",
      "custom_files"              => "(min) on Files",
      "custom_reports"            => "(min) on Report Structures",
      "custom_data"               => "(min) on Data (hours, datasets)",
      "custom_organization"       => "(min) on Organization Config",
      "custom_pages"              => "(min) on Page/Entries",
      "custom_page_editor"        => "(min) page Editor Level",
      "custom_registers"          => "(min) on Registers",
      "custom_tasks"              => "(min) on Tasks",
      "custom_person_core"        => "(min) on People",
      "custom_person_core_create" => "(min) Create People?",
      "custom_person_core_edit"   => "(min) Edit People?",
      "custom_person_details"     => "(min) on People Schema Details",
      "custom_person_account"     => "(min) on Users",
      "custom_person_abilities"   => "(min) on Users' Abilities"
    })
    header.map {|name| name_maps[name] ? name_maps[name] : name}
  end

  def to_entry_type(person)
    session.new_entry(person, dependencies: deps).yield_self do |person_entry|
      options.dig(:export, :options, :internal_names) ? person_entry.mapped_entry : person_entry.external_entry
    end
  end

  def deps
    @deps ||= {"supervisor_id" => {people: people}}
  end

  def file
    @file ||= (options[:file] || options.dig(:export, :file, :name)).tap do |filename|
      unless filename
        session.logger.error("Destination file not specified")
        return false
      end
    end
  end


end