var Immutable = require("immutable");

var __ = "__"; /* wildcard marker */

var SOA = "__["; // start of array
var EOA = "__]"; // end of array

function die(message) {
  throw new Error(message);
}

function $Embedded(trie) {
  this.trie = trie;
}

function embeddedTrie(trie) {
  return new $Embedded(trie);
}

// The name argument should be a string or null; it defaults to null.
// The pattern argument defaults to wildcard, __.
function $Capture(name, pattern) {
  this.name = name || null;
  this.pattern = (typeof pattern === 'undefined' ? __ : pattern);
}

// Abbreviation: _$(...) <==> new $Capture(...)
function _$(name, pattern) {
  return new $Capture(name, pattern);
}

function isCapture(x) { return x instanceof $Capture || x === _$; }
function captureName(x) { return x instanceof $Capture ? x.name : null; }
function capturePattern(x) { return x instanceof $Capture ? x.pattern : __; }

var SOC = "__{{"; // start of capture
var EOC = "__}}"; // end of capture

function $Success(value) {
  this.value = value;
}

$Success.prototype.equals = function (other) {
  if (!(other instanceof $Success)) return false;
  return Immutable.is(this.value, other.value);
}

function $WildcardSequence(trie) {
  this.trie = trie;
}

$WildcardSequence.prototype.equals = function (other) {
  if (!(other instanceof $WildcardSequence)) return false;
  return Immutable.is(this.trie, other.trie);
}

function is_emptyTrie(m) {
  return Object.is(m, emptyTrie);
}

///////////////////////////////////////////////////////////////////////////
// Constructors

var emptyTrie = Immutable.Map();

function rsuccess(v) {
  return (v === null) ? emptyTrie : new $Success(v);
}

function rseq(e, r) {
  if (r === emptyTrie) return emptyTrie;
  return emptyTrie.set(e, r);
}

function rwild(r) {
  return rseq(__, r);
}

function rwildseq(r) {
  return (r === emptyTrie) ? emptyTrie : new $WildcardSequence(r);
}

///////////////////////////////////////////////////////////////////////////

function compilePattern(v, p) {
  if (!p) die("compilePattern: missing pattern");
  return walk(p, rseq(EOA, rsuccess(v)));

  function walk(p, acc) {
    if (p === __) return rwild(acc);

    if (Array.isArray(p)) {
      acc = rseq(EOA, acc);
      for (var i = p.length - 1; i >= 0; i--) {
	acc = walk(p[i], acc);
      }
      return rseq(SOA, acc);
    }

    if (p instanceof $Embedded) {
      return appendTrie(p.trie, function (v) { return acc; });
    } else {
      return rseq(p, acc);
    }
  }
}

function matchPattern(v, p) {
  var captureCount = 0;
  var result = {};
  try {
    walk(v, p);
  } catch (e) {
    if (e.matchPatternFailed) return null;
    throw e;
  }
  result.length = captureCount;
  return result;

  function walk(v, p) {
    if (p === v) return;

    if (p === __) return;

    if (Array.isArray(p) && Array.isArray(v) && p.length === v.length) {
      for (var i = 0; i < p.length; i++) {
	walk(v[i], p[i]);
      }
      return;
    }

    if (isCapture(p)) {
      var thisCapture = captureCount++;
      walk(v, capturePattern(p));
      result[captureName(p) || ('$' + thisCapture)] = v;
      return;
    }

    if (p instanceof $Embedded) {
      die("$Embedded patterns not supported in matchPattern()");
    }

    throw {matchPatternFailed: true};
  }
}

function rupdate(r, key, k) {
  if (is_emptyTrie(k)) {
    return r.remove(key);
  } else {
    return r.set(key, k);
  }
}

function rlookup(r, key) {
  return r.get(key, emptyTrie);
}

function is_keyOpen(k) {
  return k === SOA;
}

function is_keyClose(k) {
  return k === EOA;
}

function is_keyNormal(k) {
  return !(is_keyOpen(k) || is_keyClose(k));
}

///////////////////////////////////////////////////////////////////////////

