CsvGenerator

csv_generator.rb

class CsvGenerator
  CONFIG_PATH = File.join(File.dirname(__FILE__), "../../config/energy")
  DEFAULT_YML_URL = File.join(CONFIG_PATH, "items/defaults.yml")
  OUTPUT_FOLDER = File.join(File.dirname(__FILE__), "output/")

  @loaded_yml = {}
  @object_fields = []
  @object_states_fields = []
  @source = ""

  def default_fields
    return ['id','name','declare','parent','super_class', 'enabled']
  end

  def description_fields
    return ['description_ru', 'description_ko', 'desription_numeral_ru', 'desription_numeral_ko', 'description_text_ru', 'description_text_ko']
  end

  def csv_params
    return {}
  end

  def parent_item
    return @loaded_yml[csv_params["parent_name"]]
  end

  def get_special_item_data(parent, data)
    return (parent == csv_params['parent_name'] or csv_params['parent_name'].empty? or parent.empty?) ? data : nil
  end

  def item_data_values(roll_percent, item_data, max_values100p, items_count)
    item_data_values = ""
    min_quantity = item_data["min_quantity"].to_s||""
    max_quantity = item_data["max_quantity"].to_s||""
    min_value = item_data["min_value"].to_i||0
    max_value = item_data["max_value"].to_i||0
    unlocker = item_data["unlocker"].to_s||""
    item_data_values += min_quantity + (!max_quantity.empty? ? "-" + max_quantity : "")
    roll_div = roll_percent/100;
    comma = !item_data_values.empty? ? "," : ""
    if max_values100p
      item_data_values += comma + sprintf("%.1f", 100.0/items_count) + "%"
    else
      if(max_value > 0 && min_value == 0 && roll_percent > 0)
        item_data_values += comma + "0-" + (max_value.to_f/roll_div).to_s + "%"
      else
         if(max_value > 0 && min_value > 0 && roll_percent > 0)
           item_data_values += comma + ((max_value.to_f - (min_value.to_f-1))/roll_div).to_s + "%"
         end
      end
    end
    if(!unlocker.empty?)
      item_data_values += comma + unlocker
    end
    return item_data_values
  end

  def check_for_sum_max_values100percents(roll_percent, roll_data)
    roll_data[roll_data.length-1].each_value do |data|
      if roll_percent != 0 && roll_percent == data["max_value"].to_i
        return true
      end
    end
    return false
  end

  def generate_roll_items(roll_percent, roll_data)
    max_values100p = check_for_sum_max_values100percents(roll_percent, roll_data)
    roll_items_data = []
    roll_data.each do |item|
      item.each_pair do |item_name, item_data|
        roll_items_data.push(item_name + ":" + item_data_values(roll_percent, item_data, max_values100p, roll_data.length))
      end
    end
    return roll_items_data.join("\n")
  end

  def generate_rolls_array(action_data)
    roll_arr = []
    empty_roll_ind=0
    action_data.each do |roll|
      roll_data_object = {"params" => "", "items" => ""}
      params = []
      roll_percent = 0
      roll.each_pair do |roll_key, roll_data|
        if(roll_key != 'items')
          if(roll_key == 'roll')
            roll_percent = roll_data.to_i
            next
          end
          params.push(roll_key.to_s + ":" + roll_data.to_s)
        end
      end
      if(params.length<=0)
        params.push("temp-reward-" + empty_roll_ind.to_s)
        empty_roll_ind+=1
      end
      roll_data_object["params"] = params.join("\n")
      roll_data_object["items"] += generate_roll_items(roll_percent, roll['items'])
      roll_arr.push(roll_data_object)
    end
    return roll_arr
  end

  def generate_state_params(state)
    params_arr = []
    state.each do |key, value|
      if(key != 'drop')
        params_arr.push(key.to_s+":"+value.to_s)
      end
    end
    return params_arr.join("\n")
  end

  def generate_object_states(object_states_data)
    object_states = {}
    state_params = {}
    state_ind = 0
    object_states_data.each do |state|
      object_states["state" + "-" + state_ind.to_s] = {}
      state_params["state" + "-" + state_ind.to_s] = generate_state_params(state)
      object_states["state" + "-" + state_ind.to_s] = generate_state_data(state, state_ind)
      state_ind+=1
    end
    return object_states, state_params
  end

  def generate_state_data(state, state_ind)
    action_object = {}
    state.each do |state_data_key, state_data|
      if(state_data_key == 'drop')
        state_data.each_pair do |action_key, action_data|
          roll_arr = generate_rolls_array(action_data)
          action_object[action_key + "-" + state_ind.to_s] = roll_arr
        end
      end
    end
    return action_object
  end

  def add_object_states_fields(object_states, object_states_params)
    return {} if object_states.length == 0
    new_fields = {}
    object_states.each_pair do |state_key, state_value|
      new_fields[state_key] = object_states_params[state_key]||""
      state_value.each_key do |action_key|
        new_fields[action_key] = ""
      end
    end
    set_header_fields(new_fields.keys, @object_states_fields)
    return new_fields
  end

  def add_object_fields(item_data)
    new_fields = prepare_item_data(item_data)

    set_header_fields(new_fields.keys, @object_fields)
    return new_fields
  end

  def generate_description_field_data(field, item_data)
    data = ""
    case field
      when 'desription_numeral_ru'
        data = item_data['description_acc_ru'].to_s + "\n" + item_data['description_acc2_ru'].to_s + "\n" + item_data['description_acc5_ru'].to_s
        item_data['description_acc_ru'] = item_data['description_acc2_ru'] = item_data['description_acc5_ru'] = nil
      when 'desription_numeral_ko'
        data = item_data['description_acc_ko'].to_s + "\n" + item_data['description_acc2_ko'].to_s + "\n" + item_data['description_acc5_ko'].to_s
        item_data['description_acc_ko'] = item_data['description_acc2_ko'] = item_data['description_acc5_ko'] = nil
      else
        if(item_data[field] && !item_data[field].to_s.empty?)
          data = item_data[field]
          item_data[field] = nil
        end
    end
    return data, item_data
  end

  def prepare_item_data(item_data)
    item_data = item_data.select {|k, v| k != 'object_states' && !k.is_a?(Syck::MergeKey)}

    item_data = generate_description_fields(item_data)

    item_data.each_pair do |k, v|
      item_data[k] = generate_field_data(k, v)
    end
    return item_data
  end

  def generate_description_fields(item_data)
    return item_data if description_fields.nil? or description_fields.length == 0
    new_fields = {}
    fields_to_delete = []
    item_data.each_pair do |key, data|
      new_key = key.sub(/\.ru$/, "_ru")
      new_key = new_key.sub(/\.ko$/, "_ko")
      new_fields[new_key] = data
      fields_to_delete.push(key)
    end
    item_data = item_data.select {|k, v| !fields_to_delete.index(k)}.merge(new_fields)

    def_fields = {}

    description_fields.each do |f|
      def_fields[f], item_data = generate_description_field_data(f, item_data)
    end
    def_fields = def_fields.delete_if {|k, v| v.nil? or v.nil?}
    item_data = item_data.delete_if {|k, v| v.nil? or v.nil?}
    item_data = def_fields.merge(item_data)
    return item_data
  end

  def get_object_states_in_rows(object_states)
    rows = {}
    object_states.each_pair do |st_key, state|
      rows[st_key] = []
      state.each_value do |action_data|
        for i in 0..action_data.length-1 do
          data = action_data[i]
          next if(!rows[st_key].index(data["params"]).nil?)
          rows[st_key].push(data["params"])
        end
      end
    end
    object_states.each_pair do |st_key, state|
      state.each_pair do |action, action_data|
        rows[action] = Array.new(rows[st_key].length, "")
        action_data.each do |data|
          rows[action][rows[st_key].index(data["params"])] = data["items"]
        end
      end
    end

    #clear temp rewards
    rows = clear_temp_rewards(object_states, rows)

    return rows
  end

  def clear_temp_rewards(object_states, rows)
    object_states.each_key do |st_key|
      for i in 0..rows[st_key].length-1 do
        rows[st_key][i] = "" if rows[st_key][i].index('temp-reward')
      end
    end
    return rows
  end

  def get_max_object_states_rows(object_states_rows)
    max_rows = 0
    object_states_rows.each_pair do |key, value|
      max_rows = value.length if(value.length > max_rows)
    end
    return max_rows
  end

  def generate_field_data(field_name, field_data)
    data = ""
    case field_name
      when 'quest_tag'
        data = field_data.join("\n")
      #when other special fields
      else
        data = field_data.to_s
    end
    return data
  end

  def set_header_fields(arr_fields, fields)
    (default_fields+arr_fields).each do |field|
      fields.push(field) if (fields.index(field).nil?)
    end
  end

  def perform_header(header_fields)
    for i in 0..header_fields.length-1 do
      if (header_fields[i].split('-').length == 2 && header_fields[i].split('-')[0]!='state')
        header_fields[i] = header_fields[i].split('-')[0].to_s
      end
    end
    return header_fields
  end

  def csv_row_header
    return sorted_object_fields + sorted_object_states_fields
  end

  def sorted_object_fields
    object_fields = @object_fields

    object_default_fields = []
    (default_fields + description_fields).each do |f|
      object_default_fields.push(f) if(object_fields.index(f))
    end
    sorted_fields = object_default_fields + object_fields.select {|f| object_default_fields.index(f).nil?}

    return sorted_fields
  end

  def sorted_object_states_fields()
    states = @object_states_fields.select{|i| i.split("-")[0] == "state"}

    sorted_fields = []
    states.each do |state|
      sorted_fields.push(state)
      sorted_fields += @object_states_fields.select {|i| i!= state && i.split("-")[1] == state.split("-")[1]}
    end

    return sorted_fields
  end

  def csv_row_data(value)
    rdata = []
    csv_row_header.each do |field|
      rdata.push(value[field].to_s||"")
    end
    return rdata
  end

  def init_empty_object(row)
    new_obj = {}
    row.each_pair do |k, v|
      new_obj[k] = k == "id" ? v : ""
    end
    return new_obj
  end

  def add_object_states_rows(row, object_states_actions)
    arr_to_csv = []
    object_states_rows = get_object_states_in_rows(object_states_actions)

    max_rows = get_max_object_states_rows(object_states_rows)
    for i in 0..max_rows-1 do
      new_object = init_empty_object(row)
      object_states_rows.each_pair do |rkey, rvalue|
        new_object[rkey] = rvalue[i]||""
      end
      arr_to_csv.push(new_object)
    end
    return arr_to_csv
  end

  def generate_csv
    @loaded_yml = {}
    @object_fields = []
    @object_states_fields = []
    puts "================================================"
    puts "Start generating CSV: #{csv_params["template_name"]}"
    @source = Tfp.load(csv_params["source_url"])
    @loaded_yml = YAML.load(@source)
    arr_to_csv = []
    @loaded_yml.each_pair do |name, data|
      next if !data['enabled'].nil? && data['enabled'].to_s.downcase == 'false'
      row = {
          'id' => data['id'],
          'name' => name,
          'declare' => @source[Regexp.new(name.to_s+'\s*:\s*&(\w+)'),1],
          'parent' => @source[Regexp.new(name.to_s+'\s*:[^<]{,30}<<\s*:\s\*(\w+)'),1]
      }

      item_data = get_special_item_data(row['parent'], data)
      next if item_data.nil?

      row = row.merge(add_object_fields(item_data))

      if item_data['object_states'].nil? or item_data['object_states'].to_s.empty?
        arr_to_csv.push(row)
        next
      end

      object_states_actions, object_states_params = generate_object_states(item_data['object_states'])
      row = row.merge(add_object_states_fields(object_states_actions, object_states_params))
      arr_to_csv.push(row)

      #add rows with object sates
      arr_to_csv = arr_to_csv.concat(add_object_states_rows(row, object_states_actions))
    end
    save_to_csv(arr_to_csv)
  end

  def save_to_csv(arr_to_csv)
    csv_data = CSV.generate() do |csv| #col_sep:" "
      header = perform_header(csv_row_header)
      csv << header
      arr_to_csv.each do |value|
        csv << csv_row_data(value)
      end
    end
    File.new(csv_params["output_file"], "w").write(csv_data)
    puts "Generating CSV: #{csv_params["template_name"]} ....... OK"
  end

end