"use strict";

// @TODO: chain-wrap in matcher
let MatchChain = class MatchChain extends Chain {
  constructor(parent) {
    super(parent);
    this.extend(['input', 'pattern', 'any', 'negate']);
    this.test = this.isMatch.bind(this);
  }

  static init(parent) {
    return new MatchChain(parent);
  }

  static input(input) {
    return MatchChain.init().input(input);
  }

  static pattern(pattern) {
    return MatchChain.init().pattern(pattern);
  }

  static any(any) {
    return MatchChain.init().any(any);
  }

  static negate(negate) {
    return MatchChain.init().negate(negate);
  }

  isMatch(data = null) {
    let _entries = this.entries(),
        input = _entries.input,
        pattern = _entries.pattern,
        any = _entries.any,
        all = _entries.all,
        negate = _entries.negate;

    if (data) input = data;
    if (!Array.isArray(input)) input = [input];
    if (!Array.isArray(pattern)) pattern = [pattern];
    const patterns = pattern.map(p => matcher.makeRe(p)); // match everything against everything, then flatten

    const patternsMatch = x => patterns.map(regex => regex.test(x));

    const arrays = input.map(x => patternsMatch(x));
    const results = [].concat.apply([], arrays);

    if (this.get('debug')) {
      console.log({
        input,
        patterns,
        any,
        all,
        negate,
        results
      });
    }

    if (any === true) return results.some(true);
    return results.filter(x => x === true).length === pattern.length;
  }

};