try
  formurla_lib = require('formurla') # in-browser path
catch err
  formurla_lib = require('../lib/formurla') # in mochaTest context
Formurla = formurla_lib.Formurla
InputStream = formurla_lib.InputStream
TokenStream = formurla_lib.TokenStream

class FormurlaManager

  formurla_prefix: '/__/'
  default_formurla: 'print("getting default_formurla from FormurlaManager")'

  constructor: (@rootPanel, @noodb, @window, @global_args) ->

    @dci_contexts = {}
    @global_args or {}
    @global_args.default_div ?= 'blurb'
    @subscribe_to_essentials()

  subscribe_to_essentials: ->
    qryTerms = [{g: 'nrn:NooronDiscriminators'}]
    @noodb.subscribe(qryTerms)

  get_location_formurla: ->
    return @extract_formurla_from_url(decodeURI(@window.location.pathname))

  set_location_formurla: (the_formurla) ->
    @window.location.pathname = @formurla_prefix + the_formurla

  update_location_formurla: (the_formurla_or_expression) ->
    if typeof the_formurla_or_expression is 'string'
      if typeof @formurla_src is 'string'
        if @formurla_src isnt the_formurla_or_expression
          @set_location_formurla(the_formurla_or_expression)

  push_formurla: (formurla) ->
    url = @window.location.origin + @formurla_prefix + formurla
    @window.history.pushState({formurla: formurla}, formurla, url)

  run_formurla: (frac, formurla_or_expression) ->
    formurla_or_expression ?= @default_formurla
    @update_location_formurla(formurla_or_expression)
    expression = null
    if @a_formurla?
      expression = formurla_or_expression
    else
      @formurla_src = formurla_or_expression
      @a_formurla = @compile_formurla(@formurla_src)
      if @a_formurla.ast.prog and @a_formurla.ast.prog.length > 0
        expression = @get_first_expression(@a_formurla)

    if expression?
      switch expression.type
        when 'call'
          func_name = expression.func.value
          func = @resolve_function(func_name)
        when 'var'
          func = @find_visualizer_for(expression.value)
        else # eg: num, str
          func = @resolve_function('print')
          @noodb.log.error "not a func",expression
      if func?
        expression.the_function = func
        visualization = func.apply(@, [frac, expression])
        @noodb.log.info "just created visualization:",visualization
        return visualization
      else
        @noodb.log.error "function «#{func_name}» could not be resolved"

      if $? # if jQuery exists
        $(".formurlaAST").html( JSON.stringify(@a_formurla.ast,null,4) )
        $(".formurlaSrc").html( @formurla_src )
        $("#noorontime").show().appendTo($("#ca_2"))

    else
      msg = "no function found for: «#{@formurla_sr}» could not be resolved"
      @noodb.log.alert msg
      print = @resolve_function('print')

      visualization = print.apply(@, [frac, msg])
    return # returning null means no visualization created

  compile_formurla: (src) ->
    return new Formurla(src)

  get_first_expression: (formurla) ->
    return formurla.ast.prog[0]

  ast_to_src: (ast) ->

    @noodb.log.warning "ast_to_src() does not properly walk the tree"
    src = ""
    comma = ""
    if ast.type is 'call'
      src += ast.func.value
      src += "("
      for arg in ast.args

        if arg.type in ['var','num','str']
          src += arg.value
        if arg.type is 'assign' and arg.operator is '='
          src += "#{comma}#{arg.left.value}=#{arg.right.value},"
        comma = "," # not needed first time through
      src += ")"
      src = src.replace(/,,/g,',') # FIXME do not cause duplicate commas rather than removing them
      src = src.replace(/,\)/,')')
      return src
    else
      return 'print("... ast_to_src() does not know how to handle expression_ast.type' + "=#{ast.type}" + '")'

  replace_discriminator: (viz_inst, suppress_reload) ->
    fracpanel = viz_inst.fracpanel
    discr = viz_inst.discriminator
    viz_inst.discriminator_old
    ast = viz_inst.expression_ast
    @set_discriminator_in_ast(discr, ast)
    formurla_src = @ast_to_src(ast)

    if not suppress_reload
      @replace_formurla(fracpanel, formurla_src)

  set_discriminator_in_ast: (discr, ast) ->

    for arg in ast.args
      if arg.left and arg.left.type is 'var' and arg.left.value is 'discr'
        found = arg
        break
    if not found # ie a discriminator was NOT found

      arg =
        left:
          type: 'var'
          value: 'discr'
        operator: '='
        type: 'assign'
      ast.args.push(arg)
    if discr.uri and discr.uri.is_qname
      arg.right =
        type: 'var'
        value: discr.uri
    else
      arg.right =
        type: 'str'
        value: discr.uri and discr.uri or discr.src

    return

  replace_function: (frac, new_function_name) ->

    old_viz_inst = frac.visualization_instance
    expression_ast = old_viz_inst.expression_ast
    expression_ast.func.value = new_function_name
    formurla_src = "print(oink,said,the,duck,strangely)"
    formurla_src = @ast_to_src(expression_ast)
    @replace_formurla(frac, formurla_src)

  replace_formurla: (frac, formurla) ->
    @noodb.log.notice "replace_formurla() formurla:",formurla
    @previous_formurla = @a_formurla
    delete @a_formurla
    @run_formurla(frac, formurla)

  resolve_function: (func_name) ->
    full_name = 'BUILTIN_'+func_name
    func = @[full_name]
    if func?
      @noodb.log.info "found function #{func_name}"
    return func

  find_visualizer_for: (symbol) ->

    @resolve_function('print')

  extract_formurla_from_url: (url) ->
    parts = url.split(@formurla_prefix)
    if parts.length > 1
      return parts[1]
    return undefined

  BUILTIN_above: (frac, expression) ->
    return if not expression.args?
    expression.args.forEach (arg,idx) =>
      if idx > 0
        frac = frac.add_sibling('south')
      @run_formurla(frac, arg)

  BUILTIN_beside: (frac, expression) ->
    return if not expression.args?
    expression.args.forEach (arg,idx) =>
      if idx > 0
        frac = frac.add_sibling('east')
      @run_formurla(frac, arg)

  BUILTIN_intro: (frac, expression) ->
    @BUILTIN_showDiv(frac, {type: "var", value: @global_args.default_div})

    Array.prototype.slice.call($("#blurb xiframe")).forEach (elem) ->
      elem.outerHTML = elem.outerHTML.replace(/xiframe/,"iframe")

  BUILTIN_formurlaSrc: (frac, expression) ->

    @BUILTIN_print(frac, null, '<pre class="formurlaSrc"></pre')

  BUILTIN_formurlaAST: (frac, expression) ->

    @BUILTIN_print(frac, null, '<pre class="formurlaAST"></pre')

  BUILTIN_showDiv: (frac, expression) ->
    window.showDiv_expression = expression
    try
      selector = "#" + expression.args[0].value
    catch e
      null
    if $? and selector
       $(selector).appendTo(frac.content_area)
       $(selector).show()
    frac.visualization_button.hide()

  BUILTIN_print: (frac, expression, raw_html) ->
    if not raw_html? and expression.args and expression.args[0]
      raw_html = expression.args[0].value
    frac.content_area.html(raw_html)
    frac.visualization_button.hide()
    frac.action_button.hide()

  makeFormurlaFromDescription: (description) ->

    isa = description.thing_isa
    @noodb.log.info "makeFormurlaFromDescription()",description
    if isa is 'i'

      return "allegations(i=#{description.thing_value})"
    args = []
    if isa is 'nrn:evaluationAggregation'
      vis_id = 'evaluations'
      if description.thing_cand_id?
        args.push("s=#{description.thing_cand_id}")
      if description.thing_crit_id?
        args.push("p=#{description.thing_crit_id}")
      if description.thing_graph_id?
        args.push("g=#{description.thing_graph_id}")
    else
      if description.thing_graph_id is 'nrn:metaKB' and description.thing_cand_id?
        vis_id = 'subjects'
        args.push("g=#{description.thing_cand_id}")
    if args.length
      return "#{vis_id}(#{args.join(',')})"
    if isa in ['p','s','g']
      @noodb.log.warning "processing of description.thing.value is not principled"
      return "evaluations(#{isa}=#{description.thing_value})"
    str = "  makeFormurlaFromDescription(DESCRIPTION:   "
    for k,v of description
      if k is 'viz'
        v = v.__proto__.constructor.name
      str += "#{k}=#{v}, "
    str += ") FAILED TO PLAN A FORMURLA"
    return "print(\"#{str}\")"

  visualizeDescriptionAtFracSide: (description, frac_id, edge_id) ->
    formurla_src = @makeFormurlaFromDescription(description)

    msg = "FORMURLA: #{formurla_src} FRAC #{frac_id} EDGE #{edge_id}"
    @noodb.log.info msg
    frac_id ?= description.frac_id # if no frac_id then use the current one
    if edge_id?
      the_panel = @rootPanel.split_frac_on_side(frac_id, edge_id)
      @run_formurla_src_in_panel(formurla_src, the_panel)
    else
      @replace_formurla(@rootPanel.get_frac(frac_id), formurla_src)
      return

  run_formurla_src_in_panel: (the_src, the_panel) ->
    formurla = new Formurla(the_src)
    expression = formurla.ast.prog[0]
    return @run_formurla(the_panel, expression)

  getContext: (ctxName) ->

    @contextCache ?= {} # assign if empty
    @contextCache[ctxName] ?= require(ctxName)
    @contextCache[ctxName].makeContext(@)

(exports ? this).FormurlaManager = FormurlaManager