telegem 1.0.6 → 2.0.0

data/lib/core/bot.rb

@@ -1,8 +1,11 @@
+require 'concurrent'
+require 'logger'
+
 module Telegem
   module Core
     class Bot
-      attr_reader :token, :api, :handlers, :middleware, :logger, :scenes
-
+      attr_reader :token, :api, :handlers, :middleware, :logger, :scenes, :running
+      
       def initialize(token, **options)
         @token = token
         @api = API::Client.new(token, **options.slice(:logger, :timeout))
@@ -20,45 +23,52 @@ module Telegem
         @logger = options[:logger] || Logger.new($stdout)
         @error_handler = nil
         @session_store = options[:session_store] || Session::MemoryStore.new
+        
+        @thread_pool = Concurrent::FixedThreadPool.new(options[:max_threads] || 10)
+        @update_queue = Queue.new
+        @worker_threads = []
+        
         @polling_thread = nil
         @running = false
         @offset = nil
+        
+        start_workers(options[:worker_count] || 5)
       end
-
+      
       def command(name, **options, &block)
         pattern = /^\/#{Regexp.escape(name)}(?:@\w+)?(?:\s+(.+))?$/i
-
+        
         on(:message, text: pattern) do |ctx|
           ctx.match = ctx.message.text.match(pattern)
           ctx.state[:command_args] = ctx.match[1] if ctx.match
           block.call(ctx)
         end
       end
-
+      
       def hears(pattern, **options, &block)
         on(:message, text: pattern) do |ctx|
           ctx.match = ctx.message.text.match(pattern)
           block.call(ctx)
         end
       end
-
+      
       def on(type, filters = {}, &block)
         @handlers[type] << { filters: filters, handler: block }
       end
-
+      
       def use(middleware, *args, &block)
         @middleware << [middleware, args, block]
         self
       end
-
+      
       def error(&block)
         @error_handler = block
       end
-
+      
       def scene(id, &block)
         @scenes[id] = Scene.new(id, &block)
       end
-
+      
       def start_polling(**options)
         return if @running
         
@@ -78,9 +88,9 @@ module Telegem
         
         self
       end
-
+      
       def webhook(app = nil, port: nil, host: '0.0.0.0', logger: nil, &block)
-        require 'webhook/server'
+        require_relative '../webhook/server'
         
         if block_given?
           Webhook::Server.new(self, &block)
@@ -90,64 +100,98 @@ module Telegem
           Webhook::Server.new(self, port: port, host: host, logger: logger)
         end
       end
-
+      
       def set_webhook(url, **options)
-        @api.call('setWebhook', { url: url }.merge(options))
+        @api.call!('setWebhook', { url: url }.merge(options))
       end
-
+      
       def delete_webhook
-        @api.call('deleteWebhook', {})
+        @api.call!('deleteWebhook', {})
       end
-
+      
       def get_webhook_info
-        @api.call('getWebhookInfo', {})
+        @api.call!('getWebhookInfo', {})
       end
-
+      
       def process(update_data)
         update = Types::Update.new(update_data)
         process_update(update)
       end
-
+      
       def shutdown
         @logger.info "🛑 Shutting down..."
         
         @running = false
+        
         @polling_thread&.join(5) if @polling_thread&.alive?
+        
+        stop_workers
+        
         @api.close
         
         @logger.info "✅ Bot stopped"
       end
-
+      
       def running?
         @running
       end
-
+      
       private
-
+      
+      def start_workers(count)
+        count.times do |i|
+          @worker_threads << Thread.new do
+            worker_loop(i)
+          end
+        end
+      end
+      
+      def stop_workers
+        @worker_threads.size.times { @update_queue << :shutdown }
+        @worker_threads.each do |thread|
+          thread.join(2) if thread.alive?
+        end
+        @worker_threads.clear
+      end
+      
+      def worker_loop(id)
+        @logger.debug "Worker #{id} started" if @logger
+        while @running
+          begin
+            task = @update_queue.pop
+            break if task == :shutdown
+            
+            update_data, callback = task
+            update = Types::Update.new(update_data)
+            process_update(update)
+            callback&.call(update) if callback.respond_to?(:call)
+          rescue => e
+            @logger.error "Worker #{id} error: #{e.message}"
+          end
+        end
+        @logger.debug "Worker #{id} stopped" if @logger
+      end
+      
       def poll_loop
         while @running
           begin
