class Smplkit::ManagementClient::LoggersNamespace

def _update_logger(logger)
  response = ErrorMapping.call { @api.update_logger(logger.id || logger.name, logger_body(logger)) }
  Smplkit::Logging::Helpers.logger_resource_to_model(self, ResourceShim.from_model(response.data))
end

def delete(id)
  normalized = Smplkit::Logging::Normalize.normalize_logger_name(id)
  ErrorMapping.call { @api.delete_logger(normalized) }
  true
end

def flush
  batch = @buffer.drain
  return if batch.empty?
  items = batch.map do |entry|
    SmplkitGeneratedClient::Logging::LoggerBulkItem.new(
      id: entry["id"],
      resolved_level: entry["resolved_level"],
      level: entry["level"],
      service: entry["service"],
      environment: entry["environment"]
    )
  end
  body = SmplkitGeneratedClient::Logging::LoggerBulkRequest.new(loggers: items)
  ErrorMapping.call { @api.bulk_register_loggers(body) }
rescue StandardError => e
  Smplkit.debug("registration", "logger flush failed: #{e.class}: #{e.message}")
end

def get(id)
  normalized = Smplkit::Logging::Normalize.normalize_logger_name(id)
  response = ErrorMapping.call { @api.get_logger(normalized) }
  Smplkit::Logging::Helpers.logger_resource_to_model(self, ResourceShim.from_model(response.data))
end

def get_logger_entry(id)
  normalized = Smplkit::Logging::Normalize.normalize_logger_name(id)
  response = ErrorMapping.call { @api.get_logger(normalized) }
  logger_entry_from_resource(ResourceShim.from_model(response.data))
end

def initialize(api_client)
  @api = SmplkitGeneratedClient::Logging::LoggersApi.new(api_client)
  @buffer = Management::LoggerRegistrationBuffer.new
end

def list(page_number: nil, page_size: nil)
  opts = {}
  opts[:page_number] = page_number unless page_number.nil?
  opts[:page_size] = page_size unless page_size.nil?
  response = ErrorMapping.call { @api.list_loggers(opts) }
  (response.data || []).map do |r|
    Smplkit::Logging::Helpers.logger_resource_to_model(self, ResourceShim.from_model(r))
  end
end

def list_logger_entries
  rows = PaginatedFetch.collect { |opts| @api.list_loggers(opts) }
  rows.to_h { |r| logger_entry_from_resource(ResourceShim.from_model(r)) }
end

def logger_body(logger)
  # Logger server schema: name, level, group, managed.
  # +resolved_level+ is read-only, +service+/+environment+ are
  # observed via bulk register, +description+ is wrapper-local.
  SmplkitGeneratedClient::Logging::LoggerResponse.new(
    data: SmplkitGeneratedClient::Logging::LoggerResource.new(
      type: "logger",
      id: logger.id,
      attributes: SmplkitGeneratedClient::Logging::Logger.new(
        name: logger.name,
        level: logger.level&.to_s,
        group: logger.log_group_id,
        managed: logger.managed
      )
    )
  )
end

def logger_entry_from_resource(resource)
  attrs = resource["attributes"] || {}
  [
    resource["id"],
    {
      "level" => attrs["level"],
      "group" => attrs["group"],
      "managed" => attrs.key?("managed") ? attrs["managed"] : true,
      "environments" => attrs["environments"] || {}
    }
  ]
end

def register(source)
  sources = source.is_a?(Array) ? source : [source]
  sources.each { |s| @buffer.add(s) }
  flush if @buffer.pending_count >= Management::LOGGER_BATCH_FLUSH_SIZE
end