module Semian

def [](name)
  resources[name]
end

def bulkheads_disabled_in_thread?(thread)
  thread.thread_variable_get(THREAD_BULKHEAD_DISABLED_VAR)
end

def consumers
  @consumers ||= {}
end

def create_bulkhead(name, **options)
  return if ENV.key?("SEMIAN_BULKHEAD_DISABLED") || bulkheads_disabled_in_thread?(Thread.current)
  return unless options.fetch(:bulkhead, true)
  permissions = options[:permissions] || default_permissions
  timeout = options[:timeout] || 0
  ::Semian::Resource.new(
    name,
    tickets: options[:tickets],
    quota: options[:quota],
    permissions: permissions,
    timeout: timeout,
  )
end

def create_circuit_breaker(name, **options)
  return if ENV.key?("SEMIAN_CIRCUIT_BREAKER_DISABLED")
  return unless options.fetch(:circuit_breaker, true)
  require_keys!([:success_threshold, :error_threshold, :error_timeout], options)
  exceptions = options[:exceptions] || []
  CircuitBreaker.new(
    name,
    success_threshold: options[:success_threshold],
    error_threshold: options[:error_threshold],
    error_threshold_timeout: options[:error_threshold_timeout],
    error_timeout: options[:error_timeout],
    error_threshold_timeout_enabled: if options[:error_threshold_timeout_enabled].nil?
                                       true
                                     else
                                       options[:error_threshold_timeout_enabled]
                                     end,
    exceptions: Array(exceptions) + [::Semian::BaseError],
    half_open_resource_timeout: options[:half_open_resource_timeout],
    implementation: implementation(**options),
  )
end

def destroy(name)
  resource = resources.delete(name)
  resource&.destroy
end

def destroy_all_resources
  resources.values.each(&:destroy)
  resources.clear
end

def disable_bulkheads_for_thread(thread)
  old_value = thread.thread_variable_get(THREAD_BULKHEAD_DISABLED_VAR)
  thread.thread_variable_set(THREAD_BULKHEAD_DISABLED_VAR, true)
  yield
ensure
  thread.thread_variable_set(THREAD_BULKHEAD_DISABLED_VAR, old_value)
end

def disabled?
  ENV.key?("SEMIAN_SEMAPHORES_DISABLED") || ENV.key?("SEMIAN_DISABLED")
end

def implementation(**options)
  # thread_safety_disabled will be replaced by a global setting
  # Semian is thread safe by default. It is possible
  # to modify the value by using Semian.thread_safe=
  unless options[:thread_safety_disabled].nil?
    logger.info(
      "NOTE: thread_safety_disabled will be replaced by a global setting" \
        "Semian is thread safe by default. It is possible" \
        "to modify the value by using Semian.thread_safe=",
    )
  end
  thread_safe = options[:thread_safety_disabled].nil? ? Semian.thread_safe? : !options[:thread_safety_disabled]
  thread_safe ? ::Semian::ThreadSafe : ::Semian::Simple
end

def issue_disabled_semaphores_warning
  return if defined?(@warning_issued)
  @warning_issued = true
  if !sysv_semaphores_supported?
    logger.info("Semian sysv semaphores are not supported on #{RUBY_PLATFORM} - all operations will no-op")
  elsif disabled?
    logger.info("Semian semaphores are disabled, is this what you really want? - all operations will no-op")
  end
end

def register(name, **options)
  return UnprotectedResource.new(name) if ENV.key?("SEMIAN_DISABLED")
  circuit_breaker = create_circuit_breaker(name, **options)
  bulkhead = create_bulkhead(name, **options)
  if circuit_breaker.nil? && bulkhead.nil?
    raise ArgumentError, "Both bulkhead and circuitbreaker cannot be disabled."
  end
  resources[name] = ProtectedResource.new(name, bulkhead, circuit_breaker)
end

def require_keys!(required, options)
  diff = required - options.keys
  unless diff.empty?
    raise ArgumentError, "Missing required arguments for Semian: #{diff}"
  end
end

def reset!
  @consumers = {}
  @resources = LRUHash.new
end

def resources
  @resources ||= LRUHash.new
end

def retrieve_or_register(name, **args)
  # If consumer who retrieved / registered by a Semian::Adapter, keep track
  # of who the consumer was so that we can clear the resource reference if needed.
  consumer = args.delete(:consumer)
  if consumer&.class&.include?(Semian::Adapter)
    consumers[name] ||= []
    consumers[name] << WeakRef.new(consumer)
  end
  self[name] || register(name, **args)
end

def semaphores_enabled?
  !disabled? && sysv_semaphores_supported?
end

def sysv_semaphores_supported?
  /linux/.match(RUBY_PLATFORM)
end

def thread_safe=(thread_safe)
  @thread_safe = thread_safe
end

def thread_safe?
  return @thread_safe if defined?(@thread_safe)
  @thread_safe = true
end

def unregister(name)
  resource = resources.delete(name)
  if resource
    resource.bulkhead&.unregister_worker
    consumers_for_resource = consumers.delete(name) || []
    consumers_for_resource.each do |consumer|
      if consumer.weakref_alive?
        consumer.clear_semian_resource
      end
    rescue WeakRef::RefError
      next
    end
  end
end

def unregister_all_resources
  resources.keys.each do |resource|
    unregister(resource)
  end
end