-            # Get updates - returns HTTPX request immediately
             updates_request = fetch_updates
             
-            # Wait for this poll to complete (with timeout)
             response = updates_request.wait(@polling_options[:timeout] + 5)
             
             if response && response.status == 200 && response.json
               handle_updates_response(response.json)
             end
             
-            # Small delay to prevent tight loop on errors
             sleep 0.1 unless @offset.nil?
             
           rescue => e
             handle_error(e)
-            # Longer delay on error
             sleep 5
           end
         end
       end
-
+      
       def fetch_updates
         params = {
           timeout: @polling_options[:timeout],
@@ -158,30 +202,21 @@ module Telegem
         
         @api.call('getUpdates', params)
       end
-
+      
       def handle_updates_response(api_response)
         return unless api_response['ok']
         
         updates_data = api_response['result'] || []
         
-        # Process each update in its own thread for concurrency
         updates_data.each do |update_data|
-          Thread.new do
-            begin
-              update = Types::Update.new(update_data)
-              process_update(update)
-            rescue => e
-              @logger.error("Error in update thread: #{e.message}")
-            end
-          end
+          @update_queue << [update_data, nil]
         end
         
-        # Update offset for next poll
         if updates_data.any?
           @offset = updates_data.last['update_id'] + 1
         end
       end
-
+      
       def process_update(update)
         ctx = Context.new(update, self)
         
@@ -193,15 +228,15 @@ module Telegem
           handle_error(e, ctx)
         end
       end
-
+      
       def run_middleware_chain(ctx, &final)
         chain = build_middleware_chain
         chain.call(ctx, &final)
       end
-
+      
       def build_middleware_chain
         chain = Composer.new
-
+        
         @middleware.each do |middleware_class, args, block|
           if middleware_class.respond_to?(:new)
             middleware = middleware_class.new(*args, &block)
@@ -210,26 +245,26 @@ module Telegem
             chain.use(middleware_class)
           end
         end
-
+        
         unless @middleware.any? { |m, _, _| m.is_a?(Session::Middleware) }
           chain.use(Session::Middleware.new(@session_store))
         end
-
+        
         chain
       end
-
+      
       def dispatch_to_handlers(ctx)
         update_type = detect_update_type(ctx.update)
         handlers = @handlers[update_type] || []
-
+        
         handlers.each do |handler|
           if matches_filters?(ctx, handler[:filters])
             handler[:handler].call(ctx)
-            break  # First matching handler wins
+            break
           end
         end
       end
-
+      
       def detect_update_type(update)
         return :message if update.message
         return :callback_query if update.callback_query
@@ -240,10 +275,10 @@ module Telegem
         return :shipping_query if update.shipping_query
         :unknown
       end
-
+      
       def matches_filters?(ctx, filters)
         return true if filters.empty?
-
+        
         filters.all? do |key, value|
           case key
           when :text
@@ -257,27 +292,27 @@ module Telegem
           end
         end
       end
-
+      
       def matches_text_filter(ctx, pattern)
         return false unless ctx.message&.text
-
+        
         if pattern.is_a?(Regexp)
           ctx.message.text.match?(pattern)
         else
           ctx.message.text.include?(pattern.to_s)
         end
       end
-
+      
       def matches_chat_type_filter(ctx, type)
         return false unless ctx.chat
         ctx.chat.type == type.to_s
       end
-
+      
       def matches_command_filter(ctx, command_name)
         return false unless ctx.message&.command?
         ctx.message.command_name == command_name.to_s
       end
-
+      
       def handle_error(error, ctx = nil)
         if @error_handler
           @error_handler.call(error, ctx)