import { BooleanExpression } from "../../expressions/BooleanExpression";
import { StringValueMatcher, LitaralMatcher, RegExpMatcher } from "../../expressions/StringMatcher";
import { Arrays } from "../../tools/Arrays";
import { LexerEvent } from "./LexerEvent";
import { LexerSequence } from "./LexerSequence";
import { LexerType } from "./LexerType";

export class LiteralLexerEventTypeMatcher extends LitaralMatcher<LexerEvent,string>
{
  getStringValue( l:LexerEvent){return l.type;}
}

export class RegExpLexerEventTypeMatcher extends RegExpMatcher<LexerEvent>
{
  getStringValue( l:LexerEvent){return l.type;}
}

export class LiteralLexerEventValueMatcher extends LitaralMatcher<LexerEvent,string>
{
  getStringValue( l:LexerEvent){return l.match;}
}

export class RegExpLexerEventValueMatcher extends RegExpMatcher<LexerEvent>
{
  getStringValue( l:LexerEvent){return l.match;}
}

export class LexerEventMatcherTools
{
  static createTypeAndValueMatcher<Type extends LexerType>( type:Type, value:string )
  {
    let typeMatcher  = new LiteralLexerEventTypeMatcher( type );
    let valueMatcher = new LiteralLexerEventValueMatcher( value );    

    return typeMatcher.AND( valueMatcher );
  }

  static convertToExpression<Type extends LexerType>( value:BooleanExpression<LexerEvent>|Type[]|string ):BooleanExpression<LexerEvent>
  {
    if ( typeof value === "string" )
    {
      return new LiteralLexerEventValueMatcher( value )
    }
    else if ( Array.isArray( value ) )
    {
      let types = value as LexerType[];
      let outputMatcher:BooleanExpression<LexerEvent> = null;

      for ( let i = 0; i < types.length; i++ )
      {
        let matcher = new LiteralLexerEventTypeMatcher( types[ i ] );
        
        if ( outputMatcher )
        {
          outputMatcher = outputMatcher.OR( matcher );
        }
        else
        {
          outputMatcher = matcher;
        }
      }

      return outputMatcher;
    }

    return value as BooleanExpression<LexerEvent>;
  } 

  static createMatchSequence<Type extends LexerType>( matcherDefinition:(BooleanExpression<LexerEvent>|Type[]|string)[], 
    ignoreDefinition:(BooleanExpression<LexerEvent>|Type[]|string)[] )
  {
    let matchers = matcherDefinition.map( md => LexerEventMatcherTools.convertToExpression<Type>( md ) );
    let ignores  = ignoreDefinition.map( id => LexerEventMatcherTools.convertToExpression<Type>( id ) );


    let ignore = null;
    
    if ( ignores.length === 1 )
    {
      ignore = ignores[ 0 ];
    }
    else if ( ignores.length > 1 )
    {
      ignore = ignores[ 0 ].OR_ANY( Arrays.copyRangeFromStart( ignores, 1 ) );
    }

    let sequence = new LexerSequence();
    sequence.sequence = matchers;
    sequence.ignore = ignore;

    return sequence;    
  }
}