/*

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

  *

  * Copyright 2008 Sun Microsystems, Inc. All rights reserved.

  *

  * The contents of this file are subject to the terms of either the GNU

  * General Public License Version 2 only ("GPL") or the Common

  * Development and Distribution License("CDDL") (collectively, the

  * "License"). You may not use this file except in compliance with the

  * License. You can obtain a copy of the License at

  * http://www.netbeans.org/cddl-gplv2.html

  * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

  * specific language governing permissions and limitations under the

  * License.  When distributing the software, include this License Header

  * Notice in each file and include the License file at

  * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Sun in the GPL Version 2 section of the License file that

  * accompanied this code. If applicable, add the following below the

  * License Header, with the fields enclosed by brackets [] replaced by

  * your own identifying information:

  * "Portions Copyrighted [year] [name of copyright owner]"

  *

  * If you wish your version of this file to be governed by only the CDDL

  * or only the GPL Version 2, indicate your decision by adding

  * "[Contributor] elects to include this software in this distribution

  * under the [CDDL or GPL Version 2] license." If you do not indicate a

  * single choice of license, a recipient has the option to distribute

  * your version of this file under either the CDDL, the GPL Version 2 or

  * to extend the choice of license to its licensees as provided above.

  * However, if you add GPL Version 2 code and therefore, elected the GPL

  * Version 2 license, then the option applies only if the new code is

  * made subject to such option by the copyright holder.

  *

  * Contributor(s):

  *

  * Portions Copyrighted 2008 Sun Microsystems, Inc.

  */

 package org.netbeans.modules.php.smarty.editor.lexer;

 import org.netbeans.api.lexer.InputAttributes;

 import org.netbeans.api.lexer.LanguagePath;

 import org.netbeans.api.lexer.Token;

 import org.netbeans.lib.editor.util.CharSequenceUtilities;

 import org.netbeans.modules.php.smarty.editor.TplMetaData;

 import org.netbeans.modules.php.smarty.editor.utlis.LexerUtils;

 import org.netbeans.modules.php.smarty.editor.utlis.TplUtils;

 import org.netbeans.spi.lexer.Lexer;

 import org.netbeans.spi.lexer.LexerInput;

 import org.netbeans.spi.lexer.LexerRestartInfo;

 import org.netbeans.spi.lexer.TokenFactory;

 /**

  *

  * @author Martin Fousek

  */

 public class TplTopLexer implements Lexer<TplTopTokenId> {

     private final TplTopColoringLexer scanner;

     private TokenFactory<TplTopTokenId> tokenFactory;

     private final InputAttributes inputAttributes;

     private final TplMetaData tplMetaData;

     private class CompoundState {

         private State lexerState;

         private SubState lexerSubState;

         public CompoundState(State lexerState, SubState lexerSubState) {

             this.lexerState = lexerState;

             this.lexerSubState = lexerSubState;

         }

         @Override

         public boolean equals(Object obj) {

             if (obj == null) {

                 return false;

             }

             if (getClass() != obj.getClass()) {

                 return false;

             }

             final CompoundState other = (CompoundState) obj;

             if (this.lexerState != other.lexerState) {

                 return false;

             }

             if (this.lexerSubState != other.lexerSubState) {

                 return false;

             }

             return true;

         }

         @Override

         public int hashCode() {

             int hash = 3;

             hash = 17 * hash + this.lexerState.ordinal();

             hash = 17 * hash + this.lexerSubState.ordinal();

             return hash;

         }

         @Override

         public String toString() {

             return "State(hash=" + hashCode() + ",s=" + lexerState + ",ss=" + lexerSubState + ")"; //NOI18N

         }

     }

     private TplTopLexer(LexerRestartInfo<TplTopTokenId> info) {

         CompoundState state = null;

         if (info.state() == null) {

             state = new CompoundState(State.INIT, SubState.NO_SUB_STATE);

         } else {

             state = (CompoundState)info.state();

         }

         this.tokenFactory = info.tokenFactory();

         this.inputAttributes = info.inputAttributes();

         if (inputAttributes != null) {

             this.tplMetaData = (TplMetaData) inputAttributes.getValue(LanguagePath.get(TplTopTokenId.language()), TplMetaData.class);

         } else {

             this.tplMetaData = TplUtils.getProjectPropertiesForFileObject(null);

         }

         scanner = new TplTopColoringLexer(info, state, tplMetaData);

     }

     /**

      * Create new top lexer.

      * @param info where was the parsing started

      * @return new lexer for additional parsing

      */

     public static synchronized TplTopLexer create(LexerRestartInfo<TplTopTokenId> info) {

         return new TplTopLexer(info);

     }

     public Token<TplTopTokenId> nextToken() {

         TplTopTokenId tokenId = scanner.nextToken();

         Token<TplTopTokenId> token = null;

         if (tokenId != null) {

             token = tokenFactory.createToken(tokenId);

         }

         return token;

     }

     public Object state() {

         return scanner.getState();

     }

     public void release() {

     }

     private enum State {

         INIT,

         OUTER,

         AFTER_DELIMITER,

         OPEN_DELIMITER,

         CLOSE_DELIMITER,

         IN_COMMENT,

         IN_SMARTY,

         IN_PHP,

         AFTER_SUBSTATE,

         IN_LITERAL

     }

     private enum SubState {

         NO_SUB_STATE,

         PHP_CODE,

         LITERAL

     }

     private class TplTopColoringLexer {

         private State state;

         private final LexerInput input;

         private SubState subState;

         private final TplMetaData metadata;

         public TplTopColoringLexer(LexerRestartInfo<TplTopTokenId> info, CompoundState state, TplMetaData metadata) {

             this.input = info.input();

             this.state = state.lexerState;

             this.subState = state.lexerSubState;

             if (metadata != null)

                 this.metadata = metadata;

             else

                 this.metadata = TplUtils.getProjectPropertiesForFileObject(null);

         }

         public TplTopTokenId nextToken() {

             int c = input.read();

             CharSequence text;

             int textLength;

             int openDelimiterLength = getOpenDelimiterLength();

             int closeDelimiterLength = getCloseDelimiterLength();

             if (c == LexerInput.EOF) {

                 return null;

             }

             while (c != LexerInput.EOF) {

                 char cc = (char) c;

                 text = input.readText();

                 textLength = text.length();

                switch (state) {

                 case INIT:

                 case OUTER:

                     if (isSmartyOpenDelimiter(text)) {

                         state = State.OPEN_DELIMITER;

                         input.backup(openDelimiterLength);

                         if (textLength > openDelimiterLength) {

                             return TplTopTokenId.T_HTML;

                         }

                     }

 //                    if (cc == '\n') {

 //                        return TplTopTokenId.T_HTML;

 //                    }

                     break;

                 case OPEN_DELIMITER:

                     if (textLength < openDelimiterLength) {

                         break;

                     }

                     state = State.AFTER_DELIMITER;

                     if (subState == subState.NO_SUB_STATE) {

                         return TplTopTokenId.T_SMARTY_OPEN_DELIMITER;

                     } else {

                         if (input.readLength() > openDelimiterLength) {

                             input.backup(input.readLength() - openDelimiterLength);

                             if (subState == subState.LITERAL)

                                 return TplTopTokenId.T_HTML;

                             else

                                 return TplTopTokenId.T_PHP;

                         }

                         break;

                     }

                 case AFTER_DELIMITER:

                     if (LexerUtils.isWS(c)) {

                         if (subState == subState.NO_SUB_STATE) {

                             return TplTopTokenId.T_SMARTY;

                         } else {

                             break;

                         }

                     }

                     else {

                         String lastWord = readNextWord(c);

                         switch(subState){

                             case LITERAL:

                                 if (lastWord.startsWith("/literal")) {

                                     subState = SubState.NO_SUB_STATE;

                                     state = State.OPEN_DELIMITER;

                                     input.backup(input.readLength());

                                     break;

                                 } else {

                                     input.backup(input.readLength()-1);

                                     state = State.IN_LITERAL;

                                 }

                                 return TplTopTokenId.T_HTML;

                             case PHP_CODE:

                                 if (lastWord.startsWith("/php")) {

                                     subState = SubState.NO_SUB_STATE;

                                     state = State.OPEN_DELIMITER;

                                     input.backup(input.readLength());

                                     break;

                                 } else {

                                     state = State.IN_PHP;

                                 }

                                 return TplTopTokenId.T_PHP;

                             default:

                                if (lastWord.charAt(0) == '*') {

                                     state = State.IN_COMMENT;

                                     input.backup(lastWord.length()-1);

                                     return TplTopTokenId.T_COMMENT;

                                 }

                                 else if (lastWord.startsWith("literal")) {

                                     subState = SubState.LITERAL;

                                     state = State.AFTER_SUBSTATE;

                                     input.backup(lastWord.length()-7);

                                     return TplTopTokenId.T_SMARTY;

                                 }

                                 else if (lastWord.startsWith("php")) {

                                     subState = SubState.PHP_CODE;

                                     state = State.AFTER_SUBSTATE;

                                     input.backup(lastWord.length()-3);

                                     return TplTopTokenId.T_SMARTY;

                                 }

                                 else {

                                     state = State.IN_SMARTY;

                                     input.backup(lastWord.length());

                                 }

                         }

                     }

                     break;

                 case IN_COMMENT:

                     if (cc == '*') {

                         state = State.AFTER_SUBSTATE;

                         return TplTopTokenId.T_COMMENT;

                     }

                     return TplTopTokenId.T_COMMENT;

                 case AFTER_SUBSTATE:

                     if (LexerUtils.isWS(c)) {

                         return TplTopTokenId.T_SMARTY;

                     }

                     else if (isSmartyCloseDelimiter(text)) {

                         state = State.CLOSE_DELIMITER;

                         input.backup(closeDelimiterLength);

                         break;

                     } else {

                         break;

                     }

                 case CLOSE_DELIMITER:

                     if (textLength < closeDelimiterLength) {

                         break;

                     }

                     switch(subState){

                         case LITERAL:

                             state = State.IN_LITERAL;

                             break;

                         case PHP_CODE:

                             state = State.IN_PHP;

                             break;

                         default:

                             state = State.OUTER;

                             break;

                     }

                     return TplTopTokenId.T_SMARTY_CLOSE_DELIMITER;

                 case IN_PHP:

                     if (isSmartyOpenDelimiter(text)) {

                         state = State.OPEN_DELIMITER;

                         input.backup(openDelimiterLength);

                         if (input.readLength() > 0)

                             return TplTopTokenId.T_PHP;

                     }

                     if (input.readLength() > 1) {

                         return TplTopTokenId.T_PHP;

                     }

                     break;

                 case IN_LITERAL:

                     if (isSmartyOpenDelimiter(text)) {

                         state = State.OPEN_DELIMITER;

                         input.backup(openDelimiterLength);

                         if (input.readLength() > 0) {

                             return TplTopTokenId.T_HTML;

                         }

                     }

                     if (LexerUtils.isWS(c)) {

                         return TplTopTokenId.T_HTML;

                     }

                     break;

                 case IN_SMARTY:

                     if (isSmartyCloseDelimiter(text)) {

                         if (textLength == closeDelimiterLength) {

                             state = State.OUTER;

                             return TplTopTokenId.T_SMARTY_CLOSE_DELIMITER;

                         }

                         else {

                             state = State.CLOSE_DELIMITER;

                             input.backup(closeDelimiterLength);

                             if (input.readLength() != 0) {

                                 return TplTopTokenId.T_SMARTY;

                             }

                         }

                     }

                     switch(c) {

                         case '\n':

                            return TplTopTokenId.T_SMARTY;

                         case LexerInput.EOF:

                            return TplTopTokenId.T_SMARTY;

 //                        case '<':

 //                           state = State.OUTER;

 //                           input.backup(1);

 //                           if (input.readLength() > 1) {

 //                                return TplTopTokenId.T_SMARTY;

 //                           }

                     }

                     break;

                 }

                 c = input.read();

             }

             return getTokenId(state);

         }

         private TplTopTokenId getTokenId(State state) {

             switch (state) {

                 case IN_SMARTY:

                     return TplTopTokenId.T_SMARTY;

                 case OPEN_DELIMITER:

                     return TplTopTokenId.T_SMARTY_OPEN_DELIMITER;

                 case CLOSE_DELIMITER:

                     return TplTopTokenId.T_SMARTY_CLOSE_DELIMITER;

                 default:

                     return TplTopTokenId.T_HTML;

             }

         }

         Object getState() {

             return new CompoundState(state, subState);

         }

         private boolean isSmartyOpenDelimiter(CharSequence text) {

             return CharSequenceUtilities.endsWith(text, metadata.getOpenDelimiter());

         }

         private boolean isSmartyCloseDelimiter(CharSequence text) {

             return CharSequenceUtilities.endsWith(text, metadata.getCloseDelimiter());

         }

         private int getOpenDelimiterLength() {

             return metadata.getOpenDelimiter().length();

         }

         private int getCloseDelimiterLength() {

             return metadata.getCloseDelimiter().length();

         }

         private String readNextWord(int lastChar) {

             String word = Character.toString((char)lastChar);

             int c;

             while (!LexerUtils.isWS(c = input.read()) && c != LexerInput.EOF) {

                 word += Character.toString((char)c);

             }

             input.backup(1);

             return word;

         }

     }

 }