var isMergeable = require('./is-mergeable');

var optimizeProperties = require('./properties/optimize');

var cloneArray = require('../../utils/clone-array');

var Token = require('../../tokenizer/token');

var serializeBody = require('../../writer/one-time').body;
var serializeRules = require('../../writer/one-time').rules;

function reduceNonAdjacent(tokens, context) {
  var options = context.options;
  var mergeablePseudoClasses =
    options.compatibility.selectors.mergeablePseudoClasses;
  var mergeablePseudoElements =
    options.compatibility.selectors.mergeablePseudoElements;
  var multiplePseudoMerging =
    options.compatibility.selectors.multiplePseudoMerging;
  var candidates = {};
  var repeated = [];

  for (var i = tokens.length - 1; i >= 0; i--) {
    var token = tokens[i];

    if (token[0] != Token.RULE) {
      continue;
    } else if (token[2].length === 0) {
      continue;
    }

    var selectorAsString = serializeRules(token[1]);
    var isComplexAndNotSpecial =
      token[1].length > 1 &&
      isMergeable(
        selectorAsString,
        mergeablePseudoClasses,
        mergeablePseudoElements,
        multiplePseudoMerging
      );
    var wrappedSelectors = wrappedSelectorsFrom(token[1]);
    var selectors =
      isComplexAndNotSpecial ?
        [selectorAsString].concat(wrappedSelectors)
      : [selectorAsString];

    for (var j = 0, m = selectors.length; j < m; j++) {
      var selector = selectors[j];

      if (!candidates[selector]) candidates[selector] = [];
      else repeated.push(selector);

      candidates[selector].push({
        where: i,
        list: wrappedSelectors,
        isPartial: isComplexAndNotSpecial && j > 0,
        isComplex: isComplexAndNotSpecial && j === 0,
      });
    }
  }

  reduceSimpleNonAdjacentCases(tokens, repeated, candidates, options, context);
  reduceComplexNonAdjacentCases(tokens, candidates, options, context);
}

function wrappedSelectorsFrom(list) {
  var wrapped = [];

  for (var i = 0; i < list.length; i++) {
    wrapped.push([list[i][1]]);
  }

  return wrapped;
}

function reduceSimpleNonAdjacentCases(
  tokens,
  repeated,
  candidates,
  options,
  context
) {
  function filterOut(idx, bodies) {
    return data[idx].isPartial && bodies.length === 0;
  }

  function reduceBody(token, newBody, processedCount, tokenIdx) {
    if (!data[processedCount - tokenIdx - 1].isPartial) token[2] = newBody;
  }

  for (var i = 0, l = repeated.length; i < l; i++) {
    var selector = repeated[i];
    var data = candidates[selector];

    reduceSelector(
      tokens,
      data,
      {
        filterOut: filterOut,
        callback: reduceBody,
      },
      options,
      context
    );
  }
}

function reduceComplexNonAdjacentCases(tokens, candidates, options, context) {
  var mergeablePseudoClasses =
    options.compatibility.selectors.mergeablePseudoClasses;
  var mergeablePseudoElements =
    options.compatibility.selectors.mergeablePseudoElements;
  var multiplePseudoMerging =
    options.compatibility.selectors.multiplePseudoMerging;
  var localContext = {};

  function filterOut(idx) {
    return localContext.data[idx].where < localContext.intoPosition;
  }

  function collectReducedBodies(token, newBody, processedCount, tokenIdx) {
    if (tokenIdx === 0) localContext.reducedBodies.push(newBody);
  }

  allSelectors: for (var complexSelector in candidates) {
    var into = candidates[complexSelector];
    if (!into[0].isComplex) continue;

    var intoPosition = into[into.length - 1].where;
    var intoToken = tokens[intoPosition];
    var reducedBodies = [];

    var selectors =
      (
        isMergeable(
          complexSelector,
          mergeablePseudoClasses,
          mergeablePseudoElements,
          multiplePseudoMerging
        )
      ) ?
        into[0].list
      : [complexSelector];

    localContext.intoPosition = intoPosition;
    localContext.reducedBodies = reducedBodies;

    for (var j = 0, m = selectors.length; j < m; j++) {
      var selector = selectors[j];
      var data = candidates[selector];

      if (data.length < 2) continue allSelectors;

      localContext.data = data;

      reduceSelector(
        tokens,
        data,
        {
          filterOut: filterOut,
          callback: collectReducedBodies,
        },
        options,
        context
      );

      if (
        serializeBody(reducedBodies[reducedBodies.length - 1]) !=
        serializeBody(reducedBodies[0])
      )
        continue allSelectors;
    }

    intoToken[2] = reducedBodies[0];
  }
}

function reduceSelector(tokens, data, context, options, outerContext) {
  var bodies = [];
  var bodiesAsList = [];
  var processedTokens = [];

  for (var j = data.length - 1; j >= 0; j--) {
    if (context.filterOut(j, bodies)) continue;

    var where = data[j].where;
    var token = tokens[where];
    var clonedBody = cloneArray(token[2]);

    bodies = bodies.concat(clonedBody);
    bodiesAsList.push(clonedBody);
    processedTokens.push(where);
  }

  optimizeProperties(bodies, true, false, outerContext);

  var processedCount = processedTokens.length;
  var propertyIdx = bodies.length - 1;
  var tokenIdx = processedCount - 1;

  while (tokenIdx >= 0) {
    if (
      (tokenIdx === 0 ||
        (bodies[propertyIdx] &&
          bodiesAsList[tokenIdx].indexOf(bodies[propertyIdx]) > -1)) &&
      propertyIdx > -1
    ) {
      propertyIdx--;
      continue;
    }

    var newBody = bodies.splice(propertyIdx + 1);
    context.callback(
      tokens[processedTokens[tokenIdx]],
      newBody,
      processedCount,
      tokenIdx
    );

    tokenIdx--;
  }
}

module.exports = reduceNonAdjacent;