package org.jr.jzj.editor;
/**
 * <p>Copyright: Copyright (c) 2002-2003</p>
 * <p>Company: JavaResearch(http://www.javaresearch.org)</p>
 * <p>最后更新日期:2003年3月20日
 * @author Barney,Cherami,Brain
 * @version 0.8
 */

import java.util.*;


public class SyntaxScanner {
  /**
   * all token types
   */
  public static final int NO_TOKEN = -1;
  public static final int TEXT = 0;
  public static final int STRING = 1;
  public static final int COMMENT = 2;
  public static final int LINE_COMMENT = 3;
  public static final int MULTI_COMMENT = 4;
  public static final int KEY_WORD = 5;
  public static final int CLASS = 6;
  public static final int PLAIN_TEXT = 7;
  public static final int TAG = 8;
  public static final int CONTENT = 9;
  public static final int DOC_COMMENT = 10;
  public static final int SCRIPT = 11;
  //
  public static final int NUM_TOKEN_TYPES = 12;

  public static int BACKUP = 2048;
  protected int currentlyScanning = NO_TOKEN;
  protected int token = NO_TOKEN;
  protected int stop = 0;
  protected char[] source = {};
  protected int pos = 0;
  protected static TreeSet keywords;
  protected static TreeSet classes;
  protected int contentType = SyntaxDocument.SYNTAX_SOURCE;
  protected boolean prevTagScript = false;
  protected boolean isInTag = false;
  protected SyntaxParser parser;

  protected SyntaxScanner(SyntaxParser parser) {
    this.parser = parser;
    buildTrees();
  }

  /**
   * 返回一個句柄
   * @return
   */
  public static SyntaxScanner newInstance() {
    return (new DefaultScanner());
  }

  /**
   * 返回一個句柄
   * @return
   */
  public static SyntaxScanner newInstance(SyntaxParser parser) {
    SyntaxScanner scanner;
    if (parser == null) {
      scanner = new DefaultScanner();
    }
    else {
      try {
        scanner = new SyntaxScanner(parser);
      }
      catch (Exception ex) {
        ex.printStackTrace();
        scanner = new DefaultScanner();
      }
    }

    return scanner;
  }

  /**
   * Token type
   * @return
   */
  public int getToken() {
    return token;
  }

  /**
   * 設置作用區域
   * @param strt
   * @param end
   * @param str
   */
  public void setRange(int strt, int end, String str) {
    stop = end;
    source = str.toCharArray();
    if (stop > source.length) {
      stop = source.length;
    }
    pos = strt;
    pos -= BACKUP;
    if (pos < 0) {
      pos = 0;
    }
  }

  /**
   *
   * @param buff
   */
  protected void setTokenFrom(StringBuffer buff) {
    if (buff == null) {
      return;
    }
    token = TEXT;
    if (keywords.contains(buff.toString())) {
      token = KEY_WORD;
    }
    if (classes.contains(buff.toString())) {
      token = CLASS;
    }
  }

  /**
   *
   * @return
   */
  public int getEndOffset() {
    return pos;
  }

  /**
   * 返回內容類型
   * @return
   */
  public int getContentType() {
    return contentType;
  }

  /**
   * 設置內容類型
   * @param type
   */
  public void setContentType(int type) {
    contentType = type;
  }

  /**
   * 掃描設置
   */
  public void scan() {
    switch (contentType) {
      case SyntaxDocument.SYNTAX_SOURCE:
        scanSyntaxSource();
        break;
      case SyntaxDocument.MARKUP:
        scanMarkup();
        break;
      default:
        scanPlainText();
        break;
    }
  }

  /**
   * 無格式文本
   */
  protected void scanPlainText() {
    pos = stop;
    token = TEXT;
  }

  /** @todo  */
  /**
   * 建立語法樹
   */
  protected void buildTrees() {
    if (parser != null) {
      classes = parser.getClasses();
      keywords = parser.getKeywords();
    }
  }

