module Expressive
  require 'json'
  class Scope
    def initialize(parent = {})
      @parent = parent
      @symbols = {}
    end

    def [](name)
      @symbols[name] || @parent[name]
    end

    def []=(name, value)
      @symbols[name] = value
    end

    def merge(scope)
      @symbols.merge!(scope)
    end

    def override_scope(scope)
      scope.merge!(@symbols)
      @symbols = scope
    end

    def retrieve_scope
      @symbols
    end

    def define(name, &block)
      self[name] =  Function.new(&block)
    end

    def syntax(name, &block)
      self[name] =  Syntax.new(&block)
    end
  end

  class Webhook

    def initialize(verb, url, params, headers)
      @verb, @url, @params, @headers = verb, url, params, headers
    end

    def execute
      self.send(@verb)
    end

    private

      def post
        headers = {:content_type => :json, :accept => :json}
        headers = headers.merge(@headers) if @headers
        RestClient.post(@url, @params.to_json, headers)
      end

      def get
        headers = {:params => @params}
        headers = headers.merge(@headers) if @headers
        RestClient.get(@url, headers)
      end

      def put
        RestClient.put(@url, @params)
      end

  end

  class TopLevel < Scope

    def initialize
      super

      syntax('set') do |scope, cells|
        scope[cells.first.text_value] = cells[1].eval(scope)
      end

      syntax('post') do |scope, cells|
        perform_webhook(:post, scope, cells)
      end

      syntax('put') do |scope, cells|
        perform_webhook(:put, scope, cells)
      end

      syntax('get') do |scope, cells|
        perform_webhook(:get, scope, cells)
      end

      define('+') {|a,b| a.to_f + b.to_f }
      define('-') {|a,b| a.to_f - b.to_f }
      define('*') {|a,b| a.to_f * b.to_f }
      define('/') {|a,b| a.to_f / b.to_f }
      define('=') {|a,b| a == b }
      define('>') {|a,b| a.to_f > b.to_f }
      define('<') {|a,b| a.to_f < b.to_f }
      define('>=') {|a,b| a.to_f >= b.to_f }
      define('<=') {|a,b| a.to_f <= b.to_f }
      define('and') {|a,b| !!a && !!b }
      define('or') {|a,b| !!a || !!b }
      define('sum') { |*args| args.flatten.map(&:to_f).reduce(:+) }
      define('if') { |*args| args.compact!; args[0] ? args[1] : args[2] }
    end

    def to_hash
      h = self.retrieve_scope.dup
      h.delete_if{|k, v| v.kind_of?(Expressive::Function)}
    end

    private

    #(post "http://example.com" "*" (headers "AUTH-TOKEN=13415") )
    #(post "http://example.com" name email john smith (headers "AUTH-TOKEN=13415") )

    def perform_webhook(verb, scope, cells)
      #convert cells to array so it can manipulated easily
      cells_array = cells.map{|c| c.text_value.gsub('"', '')}
      url = cells_array.shift
      headers = create_webhook_headers(cells_array)
      params = create_webhook_parameters(scope, cells_array)
      begin
        response = Webhook.new(verb, url, params, headers).execute
        scope = scope.merge(response) if response.is_a?(Hash)
      rescue RestClient::Exception => e
        scope['_errors'] = e.message
      end
      scope
    end

    def create_webhook_headers(cells)
      header_position = cells.index("headers")
      return if header_position.nil?
      headers = cells[header_position + 1..-1]
      cells.delete("headers")
      headers.each{|h| cells.delete(h)}
      headers.inject({}) do |header, h|
        idx = h.index("=")
        header[h[0..(idx-1)]] = h[(idx+1)..-1]
        header
      end
    end

    def create_webhook_parameters(scope, cells)
      if cells.first && cells.first == '*'
        scope.to_hash
      else
        cells.inject({}) do |params, key|
          params[key] = scope[key]
          params
        end
      end
    end
  end
end