require_relative 'rpc/references/references_twirp'
require_relative 'helpers/object_to_hash'

class Namara
  def create_reference(reference = {})
    response = rpc_request(reference_client) do |client|
      client.create_reference(serialize_reference(reference), rpc_headers)
    end

    OpenStruct.new(response.data.reference.to_h)
  end

  def list_references(organization_id, filter = {})
    payload = {
        organization_id: organization_id,
        filter:          {
            offset:    { value: filter.fetch(:offset, nil) },
            limit:     { value: filter.fetch(:limit, nil) },
            user_id:   filter.fetch(:user_id, nil),
            sort_by:   filter.fetch(:sort_by, nil),
            sort_asc:  filter.fetch(:sort_asc, nil),
            from:      filter.fetch(:from, nil),
            to:        filter.fetch(:to, nil),
            filter_by: filter.fetch(:filter_by, nil),
            source_id: filter.fetch(:source_id, nil),
            state:     filter.fetch(:state, nil),
        }
    }

    response = rpc_request(reference_client) do |client|
      client.list_references(payload, rpc_headers)
    end

    OpenStruct.new(references: ObjectToHash.to_hash_array(response.data.references.to_a), total_count: response.data.total_count)
  end

  def get_reference(reference_id, organization_id)
    payload = { id: reference_id, organization_id: organization_id }

    response = rpc_request(reference_client) do |client|
      client.get_reference(payload, rpc_headers)
    end

    OpenStruct.new(response.data.reference.to_h)
  end

  def ingest_reference(reference_id, organization_id)
    payload = { id: reference_id, organization_id: organization_id }

    response = rpc_request(reference_client) do |client|
      client.ingest_reference(payload, rpc_headers)
    end

    OpenStruct.new(response.data.to_h)
  end

  def update_reference(reference = {})
    response = rpc_request(reference_client) do |client|
      client.update_reference(serialize_reference(reference), rpc_headers)
    end

    OpenStruct.new(response.data.reference.to_h)
  end

  def delete_reference(reference = {})
    rpc_request(reference_client) do |client|
      client.delete_reference(serialize_reference(reference), rpc_headers)
    end
  end

  def force_current_job_fail(reference_id, organization_id)
    payload = { reference_id: reference_id, organization_id: organization_id }

    rpc_request(reference_client) do |client|
      client.force_current_job_fail(payload, rpc_headers)
    end
  end

  def list_jobs(reference_id, organization_id)
    payload = { reference_id: reference_id, organization_id: organization_id }

    response = rpc_request(reference_client) do |client|
      client.list_jobs(payload, rpc_headers)
    end

    OpenStruct.new(jobs: ObjectToHash.to_hash_array(response.data.jobs.to_a), total_count: response.data.total_count)
  end

  def get_job(job_id, reference_id, organization_id)
    payload = { id: job_id, reference_id: reference_id, organization_id: organization_id }

    response = rpc_request(reference_client) do |client|
      client.get_job(payload, rpc_headers)
    end

    OpenStruct.new(response.data.job.to_h)
  end

  private

  def serialize_reference(reference)
    { reference: reference.to_h }
  end

  def reference_client
    @reference_client ||= References::ReferencesServiceClient.new(api_url)
  end

end