Layer Reference: Auth → Client → Fetcher → Builder → Entity

module ServiceName
  class Auth
    include HTTParty

    DEFAULT_TIMEOUT = 30

    class Error < StandardError; end

    def self.default
      new(
        client_id: config[:service_client_id],
        client_secret: config[:service_client_secret],
        account_id: config[:service_account_id],
        auth_adapter: AuthAdapter.default
      )
    end

    def initialize(client_id:, client_secret:, account_id:, auth_adapter:, timeout: DEFAULT_TIMEOUT)
      raise ArgumentError, 'Missing required credentials' if [client_id, client_secret, account_id].any?(&:blank?)
      @client_id     = client_id
      @client_secret = client_secret
      @account_id    = account_id
      @auth_adapter  = auth_adapter
      @timeout       = timeout
      @token         = nil
    end

    def token
      return @token if @token

      @token = @auth_adapter.fetch_token(
        client_id: @client_id,
        client_secret: @client_secret,
        timeout: @timeout
      )
      raise Error, 'Auth failed' if @token.blank?
      @token
    end
  end
end

module ServiceName
  class Client
    include HTTParty

    MISSING_CONFIGURATION_ERROR = 'Missing required configuration'
    DEFAULT_TIMEOUT = 30
    DEFAULT_RETRIES = 3

    class Error < StandardError; end

    QUERY_PATH = '/api/query'

    def self.default
      token = Auth.default.token
      host  = config[:service_host]
      new(token:, http_adapter: HttpAdapter.default(host:))
    end

    def initialize(token:, http_adapter:, timeout: DEFAULT_TIMEOUT, max_retries: DEFAULT_RETRIES)
      raise Error, MISSING_CONFIGURATION_ERROR if [token, http_adapter].any?(&:blank?)
      @token        = token
      @http_adapter = http_adapter
      @timeout      = timeout
      @max_retries  = max_retries
    end

    def execute_query(payload)
      parsed = @http_adapter.post_json(
        path: QUERY_PATH,
        payload: payload,
        bearer_token: @token,
        timeout: @timeout
      )
      raise Error, 'Malformed API response' unless parsed.is_a?(Hash)

      parsed
    rescue JSON::ParserError, HttpAdapter::Error => e
      raise Error, "Request failed: #{e.class}"
    end
  end
end

module ServiceName
  class Fetcher
    MAX_RETRIES = 3
    RETRY_DELAY_IN_SECONDS = 2

    def initialize(client, data_builder:, default_query:)
      @client        = client
      @data_builder  = data_builder
      @default_query = default_query
    end

    def execute_query(query = @default_query)
      raw_response = @client.execute_query(query)
      @data_builder.build(raw_response)
    end
    alias query execute_query
  end
end

module ServiceName
  class Builder
    def initialize(attributes:)
      @attributes = attributes
    end

    def build(response)
      schema     = Array(response.dig('manifest', 'schema', 'columns'))
      data_array = Array(response.dig('result', 'data_array'))
      data_array.map { |row| build_hash(schema, row).slice(*@attributes) }
    end

    private

    def build_hash(schema, row)
      schema.each_with_index.with_object({}) do |(col, idx), hash|
        hash[String(col['name'])] = row[idx]
      end
    end
  end
end

RSpec.describe ServiceName::Client do
  let(:token) { 'tok' }
  let(:http_adapter) { instance_double('HttpAdapter') }

  subject(:client) { described_class.new(token:, http_adapter:) }

  describe '#execute_query' do
    context 'when the adapter returns malformed data' do
      before { allow(http_adapter).to receive(:post_json).and_return('not-a-hash') }

      it 'raises Client::Error' do
        expect { client.execute_query('SELECT 1') }.to raise_error(ServiceName::Client::Error)
      end
    end

    context 'when a network failure occurs' do
      before { allow(http_adapter).to receive(:post_json).and_raise(HttpAdapter::Error) }

      it 'raises Client::Error' do
        expect { client.execute_query('SELECT 1') }.to raise_error(ServiceName::Client::Error)
      end
    end
  end

  describe '.new' do
    context 'when token is blank' do
      it 'raises Client::Error with the missing configuration message' do
        expect { described_class.new(token: '', http_adapter:) }
          .to raise_error(ServiceName::Client::Error, ServiceName::Client::MISSING_CONFIGURATION_ERROR)
      end
    end
  end
end

module ServiceName
  class Animal
    ATTRIBUTES    = %w[tag_number name species_id shelter_id].freeze
    DEFAULT_QUERY = 'SELECT * FROM schema.animals;'
    SEARCH_QUERY  = 'SELECT * FROM schema.animals WHERE tag_number = ?;'

    def self.fetcher(client: Client.default)
      data_builder = Builder.new(attributes: ATTRIBUTES)
      Fetcher.new(client, data_builder:, default_query: DEFAULT_QUERY)
    end

    def self.find(tag_number:)
      query = db_sanitize([SEARCH_QUERY, tag_number])
      fetcher.execute_query(query)
    end
  end
end

# spec/factories/shelter_api/animal_response.rb
FactoryBot.define do
  factory :shelter_api_animal_response, class: Hash do
    skip_create

    sequence(:tag_number) { |n| "TAG-#{n}" }
    name       { 'Buddy' }
    species_id { 1 }
    shelter_id { 42 }
    intake_date { '2024-01-15' }
    extra_field { 'should be filtered by Builder' }

    initialize_with do
      {
        'manifest' => {
          'schema' => {
            'columns' => attributes.keys.map { |k| { 'name' => k.to_s } }
          }
        },
        'result' => {
          'data_array' => [attributes.values]
        }
      }
    end
  end
end