/*

  * Copyright (c) 2006 - 2011 Michael Schierl

  * All rights reserved.

  * 

  * This program is free software: you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation, either version 2 of the License, or

  * (at your option) any later version.

  * 

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  * 

  * You should have received a copy of the GNU General Public License

  * along with this program.  If not, see <http://www.gnu.org/licenses/>.

  */

 package net.sf.jmatchparser.template.engine.operation;

 import java.util.regex.Matcher;

 import net.sf.jmatchparser.template.engine.ParserState;

 import net.sf.jmatchparser.template.engine.parameter.Parameter;

 import net.sf.jmatchparser.util.PatternCache;

 public class MatchOperation extends Operation {

         private final Parameter parameter;

         private final boolean checkOnly;

         private final boolean negateCheck;

         private final boolean wholeLine;

         public MatchOperation(String templatePosition, Parameter parameter, boolean checkOnly, boolean negateCheck, boolean wholeLine) {

                 super(templatePosition);

                 this.parameter = parameter;

                 this.checkOnly = checkOnly;

                 this.negateCheck = negateCheck;

                 this.wholeLine = wholeLine;

                 if (negateCheck && !checkOnly)

                         throw new RuntimeException();

         }

         @Override

         public OperationResult execute(ParserState state) {

                 String regex = parameter.getRegex(state);

                 boolean success;

                 Matcher m;

                 if (wholeLine) {

                         CharSequence rest = state.getFirstLine();

                         if (rest == null) {

                                 m = null;

                                 success = false;

                         } else {

                                 m = PatternCache.compile(regex).matcher(rest);

                                 success = m.matches();

                         }

                 } else {

                         CharSequence rest = regex.contains("\n") ? state.getRest() : state.getFirstLine();

                         m = PatternCache.compile("^" + regex).matcher(rest == null ? "" : rest);

                         success = m.find();

                 }

                 if (success) {

                         parameter.applyMatch(state, m);

                         if (!checkOnly) {

                                 if (m.start() != 0)

                                         throw new RuntimeException();

                                 int end = m.end() + (wholeLine ? 1 : 0);

                                 state.discardCharacters(end);

                         }

                 }

                 if (success != negateCheck) {

                         return OperationResult.CONTINUE;

                 } else {

                         return OperationResult.FAIL;

                 }

         }

 }