var unionSuccesses = function (v1, v2) {
  if (v1 === true) return v2;
  if (v2 === true) return v1;
  return v1.union(v2);
};

var intersectSuccesses = function (v1, v2) {
  return v1;
};

var subtractSuccesses = function (v1, v2) {
  var r = v1.subtract(v2);
  if (r.isEmpty()) return null;
  return r;
};

var matchTrieSuccesses = function (v1, v2, acc) {
  return acc.union(v2);
};

var projectSuccess = function (v) {
  return v;
};

///////////////////////////////////////////////////////////////////////////

function expandWildseq(r) {
  return union(rwild(rwildseq(r)), rseq(EOA, r));
}

function union(o1, o2) {
  return merge(o1, o2);

  function merge(o1, o2) {
    if (is_emptyTrie(o1)) return o2;
    if (is_emptyTrie(o2)) return o1;
    return walk(o1, o2);
  }

  function walk(r1, r2) {
    if (r1 instanceof $WildcardSequence) {
      if (r2 instanceof $WildcardSequence) {
	return rwildseq(walk(r1.trie, r2.trie));
      }
      r1 = expandWildseq(r1.trie);
    } else if (r2 instanceof $WildcardSequence) {
      r2 = expandWildseq(r2.trie);
    }

    if (r1 instanceof $Success && r2 instanceof $Success) {
      return rsuccess(unionSuccesses(r1.value, r2.value));
    }

    var w = merge(rlookup(r1, __), rlookup(r2, __));
    if (is_emptyTrie(w)) {
      var smaller = r1.size < r2.size ? r1 : r2;
      var larger  = r1.size < r2.size ? r2 : r1;
      var target = larger;
      smaller.forEach(function (val, key) {
	var k = merge(rlookup(smaller, key), rlookup(larger, key));
	target = rupdate(target, key, k);
      });
      return target;
    } else {
      var target = rwild(w);
      function examineKey(rA, key, rB) {
	if ((key !== __) && !target.has(key)) {
	  var k = merge(rlookup(rA, key), rlookup(rB, key));
	  if (is_keyOpen(key)) {
	    target = rupdate(target, key, merge(rwildseq(w), k));
	  } else if (is_keyClose(key)) {
	    if (w instanceof $WildcardSequence) {
	      target = rupdate(target, key, merge(w.trie, k));
	    } else {
	      target = rupdate(target, key, k);
	    }
	  } else {
	    target = rupdate(target, key, merge(w, k));
	  }
	}
      }
      r1.forEach(function (val, key) { examineKey(r1, key, r2) });
      r2.forEach(function (val, key) { examineKey(r2, key, r1) });
      return target;
    }
  }
}

function unionN() {
  var acc = emptyTrie;
  for (var i = 0; i < arguments.length; i++) {
    acc = union(acc, arguments[i]);
  }
  return acc;
}

