require_relative 'rpc/organizations/organizations_twirp'

class Namara
  # organization
  def create_organization(organization = {})
    response = rpc_request(organization_client) do |client|
      client.create_organization(serialize_organization(organization), rpc_headers)
    end

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

  def get_organization(organization_id)
    response = rpc_request(organization_client) do |client|
      client.get_organization({ id: organization_id }, rpc_headers)
    end

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

  def list_organizations(filter = {})
    payload = {
        filter: {
            offset:           { value: filter.fetch(:offset, nil) },
            limit:            { value: filter.fetch(:limit, nil) },
            organization_ids: filter.fetch(:organization_ids, nil)
        }
    }

    response = rpc_request(organization_client) do |client|
      client.list_organizations(payload, rpc_headers)
    end

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

  def update_organization(organization = {})
    response = rpc_request(organization_client) do |client|
      client.update_organization(serialize_organization(organization), rpc_headers)
    end

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

  def delete_organization(organization = {})
    rpc_request(organization_client) do |client|
      client.delete_organization(serialize_organization(organization), rpc_headers)
    end
  end

  # organization_member
  def add_organization_member(organization_member = {})

    response = rpc_request(organization_client) do |client|
      client.add_organization_member(serialize_member(organization_member), rpc_headers)
    end

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

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

    response = rpc_request(organization_client) do |client|
      client.list_organization_members(payload, rpc_headers)
    end

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

  def get_organization_member(organization_id, second_user_id)
    payload = {
        organization_id: organization_id,
        user_id:         second_user_id
    }

    response = rpc_request(organization_client) do |client|
      client.get_organization_member(payload, rpc_headers)
    end

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

  def update_organization_member(organization_member = {})
    response = rpc_request(organization_client) do |client|
      client.update_organization_member(serialize_member(organization_member), rpc_headers)
    end

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

  def remove_organization_member(organization_member = {})
    rpc_request(organization_client) do |client|
      client.remove_organization_member(serialize_member(organization_member), rpc_headers)
    end
  end

  def list_organization_member_groups(organization_id, other_user_id, filter = {})
    payload = {
        organization_id: organization_id,
        user_id:         other_user_id,
        filter:          {
            offset: { value: filter.fetch(:offset, nil) },
            limit:  { value: filter.fetch(:limit, nil) }
        }
    }

    response = rpc_request(organization_client) do |client|
      client.list_organization_member_groups(payload, rpc_headers)
    end

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

  # group
  def create_group(group = {})
    response = rpc_request(organization_client) do |client|
      client.create_group(serialize_group(group), rpc_headers)
    end

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

  def get_group(group_id, organization_id)
    payload = {
        id:              group_id,
        organization_id: organization_id
    }

    response = rpc_request(organization_client) do |client|
      client.get_group(payload, rpc_headers)
    end

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

  def list_groups(organization_id, filter = {})
    payload = {
        organization_ids: Array(organization_id),
        filter:           {
            offset: { value: filter.fetch(:offset, nil) },
            limit:  { value: filter.fetch(:limit, nil) }
        }
    }

    response = rpc_request(organization_client) do |client|
      client.list_groups(payload, rpc_headers)
    end

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

  def update_group(group = {})
    response = rpc_request(organization_client) do |client|
      client.update_group(serialize_group(group), rpc_headers)
    end

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

  def delete_group(group = {})
    rpc_request(organization_client) do |client|
      client.delete_group(serialize_group(group), rpc_headers)
    end
  end

  # group-members
  def add_group_member(group_member = {})
    response = rpc_request(organization_client) do |client|
      client.add_group_member(serialize_member(group_member), rpc_headers)
    end

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

  def get_group_member(group_id, other_user_id)
    payload = {
        group_id: group_id,
        user_id:  other_user_id
    }

    response = rpc_request(organization_client) do |client|
      client.get_group_member(payload, rpc_headers)
    end

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

  def list_group_members(group_id, filter = {})
    payload = {
        group_id: group_id,
        filter:   {
            offset: { value: filter.fetch(:offset, nil) },
            limit:  { value: filter.fetch(:limit, nil) }
        }
    }

    response = rpc_request(organization_client) do |client|
      client.list_group_members(payload, rpc_headers)
    end

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

  def update_group_member(group_member = {})
    response = rpc_request(organization_client) do |client|
      client.update_group_member(serialize_member(group_member), rpc_headers)
    end

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

  def remove_group_member(group_member = {})
    rpc_request(organization_client) do |client|
      client.remove_group_member(serialize_member(group_member), rpc_headers)
    end
  end

  private

  def serialize_organization(organization)
    { organization: organization.to_h }
  end

  def serialize_group(group)
    { group: group.to_h }
  end

  def serialize_member(member)
    { member: member.to_h }
  end

  def organization_client
    @organization_client ||= Organizations::OrganizationsServiceClient.new(api_url)
  end
end