  /**
   * 語法文本
   */
  protected void scanSyntaxSource() {
    StringBuffer buff = null;
    token = NO_TOKEN;
    currentlyScanning = NO_TOKEN;
    boolean firstPass = true;
    char curChar = 0;
    char prevChar = 0;
    char nextChar = 0;
    while (pos < stop) {
      prevChar = curChar;
      curChar = source[pos];
      nextChar = (pos + 1 < stop) ? source[pos + 1] : 0;
      if ( (curChar > 64 && curChar < 91) || (curChar > 96 && curChar < 123)) {
        // text
        if (currentlyScanning == NO_TOKEN) {
          if (firstPass) {
            buff = new StringBuffer();
            currentlyScanning = TEXT;
          }
          else {
            token = TEXT;
            return;
          }
        }
        if (currentlyScanning == TEXT) {
          buff.append(curChar);
        }
      }
      else {
        // other characters
        switch (curChar) {
          case '/':
            if (currentlyScanning == STRING ||
                currentlyScanning == LINE_COMMENT) {
              break;
            }
            if (currentlyScanning == MULTI_COMMENT) {
              if (prevChar == '*') {
                token = COMMENT; // MULTI_LINE
                pos++;
                return;
              }
            }
            if (currentlyScanning == TEXT) {
              if (nextChar == '/' || nextChar == '*') {
                setTokenFrom(buff);
                return;
              }
              else {
                buff.append('/');
              }
            }
            if (currentlyScanning == NO_TOKEN) {
              if (nextChar == '*' || nextChar == '/') {
                if (firstPass) {
                  if (nextChar == '*') {
                    currentlyScanning = MULTI_COMMENT;
                  }
                  else {
                    currentlyScanning = LINE_COMMENT;
                  }
                }
                else {
                  token = TEXT;
                  return;
                }
              }
            }
            break;
          case '\n':
            if (currentlyScanning == MULTI_COMMENT) {
              break;
            }
            if (currentlyScanning == LINE_COMMENT) {
              token = LINE_COMMENT;
              pos++;
              return;
            }
            if (currentlyScanning == STRING) {
              token = STRING;
              pos++;
              return;
            }
            if (currentlyScanning == NO_TOKEN) {
              break;
            }
            if (currentlyScanning == TEXT) {
              setTokenFrom(buff);
              pos++;
              return;
            }
            break;
          case '"':

//					case '\'':
            if (currentlyScanning == MULTI_COMMENT ||
                currentlyScanning == LINE_COMMENT) {
              break;
            }
            if (currentlyScanning == NO_TOKEN && prevChar != '\'') {
              if (firstPass) {
                currentlyScanning = STRING;
                break;
              }
              else {
                token = TEXT;
                return;
              }
            }
            if (currentlyScanning == STRING) {
              if (prevChar != '\\') {
                token = STRING;
                pos++;
                return;
              }
            }
            if (currentlyScanning == TEXT) {
              // we've run into the start of a string
              setTokenFrom(buff);
              return;
            }

            // all of these can end a key word
          case '.':
          case ' ':
          case ',':
          case ':':
          case ';':
          case '\t':
          case '\r':
          case '{':
          case '}':
          case '(':
          case ')':
          case '[':
          case ']':
            if (currentlyScanning == TEXT) {
              setTokenFrom(buff);
              return;
            }
          default:
            if (currentlyScanning == TEXT) {
              buff.append(curChar);
            }
        } // switch
      } // end if
      pos++;
      firstPass = false;
    } // while
    token = currentlyScanning;
    if (token == MULTI_COMMENT) {
      token = COMMENT;
    }
    if (token == TEXT) {
      setTokenFrom(buff);
    }
    if (token == NO_TOKEN) {
      token = TEXT;
    }
  }

  /**
   *
   */
  protected void scanMarkup() {
    StringBuffer buff = null;
    token = NO_TOKEN;
    currentlyScanning = NO_TOKEN;
    char curChar = 0;
    char prevChar = 0;
    char nextChar = 0;
    boolean firstPass = true;
    boolean isInQuote = false;
    if (prevTagScript) {
      currentlyScanning = SCRIPT;
    }
    if (isInTag) {
      currentlyScanning = TAG;
      buff = new StringBuffer();
    }
    while (pos < stop) {
      nextChar = source[pos];
      if ( (nextChar == ' ') || (nextChar == '\n') || (nextChar == '\t') ||
          (nextChar == '\r')) {
        pos++;
        continue;
      }
      prevChar = curChar;
      curChar = nextChar;
      nextChar = (pos + 1 < stop) ? source[pos + 1] : 0;
      switch (curChar) {
        case '<':
          if (currentlyScanning == SCRIPT) {
            break;
          }
          if (firstPass) {
            if (nextChar == '%') {
              currentlyScanning = SCRIPT;
            }
            else {
              isInTag = true;
              currentlyScanning = TAG;
              buff = new StringBuffer();
            }
          }
          else {
            token = currentlyScanning;
            prevTagScript = false;
            if (token == NO_TOKEN) {
              token = CONTENT;
            }
            return;
          }
          break;
        case '>':
          if (currentlyScanning == TAG) {
            String tagName = buff.toString();
            tagName = tagName.toLowerCase();
            prevTagScript = (tagName.startsWith("script"));
            token = TAG;
            isInTag = false;
            pos++;
            return;
          }
          if (currentlyScanning == DOC_COMMENT) {
            token = DOC_COMMENT;
            prevTagScript = false;
            isInTag = false;
            pos++;
            return;
          }
          if (currentlyScanning == SCRIPT && prevChar == '%') {
            token = SCRIPT;
            prevTagScript = false;
            pos++;
            return;
          }
          break;
        case '-':
          if (currentlyScanning == SCRIPT) {
            break;
          }
          if (currentlyScanning == TAG && prevChar == '!' && nextChar == '-') {
            currentlyScanning = DOC_COMMENT;
            break;
          }
          break;
        case '\"':
          if (currentlyScanning == SCRIPT && prevChar != '\\') {
            isInQuote = !isInQuote;
          }
          break;
        default:
          if (buff != null) {
            buff.append(curChar);
          }
      }
      firstPass = false;
      pos++;
    }
    token = currentlyScanning;
    if (token == NO_TOKEN) {
      token = CONTENT;
    }
    prevTagScript = false;
  }
}