/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.apache.lucene.benchmark.byTask.utils;

import java.io.StreamTokenizer;
import java.io.StringReader;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Locale;
import org.apache.lucene.benchmark.byTask.PerfRunData;
import org.apache.lucene.benchmark.byTask.tasks.PerfTask;
import org.apache.lucene.benchmark.byTask.tasks.RepSumByPrefTask;
import org.apache.lucene.benchmark.byTask.tasks.TaskSequence;

/** Test algorithm, as read from file */
@SuppressWarnings("try")
public class Algorithm implements AutoCloseable {

  private TaskSequence sequence;
  private final String[] taskPackages;

  /**
   * Read algorithm from file Property examined: alt.tasks.packages == comma separated list of
   * alternate package names where tasks would be searched for, when not found in the default
   * package (that of {@link PerfTask}{@link #getClass()}). If the same task class appears in more
   * than one package, the package indicated first in this list will be used.
   *
   * @param runData perf-run-data used at running the tasks.
   * @throws Exception if errors while parsing the algorithm
   */
  @SuppressWarnings("fallthrough")
  public Algorithm(PerfRunData runData) throws Exception {
    Config config = runData.getConfig();
    taskPackages = initTasksPackages(config);
    String algTxt = config.getAlgorithmText();
    sequence = new TaskSequence(runData, null, null, false);
    TaskSequence currSequence = sequence;
    PerfTask prevTask = null;
    StreamTokenizer stok = new StreamTokenizer(new StringReader(algTxt));
    stok.commentChar('#');
    stok.eolIsSignificant(false);
    stok.quoteChar('"');
    stok.quoteChar('\'');
    stok.ordinaryChar('/');
    stok.ordinaryChar('(');
    stok.ordinaryChar(')');
    boolean colonOk = false;
    boolean isDisableCountNextTask = false; // only for primitive tasks
    currSequence.setDepth(0);

    while (stok.nextToken() != StreamTokenizer.TT_EOF) {
      switch (stok.ttype) {
        case StreamTokenizer.TT_WORD:
          String s = stok.sval;
          Constructor<? extends PerfTask> cnstr =
              taskClass(config, s).asSubclass(PerfTask.class).getConstructor(PerfRunData.class);
          PerfTask task = cnstr.newInstance(runData);
          task.setAlgLineNum(stok.lineno());
          task.setDisableCounting(isDisableCountNextTask);
          isDisableCountNextTask = false;
          currSequence.addTask(task);
          if (task instanceof RepSumByPrefTask) {
            stok.nextToken();
            String prefix = stok.sval;
            if (prefix == null || prefix.length() == 0) {
              throw new Exception("named report prefix problem - " + stok.toString());
            }
            ((RepSumByPrefTask) task).setPrefix(prefix);
          }
          // check for task param: '(' someParam ')'
          stok.nextToken();
          if (stok.ttype != '(') {
            stok.pushBack();
          } else {
            // get params, for tasks that supports them - allow recursive parenthetical expressions
            stok.eolIsSignificant(true); // Allow params tokenizer to keep track of line number
            StringBuilder params = new StringBuilder();
            stok.nextToken();
            if (stok.ttype != ')') {
              int count = 1;
              BALANCED_PARENS:
              while (true) {
                switch (stok.ttype) {
                  case StreamTokenizer.TT_NUMBER:
                    {
                      params.append(stok.nval);
                      break;
                    }
                  case StreamTokenizer.TT_WORD:
                    {
                      params.append(stok.sval);
                      break;
                    }
                  case StreamTokenizer.TT_EOF:
                    {
                      throw new RuntimeException("Unexpexted EOF: - " + stok.toString());
                    }
                  case '"':
                  case '\'':
                    {
                      params.append((char) stok.ttype);
                      // re-escape delimiters, if any
                      params.append(
                          stok.sval.replaceAll("" + (char) stok.ttype, "\\\\" + (char) stok.ttype));
                      params.append((char) stok.ttype);
                      break;
                    }
                  case '(':
                    {
                      params.append((char) stok.ttype);
                      ++count;
                      break;
                    }
                  case ')':
                    {
                      if (--count >= 1) { // exclude final closing parenthesis
                        params.append((char) stok.ttype);
                      } else {
                        break BALANCED_PARENS;
                      }
                      break;
                    }
                  default:
                    {
                      params.append((char) stok.ttype);
                    }
                }
                stok.nextToken();
              }
            }
            stok.eolIsSignificant(false);
            String prm = params.toString().trim();
            if (prm.length() > 0) {
              task.setParams(prm);
            }
          }

          // ---------------------------------------
          colonOk = false;
          prevTask = task;
          break;

        default:
          char c = (char) stok.ttype;

          switch (c) {
            case ':':
              if (!colonOk) throw new Exception("colon unexpexted: - " + stok.toString());
              colonOk = false;
              // get repetitions number
              stok.nextToken();
              if ((char) stok.ttype == '*') {
                ((TaskSequence) prevTask).setRepetitions(TaskSequence.REPEAT_EXHAUST);
              } else {
                if (stok.ttype != StreamTokenizer.TT_NUMBER) {
                  throw new Exception("expected repetitions number or XXXs: - " + stok.toString());
                } else {
                  double num = stok.nval;
                  stok.nextToken();
                  if (stok.ttype == StreamTokenizer.TT_WORD && stok.sval.equals("s")) {
                    ((TaskSequence) prevTask).setRunTime(num);
                  } else {
                    stok.pushBack();
                    ((TaskSequence) prevTask).setRepetitions((int) num);
                  }
                }
              }
              // check for rate specification (ops/min)
              stok.nextToken();
              if (stok.ttype != ':') {
                stok.pushBack();
              } else {
                // get rate number
                stok.nextToken();
                if (stok.ttype != StreamTokenizer.TT_NUMBER)
                  throw new Exception("expected rate number: - " + stok.toString());
                // check for unit - min or sec, sec is default
                stok.nextToken();
                if (stok.ttype != '/') {
                  stok.pushBack();
                  ((TaskSequence) prevTask).setRate((int) stok.nval, false); // set rate per sec
                } else {
                  stok.nextToken();
                  if (stok.ttype != StreamTokenizer.TT_WORD)
                    throw new Exception("expected rate unit: 'min' or 'sec' - " + stok.toString());
                  String unit = stok.sval.toLowerCase(Locale.ROOT);
                  if ("min".equals(unit)) {
                    ((TaskSequence) prevTask).setRate((int) stok.nval, true); // set rate per min
                  } else if ("sec".equals(unit)) {
                    ((TaskSequence) prevTask).setRate((int) stok.nval, false); // set rate per sec
                  } else {
                    throw new Exception("expected rate unit: 'min' or 'sec' - " + stok.toString());
                  }
                }
              }
              colonOk = false;
              break;

            case '{':
            case '[':
              // a sequence
              // check for sequence name
              String name = null;
              stok.nextToken();
              if (stok.ttype != '"') {
                stok.pushBack();
              } else {
                name = stok.sval;
                if (stok.ttype != '"' || name == null || name.length() == 0) {
                  throw new Exception("sequence name problem - " + stok.toString());
                }
              }
              // start the sequence
              TaskSequence seq2 = new TaskSequence(runData, name, currSequence, c == '[');
              currSequence.addTask(seq2);
              currSequence = seq2;
              colonOk = false;
              break;

            case '&':
              if (currSequence.isParallel()) {
                throw new Exception("Can only create background tasks within a serial task");
              }
              stok.nextToken();
              final int deltaPri;
              if (stok.ttype != StreamTokenizer.TT_NUMBER) {
                stok.pushBack();
                deltaPri = 0;
              } else {
                // priority
                deltaPri = (int) stok.nval;
              }

              if (prevTask == null) {
                throw new Exception("& was unexpected");
              } else if (prevTask.getRunInBackground()) {
                throw new Exception("double & was unexpected");
              } else {
                prevTask.setRunInBackground(deltaPri);
              }
              break;

            case '>':
              currSequence.setNoChildReport(); /* intentional fallthrough */
            case '}':
            case ']':
              // end sequence
              colonOk = true;
              prevTask = currSequence;
              currSequence = currSequence.getParent();
              break;

            case '-':
              isDisableCountNextTask = true;
              break;
          } // switch(c)
          break;
      } // switch(stok.ttype)
    }

    if (sequence != currSequence) {
      throw new Exception("Unmatched sequences");
    }

    // remove redundant top level enclosing sequences
    while (sequence.isCollapsable() && sequence.getRepetitions() == 1 && sequence.getRate() == 0) {
      ArrayList<PerfTask> t = sequence.getTasks();
      if (t != null && t.size() == 1) {
        PerfTask p = t.get(0);
        if (p instanceof TaskSequence) {
          sequence = (TaskSequence) p;
          continue;
        }
      }
      break;
    }
  }