function intersect(o1, o2) {
  return walk(o1, o2);

  function walkFlipped(r2, r1) { return walk(r1, r2); }

  function walk(r1, r2) {
    // INVARIANT: r1 is a part of the original o1, and
    // likewise for r2. This is so that the first arg to
    // intersectSuccesses always comes from r1, and the second
    // from r2.
    if (is_emptyTrie(r1)) return emptyTrie;
    if (is_emptyTrie(r2)) return emptyTrie;

    if (r1 instanceof $WildcardSequence) {
      if (r2 instanceof $WildcardSequence) {
	return rwildseq(walk(r1.trie, r2.trie));
      }
      r1 = expandWildseq(r1.trie);
    } else if (r2 instanceof $WildcardSequence) {
      r2 = expandWildseq(r2.trie);
    }

    if (r1 instanceof $Success && r2 instanceof $Success) {
      return rsuccess(intersectSuccesses(r1.value, r2.value));
    }

    var w1 = rlookup(r1, __);
    var w2 = rlookup(r2, __);
    var w = walk(w1, w2);

    var target = emptyTrie;

    function examineKey(key) {
      if ((key !== __) && !target.has(key)) {
	var k1 = rlookup(r1, key);
	var k2 = rlookup(r2, key);
	if (is_emptyTrie(k1)) {
	  if (is_emptyTrie(k2)) {
	    target = rupdate(target, key, emptyTrie);
	  } else {
	    target = rupdate(target, key, walkWild(walk, w1, key, k2));
	  }
	} else {
	  if (is_emptyTrie(k2)) {
	    target = rupdate(target, key, walkWild(walkFlipped, w2, key, k1));
	  } else {
	    target = rupdate(target, key, walk(k1, k2));
	  }
	}
      }
    }

    if (is_emptyTrie(w1)) {
      if (is_emptyTrie(w2)) {
	(r1.size < r2.size ? r1 : r2).forEach(function (val, key) { examineKey(key) });
      } else {
	r1.forEach(function (val, key) { examineKey(key) });
      }
    } else {
      if (is_emptyTrie(w2)) {
	r2.forEach(function (val, key) { examineKey(key) });
      } else {
	target = rupdateInplace(target, __, w);
	r1.forEach(function (val, key) { examineKey(key) });
	r2.forEach(function (val, key) { examineKey(key) });
      }
    }
    return target;
  }

  function walkWild(walker, w, key, k) {
    if (is_emptyTrie(w)) return emptyTrie;
    if (is_keyOpen(key)) return walker(rwildseq(w), k);
    if (is_keyClose(key)) {
      if (w instanceof $WildcardSequence) return walker(w.trie, k);
      return emptyTrie;
    }
    return walker(w, k);
  }
}

// Removes r2's mappings from r1. Assumes r2 has previously been
// union'd into r1. The subtractSuccesses function should return
// null to signal "no remaining success values".
function subtract(o1, o2) {
  return walk(o1, o2);

  function walk(r1, r2) {
    if (is_emptyTrie(r1)) {
      return emptyTrie;
    } else {
      if (is_emptyTrie(r2)) {
	return r1;
      }
    }

    if (r1 instanceof $WildcardSequence) {
      if (r2 instanceof $WildcardSequence) {
	return rwildseq(walk(r1.trie, r2.trie));
      }
      r1 = expandWildseq(r1.trie);
    } else if (r2 instanceof $WildcardSequence) {
      r2 = expandWildseq(r2.trie);
    }

    if (r1 instanceof $Success && r2 instanceof $Success) {
      return rsuccess(subtractSuccesses(r1.value, r2.value));
    }

    var w1 = rlookup(r1, __);
    var w2 = rlookup(r2, __);
    var w = walk(w1, w2);
    var target;

    function examineKey(key) {
      if (key !== __) {
	var k1 = rlookup(r1, key);
	var k2 = rlookup(r2, key);
	var updatedK;
	if (is_emptyTrie(k2)) {
	  updatedK = walkWild(key, k1, w2);
	} else {
	  updatedK = walk(k1, k2);
	}
	// Here we ensure a "minimal" remainder in cases
	// where after an erasure, a particular key's
	// continuation is the same as the wildcard's
	// continuation. TODO: the equals check may
	// be expensive. If so, how can it be made
	// cheaper?
	if (is_keyOpen(key)) {
	  target = rupdate(target, key,
			   ((updatedK instanceof $WildcardSequence) &&
			    Immutable.is(updatedK.trie, w))
			   ? emptyTrie
			   : updatedK);
	} else if (is_keyClose(key)) {
	  // We take care of this case later, after the
	  // target is fully constructed/rebuilt.
	  target = rupdate(target, key, updatedK);
	} else {
	  target = rupdate(target, key,
			   (Immutable.is(updatedK, w) ? emptyTrie : updatedK));
	}
      }
    }

    if (is_emptyTrie(w2)) {
      target = r1;
      r2.forEach(function (val, key) { examineKey(key) });
    } else {
      target = emptyTrie;
      target = rupdate(target, __, w);
      r1.forEach(function (val, key) { examineKey(key) });
      r2.forEach(function (val, key) { examineKey(key) });
    }

    // Here, the target is complete. If it has only two keys,
    // one wild and one is_keyClose, and wild's continuation
    // is a $WildcardSequence and the other continuation is
    // identical to the sequence's continuation, then replace
    // the whole thing with a nested $WildcardSequence.
    // (We know w === rlookup(target, __) from before.)
    //
    // TODO: I suspect actually this applies even if there are
    // more than two keys, so long as all their continuations
    // are identical and there's at least one is_keyClose
    // alongside a wild.
    if (target.size === 2) {
      var finalW = rlookup(target, __);
      if (finalW instanceof $WildcardSequence) {
	target.forEach(function (k, key) {
	  if ((key !== __) && is_keyClose(key)) {
	    if (Immutable.is(k, finalW.trie)) {
	      target = finalW;
	      return false; // terminate the iteration early
	    }
	  }
	});
      }
    }

    return target;
  }

  function walkWild(key, k, w) {
    if (is_emptyTrie(w)) return k;
    if (is_keyOpen(key)) return walk(k, rwildseq(w));
    if (is_keyClose(key)) {
      if (w instanceof $WildcardSequence) return walk(k, w.trie);
      return k;
    }
    return walk(k, w);
  }
}

