# encoding: utf-8

module Punchblock
  module Component
    class Output < ComponentNode

      include HasHeaders

      register :output, :output

      class Document < RayoNode
        register :document, :output

        SSML_CONTENT_TYPE = 'application/ssml+xml'

        # @return [String] the URL from which the fetch the grammar
        attribute :url

        # @return [String] the document content type
        attribute :content_type, String, default: ->(grammar, attribute) { grammar.url ? nil : SSML_CONTENT_TYPE }

        # @return [String, RubySpeech::SSML::Speak, URIList] the document
        attribute :value

        def inherit(xml_node)
          super
          self.value = if ssml?
            RubySpeech::SSML.import xml_node.content
          elsif urilist?
            URIList.import xml_node.content
          else
            xml_node.content
          end
          self
        end

        def rayo_attributes
          {
            'url' => url,
            'content-type' => content_type
          }
        end

        def rayo_children(root)
          root.cdata xml_value
          super
        end

        private

        def xml_value
          if ssml?
            value.to_s
          elsif urilist?
            value.to_s
          elsif
            value
          end
        end

        def ssml?
          content_type == SSML_CONTENT_TYPE
        end

        def urilist?
          content_type == 'text/uri-list'
        end
      end

      def inherit(xml_node)
        document_nodes = xml_node.xpath 'ns:document', ns: self.class.registered_ns
        self.render_documents = document_nodes.to_a.map { |node| Document.from_xml node }
        super
      end

      # @return [String] the TTS voice to use
      attribute :voice, String

      # @return [Symbol] input type on which to interrupt output
      attribute :interrupt_on, Symbol

      # @return [Integer] Indicates some offset through which the output should be skipped before rendering begins.
      attribute :start_offset, Integer

      # @return [true, false] Indicates wether or not the component should be started in a paused state to be resumed at a later time.
      attribute :start_paused, Boolean

      # @return [Integer] Indicates the duration of silence that should space repeats of the rendered document.
      attribute :repeat_interval, Integer

      # @return [Integer] Indicates the number of times the output should be played.
      attribute :repeat_times, Integer

      # @return [Integer] Indicates the maximum amount of time for which the output should be allowed to run before being terminated. Includes repeats.
      attribute :max_time, Integer

      # @return [String] the rendering engine requested by the component
      attribute :renderer, String

      def rayo_attributes
        {
          'voice' => voice,
          'interrupt-on' => interrupt_on,
          'start-offset' => start_offset,
          'start-paused' => start_paused,
          'repeat-interval' => repeat_interval,
          'repeat-times' => repeat_times,
          'max-time' => max_time,
          'renderer' => renderer
        }
      end

      def rayo_children(root)
        render_documents.each do |render_document|
          render_document.to_rayo root.parent
        end
        super
      end

      # @return [Document] the document to render
      attribute :render_documents, Array[Document], default: []

      ##
      # @param [Hash] other
      # @option other [String] :content_type the document content type
      # @option other [String] :value the output doucment
      # @option other [String] :url the url from which to fetch the document
      #
      def render_document=(other)
        self.render_documents = [other].compact
      end

      def ssml=(other)
        self.render_documents = [{:value => other}]
      end

      state_machine :state do
        event :paused do
          transition :executing => :paused
        end

        event :resumed do
          transition :paused => :executing
        end
      end

      # Pauses a running Output
      #
      # @return [Command::Output::Pause] an Rayo pause message for the current Output
      #
      # @example
      #    output_obj.pause_action.to_xml
      #
      #    returns:
      #      <pause xmlns="urn:xmpp:rayo:output:1"/>
      def pause_action
        Pause.new :component_id => component_id, :target_call_id => target_call_id
      end

      ##
      # Sends an Rayo pause message for the current Output
      #
      def pause!
        raise InvalidActionError, "Cannot pause a Output that is not executing" unless executing?
        pause_action.tap do |action|
          result = write_action action
          paused! if result
        end
      end

      ##
      # Create an Rayo resume message for the current Output
      #
      # @return [Command::Output::Resume] an Rayo resume message
      #
      # @example
      #    output_obj.resume_action.to_xml
      #
      #    returns:
      #      <resume xmlns="urn:xmpp:rayo:output:1"/>
      def resume_action
        Resume.new :component_id => component_id, :target_call_id => target_call_id
      end

      ##
      # Sends an Rayo resume message for the current Output
      #
      def resume!
        raise InvalidActionError, "Cannot resume a Output that is not paused." unless paused?
        resume_action.tap do |action|
          result = write_action action
          resumed! if result
        end
      end

      class Pause < CommandNode # :nodoc:
        register :pause, :output
      end

      class Resume < CommandNode # :nodoc:
        register :resume, :output
      end

      ##
      # Creates an Rayo seek message for the current Output
      #
      # @return [Command::Output::Seek] a Rayo seek message
      #
      # @example
      #    output_obj.seek_action.to_xml
      #
      #    returns:
      #      <seek xmlns="urn:xmpp:rayo:output:1"/>
      def seek_action(options = {})
        Seek.new({ :component_id => component_id, :target_call_id => target_call_id }.merge(options)).tap do |s|
          s.original_component = self
        end
      end

      ##
      # Sends a Rayo seek message for the current Output
      #
      def seek!(options = {})
        raise InvalidActionError, "Cannot seek an Output that is already seeking." if seeking?
        seek_action(options).tap do |action|
          write_action action
        end
      end

      state_machine :seek_status, :initial => :not_seeking do
        event :seeking do
          transition :not_seeking => :seeking
        end

        event :stopped_seeking do
          transition :seeking => :not_seeking
        end
      end

      class Seek < CommandNode # :nodoc:
        register :seek, :output

        attribute :direction
        attribute :amount

        def request!
          source.seeking!
          super
        end

        def execute!
          source.stopped_seeking!
          super
        end

        def rayo_attributes
          {'direction' => direction, 'amount' => amount}
        end
      end

      ##
      # Creates an Rayo speed up message for the current Output
      #
      # @return [Command::Output::SpeedUp] a Rayo speed up message
      #
      # @example
      #    output_obj.speed_up_action.to_xml
      #
      #    returns:
      #      <speed-up xmlns="urn:xmpp:rayo:output:1"/>
      def speed_up_action
        SpeedUp.new(:component_id => component_id, :target_call_id => target_call_id).tap do |s|
          s.original_component = self
        end
      end

      ##
      # Sends a Rayo speed up message for the current Output
      #
      def speed_up!
        raise InvalidActionError, "Cannot speed up an Output that is already speeding." unless not_speeding?
        speed_up_action.tap do |action|
          write_action action
        end
      end

      ##
      # Creates an Rayo slow down message for the current Output
      #
      # @return [Command::Output::SlowDown] a Rayo slow down message
      #
      # @example
      #    output_obj.slow_down_action.to_xml
      #
      #    returns:
      #      <speed-down xmlns="urn:xmpp:rayo:output:1"/>
      def slow_down_action
        SlowDown.new(:component_id => component_id, :target_call_id => target_call_id).tap do |s|
          s.original_component = self
        end
      end

      ##
      # Sends a Rayo slow down message for the current Output
      #
      def slow_down!
        raise InvalidActionError, "Cannot slow down an Output that is already speeding." unless not_speeding?
        slow_down_action.tap do |action|
          write_action action
        end
      end

      state_machine :speed_status, :initial => :not_speeding do
        event :speeding_up do
          transition :not_speeding => :speeding_up
        end

        event :slowing_down do
          transition :not_speeding => :slowing_down
        end

        event :stopped_speeding do
          transition [:speeding_up, :slowing_down] => :not_speeding
        end
      end

      class SpeedUp < CommandNode # :nodoc:
        register :'speed-up', :output

        def request!
          source.speeding_up!
          super
        end

        def execute!
          source.stopped_speeding!
          super
        end
      end

      class SlowDown < CommandNode # :nodoc:
        register :'speed-down', :output

        def request!
          source.slowing_down!
          super
        end

        def execute!
          source.stopped_speeding!
          super
        end
      end

      ##
      # Creates an Rayo volume up message for the current Output
      #
      # @return [Command::Output::VolumeUp] a Rayo volume up message
      #
      # @example
      #    output_obj.volume_up_action.to_xml
      #
      #    returns:
      #      <volume-up xmlns="urn:xmpp:rayo:output:1"/>
      def volume_up_action
        VolumeUp.new(:component_id => component_id, :target_call_id => target_call_id).tap do |s|
          s.original_component = self
        end
      end

      ##
      # Sends a Rayo volume up message for the current Output
      #
      def volume_up!
        raise InvalidActionError, "Cannot volume up an Output that is already voluming." unless not_voluming?
        volume_up_action.tap do |action|
          write_action action
        end
      end

      ##
      # Creates an Rayo volume down message for the current Output
      #
      # @return [Command::Output::VolumeDown] a Rayo volume down message
      #
      # @example
      #    output_obj.volume_down_action.to_xml
      #
      #    returns:
      #      <volume-down xmlns="urn:xmpp:rayo:output:1"/>
      def volume_down_action
        VolumeDown.new(:component_id => component_id, :target_call_id => target_call_id).tap do |s|
          s.original_component = self
        end
      end

      ##
      # Sends a Rayo volume down message for the current Output
      #
      def volume_down!
        raise InvalidActionError, "Cannot volume down an Output that is already voluming." unless not_voluming?
        volume_down_action.tap do |action|
          write_action action
        end
      end

      state_machine :volume_status, :initial => :not_voluming do
        event :voluming_up do
          transition :not_voluming => :voluming_up
        end

        event :voluming_down do
          transition :not_voluming => :voluming_down
        end

        event :stopped_voluming do
          transition [:voluming_up, :voluming_down] => :not_voluming
        end
      end

      class VolumeUp < CommandNode # :nodoc:
        register :'volume-up', :output

        def request!
          source.voluming_up!
          super
        end

        def execute!
          source.stopped_voluming!
          super
        end
      end

      class VolumeDown < CommandNode # :nodoc:
        register :'volume-down', :output

        def request!
          source.voluming_down!
          super
        end

        def execute!
          source.stopped_voluming!
          super
        end
      end

      class Complete
        class Finish < Event::Complete::Reason
          register :finish, :output_complete
        end

        class MaxTime < Event::Complete::Reason
          register :'max-time', :output_complete
        end
      end
    end # Output
  end # Command
end # Punchblock