module Ardes #:nodoc:
  # included into ActionController::Base
  module ResponseFor
    def self.included(base)
      base.class_eval do
        extend ClassMethods
        alias_method_chain :default_render, :response_for
        alias_method_chain :template_exists?, :response_for
        alias_method_chain :respond_to, :response_for
      end
    end
    
    module ClassMethods
      # response_for allows you to specify a default response for your actions that don't specify a
      # respond_to block.
      # 
      # Using response_for, you may keep the response logic out of the action, so that it can be overriden easily
      # without having to rewrite the entire action.  This is very useful when subclassing controllers.
      #
      # == Usage
      #
      #   response_for :action1 [, :action2], [,:types => [:mime, :type, :list]] [ do |format| ... end] # or
      #
      # === Example
      #
      #   class FooController < ApplicationController
      #     def index
      #       @foos = Foo.find(:all)
      #     end
      #   
      #     def show
      #       @foo = Foo.find(params[:id])
      #     end
      #   end
      #   
      #   # this controller needs to respond_to fbml on index, and
      #   # js, html and xml (templates) on index and show
      #   class SpecialFooController < FooController
      #     response_for :index do |format|
      #       format.fbml { render :inline => turn_into_facebook(@foos) }
      #     end
      #   
      #     response_for :index, :show, :types => [:html, :xml, :js]
      #   end
      #
      # === when response_for kicks in
      # 
      # response_for only kicks in if the action (or any filters) have not already redirected or rendered.
      # 
      # This means that if you foresee wanting to override your action's responses, you should write them without
      # a respond_to block, but with a response_for block (the latter can be overridden by subsequent response_fors, the 
      # former cannot)
      # 
      # === Other examples 
      #
      #   response_for :index, :types => [:fbml]    # index will respond to fbml and try to render, say, index.fbml.builder
      #
      #   response_for :update do |format|          # this example is for a resources_controller controller
      #     if !(resource.new_record? || resource.changed?) # => resource.saved?
      #       format.js { render(:update) {|page| page.replace dom_id(resource), :partial => resource }}
      #     else
      #       format.js { render(:update) {|page| page.visual_effect :shake, dom_id(resource) }}
      #     end
      #   end
      #
      # === Notes
      #
      # * If the before_filters or action renders or redirects, then response_for will not be invoked.
      # * you can stack up multiple response_for calls, the most recent has precedence
      # * the specifed block is executed within the controller instance, so you can use controller
      #   instance methods and instance variables (i.e. you can make it look just like a regular
      #   respond_to block).
      # * you can add a response_for an action that has no action method defined.  This is just like
      #   defining a template for an action that has no action method defined.
      # * you can combine the :types option with a block, the block has precedence if you specify the
      #   same mime type in both.
      def response_for(*actions, &block)
        (options = actions.extract_options!).assert_valid_keys(:types)
        
        types_block = if options[:types]
          proc {|responder| Array(options[:types]).each {|type| responder.send type}}
        end
        
        # store responses against action names
        actions.collect(&:to_s).each do |action|
          action_responses[action] ||= []
          action_responses[action].unshift types_block if types_block
          action_responses[action].unshift block if block
        end
      end
    
      # remove any response for the specified actions.  If no arguments are given,
      # then all repsonses for all actions are removed
      def remove_response_for(*actions)
        if actions.empty?
          instance_variable_set('@action_responses', nil)
        else
          actions.each {|action| action_responses.delete(action.to_s)}
        end
      end
      
      # return action_responses Hash. On initialize, set and return hash whose values are copies of superclass action_responses, if any
      def action_responses
        instance_variable_get('@action_responses') || instance_variable_set('@action_responses', copy_of_each_of_superclass_action_responses)
      end
      
      # takes any responses from the argument (a controller, or responses module) and adds them to this controller's responses
      def include_responses_from(responses_container)
        responses_container.action_responses.each do |action, responses|
          action_responses[action] ||= []
          action_responses[action].unshift(*responses)
        end
      end
      
    private
      def copy_of_each_of_superclass_action_responses
        (superclass.action_responses rescue {}).inject({}){|m,(k,v)| m.merge(k => v.dup)}
      end
    end
    
  protected
    # does a response exist for the current action?
    def response_exists?
      self.class.action_responses.keys.include?(action_name.to_s)
    end
    
    # we extend template_exists? to return true if a template OR a response exists corresponding to the current action.
    # This is so that a default render will be triggered when no action, but a repsonse does exist.
    def template_exists_with_response_for?
      response_exists? || template_exists_without_response_for?
    end
 
    # if there are responses for the current action, then respond_to them
    #
    # we rescue the case where there were no responses, so that the default_render
    # action will be performed
    def respond_to_action_responses
      if !@respond_to_performed && (responses = self.class.action_responses[action_name]) && responses.any?
        respond_to do |responder|
          responses.each {|response| instance_exec(responder, &response) }
        end rescue Responder::NoResponsesError
      end
    end
    
    # this method is invoked if we've got to the end of an action without
    # performing, which is when we respond_to any repsonses defined 
    def default_render_with_response_for
      respond_to_action_responses
      default_render_without_response_for unless performed?
    end
    
    def respond_to_with_response_for(*args, &block)
      @respond_to_performed = true
      respond_to_without_response_for(*args, &block)
    end
    
    # included into ActionController::MimeResponds::Responder
    module Responder
      class NoResponsesError < RuntimeError; end
      
      def self.included(responder)
        responder.class_eval do
          # we make the responder raise an error if there are no responses
          def respond_with_response_for
            raise NoResponseError if @responses.empty?
            respond_without_response_for
          end
          alias_method_chain :respond, :response_for
        end
      end
    end
    
    module VERSION #:nodoc:
      MAJOR = 0
      MINOR = 2
      TINY  = 1
 
      STRING = [MAJOR, MINOR, TINY].join('.')
    end
  end
end