// Returns null on failed match, otherwise the appropriate success
// value contained in the trie r.
function matchValue(r, v) {
  var failureResult = null;

  var vs = Immutable.List.of(v);
  var stack = [Immutable.List()];

  while (!is_emptyTrie(r)) {
    if (r instanceof $WildcardSequence) {
      if (stack.length === 0) return failureResult;
      vs = stack.pop();
      r = r.trie;
      continue;
    }

    if (r instanceof $Success) {
      if (vs.size === 0 && stack.length === 0) return r.value;
      return failureResult;
    }

    if (vs.size === 0) {
      if (stack.length === 0) return failureResult;
      vs = stack.pop();
      r = rlookup(r, EOA);
      continue;
    }

    var v = vs.first();
    vs = vs.shift();

    if (typeof v === 'string' && v.substring(0, 2) === '__') {
      die("Cannot match special string starting with __");
    }

    if (Array.isArray(v)) {
      if (r.has(SOA)) {
	r = rlookup(r, SOA);
	stack.push(vs);
	vs = Immutable.List(v);
      } else {
	r = rlookup(r, __);
      }
    } else {
      if (r.has(v)) {
	r = rlookup(r, v);
      } else {
	r = rlookup(r, __);
      }
    }
  }

  return failureResult;
}

function matchTrie(o1, o2, seed) {
  var acc = typeof seed === 'undefined' ? Immutable.Set() : seed; // variable updated imperatively
  walk(o1, o2);
  return acc;

  function walkFlipped(r2, r1) { return walk(r1, r2); }

  function walk(r1, r2) {
    if (is_emptyTrie(r1) || is_emptyTrie(r2)) return;

    if (r1 instanceof $WildcardSequence) {
      if (r2 instanceof $WildcardSequence) {
	walk(r1.trie, r2.trie);
	return;
      }
      r1 = expandWildseq(r1.trie);
    } else if (r2 instanceof $WildcardSequence) {
      r2 = expandWildseq(r2.trie);
    }

    if (r1 instanceof $Success && r2 instanceof $Success) {
      acc = matchTrieSuccesses(r1.value, r2.value, acc);
      return;
    }

    var w1 = rlookup(r1, __);
    var w2 = rlookup(r2, __);
    walk(w1, w2);

    function examineKey(key) {
      if (key !== __) {
	var k1 = rlookup(r1, key);
	var k2 = rlookup(r2, key);
	if (is_emptyTrie(k1)) {
	  if (is_emptyTrie(k2)) {
	    return;
	  } else {
	    walkWild(walk, w1, key, k2);
	  }
	} else {
	  if (is_emptyTrie(k2)) {
	    walkWild(walkFlipped, w2, key, k1);
	  } else {
	    walk(k1, k2);
	  }
	}
      }
    }

    // Optimize similarly to intersect().
    if (is_emptyTrie(w1)) {
      if (is_emptyTrie(w2)) {
	(r1.size < r2.size ? r1 : r2).forEach(function (val, key) { examineKey(key) });
      } else {
	r1.forEach(function (val, key) { examineKey(key) });
      }
    } else {
      if (is_emptyTrie(w2)) {
	r2.forEach(function (val, key) { examineKey(key) });
      } else {
	r1.forEach(function (val, key) { examineKey(key) });
	r2.forEach(function (val, key) { examineKey(key) });
      }
    }
  }

  function walkWild(walker, w, key, k) {
    if (is_emptyTrie(w)) return;
    if (is_keyOpen(key)) {
      walker(rwildseq(w), k);
      return;
    }
    if (is_keyClose(key)) {
      if (w instanceof $WildcardSequence) walker(w.trie, k);
      return;
    }
    walker(w, k);
  }
}

