/*
 * Copyright 2005 Sascha Weinreuter
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.intellij.lang.xpath;

import com.intellij.lexer.FlexAdapter;
import com.intellij.lexer.Lexer;
import com.intellij.lexer.LexerPosition;
import com.intellij.lexer.LookAheadLexer;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.tree.TokenSet;

import java.io.IOException;

public final class XPathLexer extends LookAheadLexer {
  private static final TokenSet WS_OR_COMMENT = TokenSet.create(XPathTokenTypes.WHITESPACE, XPath2TokenTypes.COMMENT);

  private final boolean myXPath2Syntax;

  private XPathLexer(boolean xpath2Syntax) {
    super(new FlexAdapter(new _XPathLexer(xpath2Syntax) {
      @Override
      protected void readComment() throws IOException {
        final int state = yystate();
        final int start = getTokenStart();
        while (true) {
          final IElementType type = advance();
          if (type == null || type == XPath2TokenTypes.END_COMMENT) {
            break;
          }
        }
        setStart(start);
        yybegin(state);
      }
    }));

    myXPath2Syntax = xpath2Syntax;
  }

  @Override
  protected void lookAhead(Lexer baseLexer) {
    final IElementType type = baseLexer.getTokenType();

    if (type == XPath2TokenTypes.IF) { // "if" / "(" EXPRESSION
      if (replaceTokenNotFollowedBy(baseLexer, XPathTokenTypes.NCNAME, XPathTokenTypes.LPAREN)) {
        return;
      }
    } else if (type == XPathTokenTypes.NCNAME) {
      if (handleNCName(baseLexer, type)) return;
    } else if (type == XPathTokenTypes.RPAREN) {
      if (getState() == _XPathLexer.TYPE) {
        if (!lookingAt(baseLexer, XPath2TokenTypes.OCCURRENCE_OPS)) {
          setState(baseLexer, _XPathLexer.YYINITIAL);
        }
      }
    } else if (type == XPathTokenTypes.AXIS_NAME) {
      if (replaceTokenNotFollowedBy(baseLexer, XPathTokenTypes.NCNAME, XPathTokenTypes.COLCOL)) { // AXIS_NAME / "::"
        setState(baseLexer, _XPathLexer.YYINITIAL);
        return;
      }
    } else if (type == XPathTokenTypes.NODE_TYPE) {
      final String text = baseLexer.getTokenText();
      // NODE_TYPE2
      if ("attribute".equals(text) || "element".equals(text) || "schema-element".equals(text) || "schema-attribute".equals(text) || "document-node".equals(text)) {
        // "attribute::" vs. "attribute("
        if ("attribute".equals(text)) {
          if (replaceTokenFollowedBy(baseLexer, XPathTokenTypes.AXIS_NAME, XPathTokenTypes.COLCOL)) {
            setState(baseLexer, _XPathLexer.S1);
            return;
          }
        }

        if (myXPath2Syntax) {
          if (!replaceTokenNotFollowedBy(baseLexer, XPathTokenTypes.NCNAME, XPathTokenTypes.LPAREN)) {
            advanceAs(baseLexer, type);
          }
        } else {
          handleNCName(baseLexer, XPathTokenTypes.NCNAME);
        }
        return;
      } else if (replaceTokenNotFollowedBy(baseLexer, XPathTokenTypes.NCNAME, XPathTokenTypes.LPAREN)) {
        // other NODE_TYPEs
        setState(baseLexer, _XPathLexer.YYINITIAL);
        return;
      }
    } else if (XPath2TokenTypes.QUANTIFIERS.contains(type) || type == XPath2TokenTypes.FOR) { // ("some" | "every" | "for") / "$" VARNAME
      if (replaceTokenNotFollowedBy(baseLexer, XPathTokenTypes.NCNAME, XPathTokenTypes.DOLLAR)) {
        return;
      }
    }

    advanceAs(baseLexer, type);
  }

  private boolean handleNCName(Lexer baseLexer, IElementType type) {
    if (baseLexer.getState() == _XPathLexer.TYPE) {
      if (!lookingAt(baseLexer, XPathTokenTypes.COL, XPathTokenTypes.NCNAME) && !lookingAt(baseLexer, XPath2TokenTypes.OCCURRENCE_OPS)) {
        setState(baseLexer, _XPathLexer.S1);
      }
    } else {
      if (!replaceTokenFollowedBy(baseLexer, XPathTokenTypes.FUNCTION_NAME, XPathTokenTypes.LPAREN)) { // NCNAME / "(" -> FUNCTION_NAME
        if (lookingAt(baseLexer, XPathTokenTypes.COL, XPathTokenTypes.NCNAME, XPathTokenTypes.LPAREN)) { // NCNAME / ":" NCNAME "(" -> EXT_PREFIX
          advanceAs(baseLexer, XPathTokenTypes.EXT_PREFIX);
        } else {
          if (!replaceTokenFollowedBy(baseLexer, XPathTokenTypes.BAD_AXIS_NAME, XPathTokenTypes.COLCOL)) { // NCNAME / "::" -> BAD_AXIS_NAME
            advanceAs(baseLexer, type);
          }
        }
      }
      return true;
    }
    return false;
  }

  private static boolean lookingAt(Lexer lexer, TokenSet tokenSet) {
    final LexerPosition position = lexer.getCurrentPosition();
    try {
      lexer.advance();
      skipWhitespaceAnComments(lexer);
      return tokenSet.contains(lexer.getTokenType());
    } finally {
      lexer.restore(position);
    }
  }

  private static void setState(Lexer baseLexer, int state) {
    ((FlexAdapter)baseLexer).getFlex().yybegin(state);
  }

  private boolean replaceTokenNotFollowedBy(Lexer baseLexer, final IElementType replacement, IElementType nextToken) {
    if (!lookingAt(baseLexer, nextToken)) {
      treatAs(baseLexer, replacement);
      return true;
    }
    return false;
  }

  private boolean replaceTokenFollowedBy(Lexer baseLexer, final IElementType replacement, IElementType nextToken) {
    if (lookingAt(baseLexer, nextToken)) {
      treatAs(baseLexer, replacement);
      return true;
    }
    return false;
  }

  private void treatAs(Lexer lexer, IElementType type) {
    if (type == XPathTokenTypes.NCNAME) {
      if (!handleNCName(lexer, type)) {
        advanceAs(lexer, type);
      }
    } else {
      advanceAs(lexer, type);
    }
  }

  private static boolean lookingAt(Lexer baseLexer, IElementType... tokens) {
    final LexerPosition position = baseLexer.getCurrentPosition();
    try {
      for (IElementType token : tokens) {
        baseLexer.advance();
        skipWhitespaceAnComments(baseLexer);
        if (baseLexer.getTokenType() != token) {
          return false;
        }
      }
      return true;
    } finally {
      baseLexer.restore(position);
    }
  }

  private static void skipWhitespaceAnComments(Lexer baseLexer) {
    while (WS_OR_COMMENT.contains(baseLexer.getTokenType())) {
      baseLexer.advance();
    }
  }

  public static Lexer create(boolean xpath2Syntax) {
    return new XPathLexer(xpath2Syntax);
  }
}