require 'stringio'

module V8
  module C
    class Context
      def enter
        if block_given?
          Enter()
          begin
            yield(self)
          ensure
            Exit()
          end
        end
      end
    end
  end
  
  class Context    
    attr_reader :native
    def initialize(opts = {})      
      @native = C::Context.new(opts[:with])
    end
    
    def open
      @native.enter do
        yield(self)
      end if block_given?
    end
    
    def eval(javascript, filename = "<eval>", line = 1)
      if IO === javascript || StringIO === javascript
        javascript = javascript.read()
      end      
      @native.Enter()
      begin
        C::TryCatch.try do |try|
          script = C::Script::Compile(To.v8(javascript.to_s), To.v8(filename.to_s))
          raise JavascriptError.new(try) if try.HasCaught()
          result = script.Run()
          raise JavascriptError.new(try) if try.HasCaught()
          To.ruby(result)
        end                
      ensure
        @native.Exit()
      end
    end
    
    # def eval(javascript, sourcename = '<eval>', line = 1)
    #   if IO === javascript || StringIO === javascript
    #     javascript = javascript.read()
    #   end
    #   @native.open do        
    #     @native.eval(javascript, sourcename).tap do |result|
    #       raise JavascriptError.new(result) if result.kind_of?(C::Message)
    #       return To.ruby(result)
    #     end
    #   end
    # end
        
    def evaluate(*args)
      self.eval(*args)
    end
    
    def load(filename)
      File.open(filename) do |file|
        evaluate file, filename, 1
      end      
    end
    
    def [](key)
      open do
        To.ruby(@native.Global().Get(key.to_s))
      end
    end
    
    def []=(key, value)
      value.tap do 
        open do
          @native.Global().tap do |scope|
            scope.Set(key.to_s, value)
          end
        end
      end
    end
    
    def self.open(opts = {}, &block)
      new(opts).open(&block)
    end
    
    def self.eval(source)
      new.eval(source)
    end
    
    def V8.eval(*args)
      V8::Context.eval(*args)
    end
  end
  
  class ContextError < StandardError
    def initialize(caller_name)
      super("tried to call method '#{caller_name} without an open context")
    end
    def self.check_open(caller_name)
      raise new(caller_name) unless C::Context::InContext()
    end
  end
  
  class JavascriptError < StandardError
    attr_reader :source_name, :source_line, :line_number, :javascript_stacktrace
    
    def initialize(try)
      msg = try.Message()
      @source_name = To.ruby(msg.GetScriptResourceName())
      @source_line = To.ruby(msg.GetSourceLine())
      @line_number = To.ruby(msg.GetLineNumber())
      @javascript_stacktrace = To.ruby(try.StackTrace())
      super("#{To.ruby(msg.Get())}: #{@source_name}:#{@line_number}")
    end

  end
  class RunawayScriptError < ContextError
  end
end