function appendTrie(m, mTailFn) {
  return walk(m);

  function walk(m) {
    if (is_emptyTrie(m)) return emptyTrie;
    if (m instanceof $WildcardSequence) return rwildseq(walk(m.trie));
    if (m instanceof $Success) die("Ill-formed trie");

    var target = emptyTrie;
    m.forEach(function (k, key) {
      if (is_keyClose(key) && (k instanceof $Success)) {
	target = union(target, mTailFn(k.value));
      } else {
	target = rupdate(target, key, walk(k));
      }
    });
    return target;
  }
}

function relabel(m, f) {
  return walk(m);

  function walk(m) {
    if (is_emptyTrie(m)) return emptyTrie;
    if (m instanceof $WildcardSequence) return rwildseq(walk(m.trie));
    if (m instanceof $Success) return rsuccess(f(m.value));

    var target = emptyTrie;
    m.forEach(function (k, key) {
      target = rupdate(target, key, walk(k));
    });
    return target;
  }
}

function compileProjection(/* projection, projection, ... */) {
  var names = [];
  var acc = [];
  for (var i = 0; i < arguments.length; i++) {
    walk(arguments[i]);
  }
  acc.push(EOA);
  return {names: names, spec: acc};

  function walk(p) {
    if (isCapture(p)) {
      names.push(captureName(p));
      acc.push(SOC);
      walk(capturePattern(p));
      acc.push(EOC);
      return;
    }

    if (Array.isArray(p)) {
      acc.push(SOA);
      for (var i = 0; i < p.length; i++) {
	walk(p[i]);
      }
      acc.push(EOA);
      return;
    }

    if (p instanceof $Embedded) {
      die("Cannot embed trie in projection");
    } else {
      acc.push(p);
    }
  }
}

function projectionToPattern(p) {
  return walk(p);

  function walk(p) {
    if (isCapture(p)) return walk(capturePattern(p));

    if (Array.isArray(p)) {
      var result = [];
      for (var i = 0; i < p.length; i++) {
	result.push(walk(p[i]));
      }
      return result;
    }

    if (p instanceof $Embedded) {
      return p.trie;
    } else {
      return p;
    }
  }
}

