# frozen_string_literal: true

# Released under the MIT License.
# Copyright, 2018-2024, by Samuel Williams.
# Copyright, 2018, by Huba Nagy.
# Copyright, 2019, by Mikael Henriksson.
# Copyright, 2019, by David Ortiz.
# Copyright, 2020, by Salim Semaoune.

require_relative "context/pipeline"
require_relative "context/transaction"
require_relative "context/subscribe"
require_relative "endpoint"

require "io/endpoint/host_endpoint"
require "async/pool/controller"
require "protocol/redis/methods"

require "io/stream"

module Async
	module Redis
		# Legacy.
		ServerError = ::Protocol::Redis::ServerError
		
		class Client
			include ::Protocol::Redis::Methods
			
			module Methods
				def subscribe(*channels)
					context = Context::Subscribe.new(@pool, channels)
					
					return context unless block_given?
					
					begin
						yield context
					ensure
						context.close
					end
				end
				
				def transaction(&block)
					context = Context::Transaction.new(@pool)
					
					return context unless block_given?
					
					begin
						yield context
					ensure
						context.close
					end
				end
				
				alias multi transaction
				
				def pipeline(&block)
					context = Context::Pipeline.new(@pool)
					
					return context unless block_given?
					
					begin
						yield context
					ensure
						context.close
					end
				end
				
				# Deprecated.
				alias nested pipeline
				
				def call(*arguments)
					@pool.acquire do |connection|
						connection.write_request(arguments)
						
						connection.flush
						
						return connection.read_response
					end
				end
				
				def close
					@pool.close
				end
			end
			
			include Methods
			
			def initialize(endpoint = Endpoint.local, protocol: endpoint.protocol, **options)
				@endpoint = endpoint
				@protocol = protocol
				
				@pool = make_pool(**options)
			end
			
			attr :endpoint
			attr :protocol
			
			# @return [client] if no block provided.
			# @yield [client, task] yield the client in an async task.
			def self.open(*arguments, **options, &block)
				client = self.new(*arguments, **options)
				
				return client unless block_given?
				
				Async do |task|
					begin
						yield client, task
					ensure
						client.close
					end
				end.wait
			end
			
			protected
			
			def assign_default_tags(tags)
				tags[:endpoint] = @endpoint.to_s
				tags[:protocol] = @protocol.to_s
			end
			
			def make_pool(**options)
				self.assign_default_tags(options[:tags] ||= {})
				
				Async::Pool::Controller.wrap(**options) do
					peer = @endpoint.connect
					
					# We will manage flushing ourselves:
					peer.sync = true
					
					stream = ::IO::Stream(peer)
					
					@protocol.client(stream)
				end
			end
		end
	end
end