  private String[] initTasksPackages(Config config) {
    String alts = config.get("alt.tasks.packages", null);
    String dfltPkg = PerfTask.class.getPackage().getName();
    if (alts == null) {
      return new String[] {dfltPkg};
    }
    ArrayList<String> pkgs = new ArrayList<>();
    pkgs.add(dfltPkg);
    for (String alt : alts.split(",")) {
      pkgs.add(alt);
    }
    return pkgs.toArray(new String[0]);
  }

  private Class<?> taskClass(Config config, String taskName) throws ClassNotFoundException {
    for (String pkg : taskPackages) {
      try {
        return Class.forName(pkg + '.' + taskName + "Task");
      } catch (ClassNotFoundException e) {
        // failed in this package, might succeed in the next one...
      }
    }
    // can only get here if failed to instantiate
    throw new ClassNotFoundException(
        taskName + " not found in packages " + Arrays.toString(taskPackages));
  }

  @Override
  public String toString() {
    String newline = System.getProperty("line.separator");
    StringBuilder sb = new StringBuilder();
    sb.append(sequence.toString());
    sb.append(newline);
    return sb.toString();
  }

  /** Execute this algorithm */
  public void execute() throws Exception {
    try {
      sequence.runAndMaybeStats(true);
    } finally {
      sequence.close();
    }
  }

  /**
   * Expert: for test purposes, return all tasks participating in this algorithm.
   *
   * @return all tasks participating in this algorithm.
   */
  public ArrayList<PerfTask> extractTasks() {
    ArrayList<PerfTask> res = new ArrayList<>();
    extractTasks(res, sequence);
    return res;
  }

  private void extractTasks(ArrayList<PerfTask> extrct, TaskSequence seq) {
    if (seq == null) return;
    extrct.add(seq);
    ArrayList<PerfTask> t = sequence.getTasks();
    if (t == null) return;
    for (final PerfTask p : t) {
      if (p instanceof TaskSequence) {
        extractTasks(extrct, (TaskSequence) p);
      } else {
        extrct.add(p);
      }
    }
  }

  @Override
  public void close() throws Exception {
    sequence.close();
  }
}