function project(m, compiledProjection) {
  var spec = compiledProjection.spec;
  return walk(false, m, 0);

  function walk(isCapturing, m, specIndex) {
    if (specIndex >= spec.length) {
      if (isCapturing) die("Bad specification: unclosed capture");
      if (m instanceof $Success) {
	return rseq(EOA, rsuccess(projectSuccess(m.value)));
      } else {
	return emptyTrie;
      }
    }

    if (is_emptyTrie(m)) return emptyTrie;

    var item = spec[specIndex];
    var nextIndex = specIndex + 1;

    if (item === EOC) {
      if (!isCapturing) die("Bad specification: unexpected EOC");
      return walk(false, m, nextIndex);
    }

    if (item === SOC) {
      if (isCapturing) die("Bad specification: nested capture");
      return walk(true, m, nextIndex);
    }

    if (item === __) {
      if (m instanceof $WildcardSequence) {
	if (isCapturing) {
	  return rwild(walk(isCapturing, m, nextIndex));
	} else {
	  return walk(isCapturing, m, nextIndex);
	}
      }

      if (m instanceof $Success) {
	return emptyTrie;
      }

      var target;
      if (isCapturing) {
	target = emptyTrie;
	target = rupdate(target, __, walk(isCapturing, rlookup(m, __), nextIndex));
	m.forEach(function (mk, key) {
	  if (key !== __) {
	    if (is_keyOpen(key)) {
	      function cont(mk2) { return walk(isCapturing, mk2, nextIndex); }
	      target = rupdate(target, key, captureNested(mk, cont));
	    } else if (is_keyClose(key)) {
	      // do nothing
	    } else {
	      target = rupdate(target, key, walk(isCapturing, mk, nextIndex));
	    }
	  }
	});
      } else {
	target = walk(isCapturing, rlookup(m, __), nextIndex);
	m.forEach(function (mk, key) {
	  if (key !== __) {
	    if (is_keyOpen(key)) {
	      function cont(mk2) { return walk(isCapturing, mk2, nextIndex); }
	      target = union(target, skipNested(mk, cont));
	    } else if (is_keyClose(key)) {
	      // do nothing
	    } else {
	      target = union(target, walk(isCapturing, mk, nextIndex));
	    }
	  }
	});
      }
      return target;
    }

    var result;
    if (m instanceof $WildcardSequence) {
      if (is_keyOpen(item)) {
	result = walk(isCapturing, rwildseq(m), nextIndex);
      } else if (is_keyClose(item)) {
	result = walk(isCapturing, m.trie, nextIndex);
      } else {
	result = walk(isCapturing, m, nextIndex);
      }
    } else if (m instanceof $Success) {
      result = emptyTrie;
    } else {
      if (is_keyOpen(item)) {
	result = walk(isCapturing, rwildseq(rlookup(m, __)), nextIndex);
      } else if (is_keyClose(item)) {
	result = emptyTrie;
      } else {
	result = walk(isCapturing, rlookup(m, __), nextIndex);
      }
      result = union(result, walk(isCapturing, rlookup(m, item), nextIndex));
    }
    if (isCapturing) {
      result = rseq(item, result);
    }
    return result;
  }

  function captureNested(m, cont) {
    if (m instanceof $WildcardSequence) {
      return rwildseq(cont(m.trie));
    }

    if (is_emptyTrie(m) || (m instanceof $Success)) {
      return emptyTrie;
    }

    var target = emptyTrie;
    target = rupdate(target, __, captureNested(rlookup(m, __), cont));
    m.forEach(function (mk, key) {
      if (key !== __) {
	if (is_keyOpen(key)) {
	  function cont2(mk2) { return captureNested(mk2, cont); }
	  rupdateInplace(target, key, captureNested(mk, cont2));
	} else if (is_keyClose(key)) {
	  rupdateInplace(target, key, cont(mk));
	} else {
	  rupdateInplace(target, key, captureNested(mk, cont));
	}
      }
    });
    return target;
  }

  function skipNested(m, cont) {
    if (m instanceof $WildcardSequence) {
      return cont(m.trie);
    }

    if (is_emptyTrie(m) || (m instanceof $Success)) {
      return emptyTrie;
    }

    var target = skipNested(rlookup(m, __), cont);
    m.forEach(function (mk, key) {
      if (key !== __) {
	if (is_keyOpen(key)) {
	  function cont2(mk2) { return skipNested(mk2, cont); }
	  target = union(target, skipNested(mk, cont2));
	} else if (is_keyClose(key)) {
	  target = union(target, cont(mk));
	} else {
	  target = union(target, skipNested(mk, cont));
	}
      }
    });
    return target;
  }
}

