require_relative 'rpc/category/category_twirp'
require_relative 'helpers/object_to_hash'

class Namara
  def create_topic(topic = {})
    response = rpc_request(category_client) do |client|
      client.create_topic(serialize_topic(topic), rpc_headers)
    end

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

  def get_topic(topic_id, organization_id)
    payload = {
        id:              topic_id,
        organization_id: organization_id
    }

    response = rpc_request(category_client) do |client|
      client.get_topic(payload, rpc_headers)
    end

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

  def update_topic(topic = {})
    response = rpc_request(category_client) do |client|
      client.update_topic(serialize_topic(topic), rpc_headers)
    end

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

  def list_topics(organization_id, filter = {})
    payload  = {
        organization_id: organization_id,
        filter:          {
            offset: { value: filter.fetch(:offset, nil) },
            limit:  { value: filter.fetch(:limit, nil) }
        }
    }
    response = rpc_request(category_client) do |client|
      client.list_topics(payload, rpc_headers)
    end

    ObjectToHash.to_hash_array(response.data.topics.to_a)
  end

  def delete_topic(topic)
    rpc_request(category_client) do |client|
      client.delete_topic(serialize_topic(topic), rpc_headers)
    end
  end

  def set_topic(topic_id, dataset_id, organization_id)
    payload = {
        id:              topic_id,
        dataset_id:      dataset_id,
        organization_id: organization_id
    }

    response = rpc_request(category_client) do |client|
      client.set_topic(payload, rpc_headers)
    end

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

  def unset_topic(topic_id, dataset_id, organization_id)
    payload = {
        id:              topic_id,
        dataset_id:      dataset_id,
        organization_id: organization_id
    }

    rpc_request(category_client) do |client|
      client.unset_topic(payload, rpc_headers)
    end
  end

  def get_topics(dataset_id, organization_id, filter = {})
    payload  = {
        dataset_id:      dataset_id,
        organization_id: organization_id,
        filter:          {
            offset: { value: filter.fetch(:offset, nil) },
            limit:  { value: filter.fetch(:limit, nil) }
        }
    }

    response = rpc_request(category_client) do |client|
      client.get_topics(payload, rpc_headers)
    end

    ObjectToHash.to_hash_array(response.data.topics.to_a)
  end

  def get_classifications(topic_id, organization_id)
    payload  = {
        organization_id: organization_id,
        topic_id:        topic_id
    }

    response = rpc_request(category_client) do |client|
      client.get_classifications(payload, rpc_headers)
    end

    ObjectToHash.to_hash_array(response.data.classifications.to_a)
  end

  def list_datasets(topic_ids, organization_id)
    payload  = {
        organization_id: organization_id,
        topic_ids:       Array(topic_ids)
    }

    response = rpc_request(category_client) do |client|
      client.list_datasets(payload, rpc_headers)
    end

    response.data.dataset_ids.to_a
  end

  private

  def serialize_topic(topic)
    { topic: topic.to_h }
  end

  def category_client
    @category_client ||= Category::CategoryServiceClient.new(api_url)
  end
end