class Admin::Legacy::HumanResources::AdditionalFieldsController <
  Admin::Legacy::HumanResources::Controller
  def index
    data = fields.includes(:group).by_group(params[:group_id]).ordered.map { |f| field_props(f) }
    render_success :ok, json: data
  end

  def show
    render_success :ok, json: field_props(field)
  end

  def create
    field = fields.build(field_params)
    if field.save
      render_success :ok, json: field_props(field)
    else
      render_error :unprocessable_entity, errors: field
    end
  end

  def update
    if field.update(field_params)
      render_success :ok, json: field_props(field)
    else
      render_error :unprocessable_entity, errors: field
    end
  end

  def destroy
    if field.destroy
      render_success :ok
    else
      render_error :unprocessable_entity, errors: field
    end
  end

  def order
    field_ids = params[:items].map { |i| i['id'] }
    items = fields.where(id: field_ids).map do |field|
      item = params[:items].find { |i| field.id == i['id'] }
      field.order = item['order']
      field
    end

    if transactional_save(items)
      render_success :ok, message: 'Order Updated.'
    else
      render_error :unprocessable_entity, message: 'Something went wrong.'
    end
  end

  def destroy_additional_values
    if field.destroy_attached_values
      render_success :ok, message: 'Field data cleared.'
    else
      render_error :unprocessable_entity
    end
  end

  private
    def fields
      current_school.employee_additional_fields.includes(:choices)
    end

    def field
      @field ||= fields.find_by(id: params[:id])
    end

    def field_params
      params.permit(
        :name,
        :description,
        :type,
        :public,
        :validation_type,
        :validation_pattern,
        :required,
        :order,
        choices_attributes: [:id, :name, :value, :order, :_destroy]
      ).merge(set_group)
    end

    def group
      @group ||= current_school.employee_additional_groups.find_by(id: params[:group_id])
    end

    def set_group
      {}.tap do |props|
        props[:group] = group if params.key?(:group_id)
      end
    end

    def field_props(field)
      {}.tap do |prop|
        prop[:id] = field.id
        prop[:name] = field.name
        prop[:description] = field.description
        prop[:type] = field.type
        prop[:public] = field.public?
        prop[:validation_type] = field.validation_type
        prop[:validation_pattern] = field.validation_pattern
        prop[:required] = field.required
        prop[:order] = field.order
        prop[:group_id] = field.group_id
        prop[:group_name] = field.group.name
        return prop if action_name.to_sym == :index

        prop[:choices_attributes] = field.choices.order(:order).map { |c| choice_props(c) }
        prop[:employees_with_values] = field.employees_with_values
      end
    end

    def choice_props(choice)
      {
        id: choice.id,
        name: choice.name,
        value: choice.value,
        order: choice.order
      }
    end
end