export abstract class BooleanExpression<T>
{
  abstract evaluate( t:T ):boolean;
  
  NOT():BooleanExpression<T>
  {
    return new NotExpression<T>( this );
  }

  AND( matcher:BooleanExpression<T>):BooleanExpression<T>
  {
    return new AndExpression<T>( [ this, matcher ] );
  }

  OR( matcher:BooleanExpression<T>):BooleanExpression<T>
  {
    return new OrExpression<T>( [ this, matcher ] );
  }

  AND_ALL( matchers:BooleanExpression<T>[] ):BooleanExpression<T>
  {
    if ( matchers.length === 0 )
    {
      return this;
    }

    let outputExpression = this.AND( matchers[ 0 ] );

    for ( let i = 1; i < matchers.length; i++ )
    {
      outputExpression = outputExpression.AND( matchers[ i ] );
    }

    return outputExpression;    
  }

  OR_ANY( matchers:BooleanExpression<T>[] ):BooleanExpression<T>
  {
    if ( matchers.length === 0 )
    {
      return this;
    }

    let outputExpression = this.OR( matchers[ 0 ] );

    for ( let i = 1; i < matchers.length; i++ )
    {
      outputExpression = outputExpression.OR( matchers[ i ] );
    }

    return outputExpression;   
  }
}

export class NotExpression<T> extends BooleanExpression<T>
{
  private _matcher:BooleanExpression<T>;

  constructor( matcher:BooleanExpression<T> )
  {
    super();
    this._matcher = matcher;
  }

  evaluate( t:T )
  {
    return ! this._matcher.evaluate( t );
  } 

  NOT()
  {
    return this._matcher;
  }
}

export abstract class ListInputExpression<T> extends BooleanExpression<T>
{
  protected _matchers:BooleanExpression<T>[];
  
  constructor( matchers:BooleanExpression<T>[] )
  {
    super();
    this._matchers = matchers;
  }
}

export class AndExpression<T> extends ListInputExpression<T>
{
  evaluate( t:T )
  {
    return this._matchers.every( m => m.evaluate( t ) );
  }

  AND( matcher:BooleanExpression<T> )
  {
    this._matchers.push( matcher );
    return this;
  }
}

export class OrExpression<T> extends ListInputExpression<T>
{
  evaluate( t:T )
  {
    return this._matchers.some( m => m.evaluate( t ) );
  }

  OR( matcher:BooleanExpression<T> )
  {
    this._matchers.push( matcher );
    return this;
  }
}