(function (tree) {

tree.Media = function (value, features, index, currentFileInfo) {

this.index = index;
this.currentFileInfo = currentFileInfo;

var selectors = this.emptySelectors();

this.features = new(tree.Value)(features);
this.rules = [new(tree.Ruleset)(selectors, value)];
this.rules[0].allowImports = true;

}; tree.Media.prototype = {

type: "Media",
accept: function (visitor) {
    if (this.features) {
        this.features = visitor.visit(this.features);
    }
    if (this.rules) {
        this.rules = visitor.visitArray(this.rules);
    }
},
genCSS: function (env, output) {
    output.add('@media ', this.currentFileInfo, this.index);
    this.features.genCSS(env, output);
    tree.outputRuleset(env, output, this.rules);
},
toCSS: tree.toCSS,
eval: function (env) {
    if (!env.mediaBlocks) {
        env.mediaBlocks = [];
        env.mediaPath = [];
    }

    var media = new(tree.Media)(null, [], this.index, this.currentFileInfo);
    if(this.debugInfo) {
        this.rules[0].debugInfo = this.debugInfo;
        media.debugInfo = this.debugInfo;
    }
    var strictMathBypass = false;
    if (!env.strictMath) {
        strictMathBypass = true;
        env.strictMath = true;
    }
    try {
        media.features = this.features.eval(env);
    }
    finally {
        if (strictMathBypass) {
            env.strictMath = false;
        }
    }

    env.mediaPath.push(media);
    env.mediaBlocks.push(media);

    env.frames.unshift(this.rules[0]);
    media.rules = [this.rules[0].eval(env)];
    env.frames.shift();

    env.mediaPath.pop();

    return env.mediaPath.length === 0 ? media.evalTop(env) :
                media.evalNested(env);
},
variable: function (name) { return tree.Ruleset.prototype.variable.call(this.rules[0], name); },
find: function () { return tree.Ruleset.prototype.find.apply(this.rules[0], arguments); },
rulesets: function () { return tree.Ruleset.prototype.rulesets.apply(this.rules[0]); },
emptySelectors: function() { 
    var el = new(tree.Element)('', '&', this.index, this.currentFileInfo),
        sels = [new(tree.Selector)([el], null, null, this.index, this.currentFileInfo)];
    sels[0].mediaEmpty = true;
    return sels;
},
markReferenced: function () {
    var i, rules = this.rules[0].rules;
    this.rules[0].markReferenced();
    this.isReferenced = true;
    for (i = 0; i < rules.length; i++) {
        if (rules[i].markReferenced) {
            rules[i].markReferenced();
        }
    }
},

evalTop: function (env) {
    var result = this;

    // Render all dependent Media blocks.
    if (env.mediaBlocks.length > 1) {
        var selectors = this.emptySelectors();
        result = new(tree.Ruleset)(selectors, env.mediaBlocks);
        result.multiMedia = true;
    }

    delete env.mediaBlocks;
    delete env.mediaPath;

    return result;
},
evalNested: function (env) {
    var i, value,
        path = env.mediaPath.concat([this]);

    // Extract the media-query conditions separated with `,` (OR).
    for (i = 0; i < path.length; i++) {
        value = path[i].features instanceof tree.Value ?
                    path[i].features.value : path[i].features;
        path[i] = Array.isArray(value) ? value : [value];
    }

    // Trace all permutations to generate the resulting media-query.
    //
    // (a, b and c) with nested (d, e) ->
    //    a and d
    //    a and e
    //    b and c and d
    //    b and c and e
    this.features = new(tree.Value)(this.permute(path).map(function (path) {
        path = path.map(function (fragment) {
            return fragment.toCSS ? fragment : new(tree.Anonymous)(fragment);
        });

        for(i = path.length - 1; i > 0; i--) {
            path.splice(i, 0, new(tree.Anonymous)("and"));
        }

        return new(tree.Expression)(path);
    }));

    // Fake a tree-node that doesn't output anything.
    return new(tree.Ruleset)([], []);
},
permute: function (arr) {
  if (arr.length === 0) {
      return [];
  } else if (arr.length === 1) {
      return arr[0];
  } else {
      var result = [];
      var rest = this.permute(arr.slice(1));
      for (var i = 0; i < rest.length; i++) {
          for (var j = 0; j < arr[0].length; j++) {
              result.push([arr[0][j]].concat(rest[i]));
          }
      }
      return result;
  }
},
bubbleSelectors: function (selectors) {
  if (!selectors)
    return;
  this.rules = [new(tree.Ruleset)(selectors.slice(0), [this.rules[0]])];
}

};

})(require('../tree'));