function trieKeys(m) {
  if (is_emptyTrie(m)) return [];
  var result = walkSeq(m, function (vss, vsk) { return vss; });
  if (result === null) return null;
  return result.map(function (vs) { return vs.toArray() });

  function walk(m, k) {
    if (m instanceof $WildcardSequence) return null;
    if (m instanceof $Success) return [];
    if (m.has(__)) return null;
    var acc = [];
    m.forEach(function (mk, key) {
      var piece;
      if (is_keyOpen(key)) {
	function seqK(vss, vsk) {
	  var acc = [];
	  for (var i = 0; i < vss.length; i++) {
	    var vs = vss[i];
	    acc = acc.concat(k(transformSeqs(vs, key), vsk));
	  }
	  return acc;
	}
	piece = walkSeq(mk, seqK);
      } else if (is_keyClose(key)) {
	die("trieKeys: internal error: unexpected key-close");
      } else {
	piece = k(key, mk);
      }
      if (piece === null) return null;
      acc = acc.concat(piece);
    });
    return acc;
  }

  function walkSeq(m, k) {
    if (m instanceof $WildcardSequence) return null;
    if (m instanceof $Success) return k([], emptyTrie); // TODO: ??
    if (m.has(__)) return null;
    var acc = [];
    m.forEach(function (mk, key) {
      var piece;
      if (is_keyClose(key)) {
	piece = k([Immutable.List()], mk);
      } else {
	function outerK(v, vk) {
	  return walkSeq(vk, function (vss, vsk) {
	    var acc = [];
	    for (var i = 0; i < vss.length; i++) {
	      acc.push(vss[i].unshift(v));
	    }
	    return k(acc, vsk);
	  });
	}
	piece = walk(rseq(key, mk), outerK);
      }
      if (piece === null) return null;
      acc = acc.concat(piece);
    });
    return acc;
  }

  function transformSeqs(vs, opener) {
    if (opener === SOA) return vs;
    die("Internal error: unknown opener " + opener);
  }
}

function trieKeysToObjects(trieKeysResult, compiledProjection) {
  if (trieKeysResult === null) return null;
  var result = [];
  for (var i = 0; i < trieKeysResult.length; i++) {
    var e = trieKeysResult[i];
    var d = {};
    for (var j = 0; j < e.length; j++) {
      d[compiledProjection.names[j] || ('$' + j)] = e[j];
    }
    result.push(d);
  }
  return result;
}

function projectObjects(m, compiledProjection) {
  return trieKeysToObjects(trieKeys(project(m, compiledProjection)), compiledProjection);
}

function prettyTrie(m, initialIndent) {
  var acc = [];
  walk(initialIndent || 0, m);
  return acc.join('');

  function walk(i, m) {
    if (m instanceof $WildcardSequence) {
      acc.push("...>");
      walk(i + 4, m.trie);
      return;
    }
    if (m instanceof $Success) {
      var v = m.value;
      if (Immutable.Set.isSet(v)) { v = v.toArray(); }
      acc.push("{" + JSON.stringify(v) + "}");
      return;
    }

    if (m.size === 0) {
      acc.push("::: no further matches possible");
      return;
    }

    var needSep = false;
    m.toOrderedMap()
      .sortBy(function (k, key) { return key })
      .forEach(function (k, key) {
	if (needSep) {
	  acc.push("\n");
	  acc.push(indentStr(i));
	} else {
	  needSep = true;
	}
	acc.push(" ");
	if (key === __) key = '★';
	else if (key === SOA) key = '<';
	else if (key === EOA) key = '>';
	else key = JSON.stringify(key);
	acc.push(key);
	walk(i + key.length + 1, k);
      });
  }

  function indentStr(i) {
    return new Array(i + 1).join(' '); // eww
  }
}

///////////////////////////////////////////////////////////////////////////

module.exports.__ = __;
module.exports.$Capture = $Capture;
module.exports._$ = _$;
module.exports.is_emptyTrie = is_emptyTrie;
module.exports.emptyTrie = emptyTrie;
module.exports.embeddedTrie = embeddedTrie;
module.exports.compilePattern = compilePattern;
module.exports.matchPattern = matchPattern;
module.exports.union = unionN;
module.exports.intersect = intersect;
module.exports.subtract = subtract;
module.exports.matchValue = matchValue;
module.exports.matchTrie = matchTrie;
module.exports.appendTrie = appendTrie;
module.exports.relabel = relabel;
module.exports.compileProjection = compileProjection;
module.exports.projectionToPattern = projectionToPattern;
module.exports.project = project;
module.exports.trieKeys = trieKeys;
module.exports.trieKeysToObjects = trieKeysToObjects;
module.exports.projectObjects = projectObjects;
module.exports.prettyTrie = prettyTrie;