package com.walker.infrastructure.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 语句分段读取器，它能根据关键词分段读出中间的内容。</p>
 * 你可以设置多个分段关键词让分析器来处理，例如：
 * <pre>
 * I am a boy, but my sister is a good girl!</br>
 * 你可以设置关键词对来解析内容：[I,boy],[but ,girl!]
 * 经过这两个关键词分析后，会返回以下结果：</br>
 * [ am a],[ my sister is a good ]
 * </pre>
 * @author shikeying
 * @date 2013-7-17
 *
 */
public class SegmentReader {

	/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	 * 定义组件的选项开关
	 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
	
	/* 关键词是否大小写敏感，默认否 */
	private boolean keyCaseSensitive = false;
	
	public boolean isKeyCaseSensitive() {
		return keyCaseSensitive;
	}

	public void setKeyCaseSensitive(boolean keyCaseSensitive) {
		this.keyCaseSensitive = keyCaseSensitive;
	}

	/* 返回结果中是否包含关键词，默认不包含 */
	private boolean contentIncludeKey = false;
	
	/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	 * 定义组件内部私有变量
	 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
	
	public boolean isContentIncludeKey() {
		return contentIncludeKey;
	}

	public void setContentIncludeKey(boolean contentIncludeKey) {
		this.contentIncludeKey = contentIncludeKey;
	}

	private Logger logger = LoggerFactory.getLogger(this.getClass());
	
	/* 最终分析过后的字符串内容 */
	private final StringBuilder totalResult = new StringBuilder(512);
	
	/* 解析后的最终结果，可以通过关键词对来查找对应结果 */
//	private final Map<KeyExpression, StringBuilder> result = new HashMap<KeyExpression, StringBuilder>(2);
	private final Map<KeyExpression, List<StringBuilder>> result2 = new HashMap<KeyExpression, List<StringBuilder>>(2);
	
	/* 用户添加的所有关键词信息 */
	private final List<KeyExpression> keys = new ArrayList<KeyExpression>(2);
	
	/* 开始关键词与结束关键词对应，便于快速查找 */
	private final Map<String, String> startEndKeys = new HashMap<String, String>(2);
	
	private int maxStartKeyLength, maxEndKeyLength = 0;
	
	/* 当前已经扫描过入栈字符 */
	private LinkedList<Character> scanStack = new LinkedList<Character>();
	
	/* 已入栈的关键词 */
	private LinkedList<String> existKeysStack = new LinkedList<String>();
	
	/* 关键词排除的字符集合，即有些关键词不能出现在特定的字符中 */
	/* 例如SQL语句中关键词分号不能在''中，有些字符串中也会包含关键词 */
	/* 这些被排除的字符都是成对出现的。 */
	public static final Set<Character> keyExcludedCharSet = new HashSet<Character>();
	
	static {
		keyExcludedCharSet.add('\'');
	}
	
	private LinkedList<Character> keyExcludedCharStack = new LinkedList<Character>();
	
	/** ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	 * 
	 *  组件暴露方法调用
	 * 
	 ** ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
	
	/**
	 * 读取给定的语句，组件准备分析
	 * @param sentence
	 * @return 返回分析过的最终完整的语句内容
	 */
	public String read(String sentence){
		assert (sentence != null && !sentence.equals(""));
		if(keys.size() == 0)
			throw new IllegalStateException("keys is required.");
		
		getMaxKeyLength();
		for(KeyExpression ke : keys){
//			result.put(ke, new StringBuilder(512));
			result2.put(ke, new ArrayList<StringBuilder>());
			startEndKeys.put(ke.getStartKey(), ke.getEndKey());
		}
		
		for(char c : (keyCaseSensitive ? sentence.toCharArray() : sentence.toLowerCase().toCharArray())){
			readOneCharacter(c, false);
		}
		
		/**
		 * 修复bug(bug20131202-1)：如果把语句整体转换成小写，可能改变原始内容，例如：SQL语句中ID字段</br>
		 * 会全部为小写，这样就影响了业务对数据的使用。所以不能转换小写。
		 */
//		for(char c : sentence.toCharArray()){
//			readOneCharacter(c, false);
//		}
		
		/* 处理最后一个读取字符问题 */
		readOneCharacter(scanStack.peekLast(), true);
		
		return totalResult.toString();
	}
	
	/**
	 * 返回关键词对应的处理结果，
	 * @param startKey 开始关键词
	 * @param endKey 结束关键词
	 * @return
	 */
	public String getSolvedContent(String startKey, String endKey){
		KeyExpression ke = new KeyExpression(startKey, endKey);
//		StringBuilder sb = this.result.get(ke);
		List<StringBuilder> sb = this.result2.get(ke);
		return sb == null ? null : sb.size() == 0 ? null : sb.get(0).toString();
	}
	
	/**
	 * 根据关键词，返回该关键词包含的分析结果列表。</br>
	 * 输入的关键词不能嵌套，是平行关系。如下示例：
	 * <pre>
	 * select ... from ... (select * from ...).
	 * select是开始，from是结束关键词
	 * </pre>
	 * @param startKey
	 * @param endKey
	 * @return
	 */
	public List<StringBuilder> getSolvedList(String startKey, String endKey){
		return this.result2.get(new KeyExpression(startKey, endKey));
	}
	
	/**
	 * 关键词分析后的结果处理模式: 存储
	 */
	public static final int RESULT_MODE_STORE     = 1;

	/**
	 * 关键词分析后的结果处理模式: 删除
	 */
	public static final int RESULT_MODE_REMOVE    = 2;

	/**
	 * 关键词分析后的结果处理模式: 替换内容
	 */
	public static final int RESULT_MODE_REPLACE   = 3;

	/**
	 * 关键词分析后的结果处理模式: 通过回调接口来处理
	 */
	public static final int RESULT_MODE_CALLBACK = 4;

	/**
	 * 添加默认的关键词，系统默认会返回解析的结果
	 * @param startKey 开始关键词
	 * @param endKey 结束关键词，可以没有
	 */
	public void addKey(String startKey, String endKey){
		addKey(startKey, endKey, RESULT_MODE_STORE);
	}
	
	/**
	 * 添加关键词，删除行为。即：关键词之间的内容被删除
	 * @param startKey
	 * @param endKey
	 */
	public void addRemoveKey(String startKey, String endKey){
		addKey(startKey, endKey, RESULT_MODE_REMOVE);
	}
	
	/**
	 * 添加关键词，替换行为。即：关键词之间内容会被替换
	 * @param startKey
	 * @param endKey
	 * @param replace 要替换的内容
	 */
	public void addReplaceKey(String startKey, String endKey, String replace){
		addKey(startKey, endKey, RESULT_MODE_REPLACE, replace);
	}
	
	/**
	 * 添加关键词，回调行为。即：关键词之间内容会被回调接口继续调用，最终结果仍会返回
	 * @param startKey
	 * @param endKey
	 * @param callback 用户自定义实现的回调实现
	 */
	public void addCallbackKey(String startKey, String endKey, CallBack callback){
		addKey(startKey, endKey, RESULT_MODE_CALLBACK, callback);
	}
	
	
	/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	 * 组件内部私有方法
	 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
	
	private void addKey(String startKey, String endKey, int mode, Object ...others){
		assert (startKey != null && !startKey.equals(""));
		if(!keyCaseSensitive){
			startKey = startKey.toLowerCase();
			endKey = (endKey == null ? null : endKey.toLowerCase());
		}
		
		for(KeyExpression ke : keys){
			if(ke.getStartKey().equals(startKey))
				throw new IllegalArgumentException("设置的开始关键字重复, key = " + startKey);
		}
		
		KeyExpression ke = new KeyExpression(startKey, endKey);
		
		if(mode == RESULT_MODE_REPLACE || mode == RESULT_MODE_CALLBACK){
			if(others == null || others.length > 1)
				throw new IllegalArgumentException("argument is required in mode 'REPLACE' and 'CALLBACK'.");
			if(mode == RESULT_MODE_REPLACE){
				if(!(others[0] instanceof String))
					throw new IllegalArgumentException("argument of replace must be String.");
				else
					ke.setResultMode(RESULT_MODE_REPLACE)
					.setReplace(others[0].toString());
			}
			if(mode == RESULT_MODE_CALLBACK){
				if(!(others[0] instanceof CallBack))
					throw new IllegalArgumentException("argument of callback must be CallBack.");
				else
					ke.setResultMode(RESULT_MODE_CALLBACK)
					.setCallBack((CallBack)others[0]);
			}
		} else if(mode == RESULT_MODE_REMOVE){
			ke.setResultMode(RESULT_MODE_REMOVE);
		}
		keys.add(ke);
	}
	
	private void getMaxKeyLength(){
		int skSize = 0;
		int ekSize = 0;
		for(KeyExpression ke : keys){
			int k1 = ke.getStartKey().length();
			if(k1 > skSize){
				skSize = k1;
			}
			if(ke.getEndKey() != null && ke.getEndKey().length() > ekSize){
				ekSize = ke.getEndKey().length();
			}
		}
		this.maxStartKeyLength = skSize;
		this.maxEndKeyLength = ekSize;
		logger.debug("maxStartKeyLength = " + maxStartKeyLength);
		logger.debug("maxEndKeyLength = " + maxEndKeyLength);
	}
	
	private char previousRead;
	
	private void readOneCharacter(char c, boolean isLastRead){
		/* 读到空格，而且上一个也是空格，忽略 */
		if(c == 32 && previousRead == 32) return;
		
		checkKeyExcludedChar(c);
		
//		String scaned = getScanedChars().trim();
		String scaned = getScanedChars();
//		System.out.println("已扫描内容 = " + scaned);
		
		doMatchedInScaned(scaned);
		
		if(!isLastRead){
			scanStack.addLast(c);
			previousRead = c;
		} else {
			// 读到最后一个字符了，如果栈中存在内容就输出
			this.totalResult.append(getScanedChars());
		}
	}
	
	/**
	 * 栈中是否存在被排除的字符，如果存在返回<code> true </code>
	 * @return
	 */
	private boolean inExcludedCharStack(){
		return !keyExcludedCharStack.isEmpty();
	}
	
	/**
	 * 检查输入的字符是否是排除的字符
	 * @param c
	 */
	private void checkKeyExcludedChar(char c){
		if(keyExcludedCharSet.contains(c)){
			Character existInStack = this.keyExcludedCharStack.peekLast();
			if(existInStack != null && c == existInStack){
//				logger.debug("读入的字符在排除字符栈中已经存在,配对成功, 可以清除了. char = " + c);
				keyExcludedCharStack.pollLast();
			} else {
//				logger.debug("读入的字符是要排除的字符，但栈顶并没有匹配的，直接加入栈顶");
				keyExcludedCharStack.offerLast(c);
			}
		}
	}
	
	/**
	 * 在已经扫描的字符串中，是否存在匹配的关键词
	 * @return
	 */
	private boolean doMatchedInScaned(String scaned){
		String findStartKey = doMatchStartKey(scaned);
		if(findStartKey != null){
			/* 在清空扫描栈之前，需要保存到关键词对应变量中 */
			String savedData = null;
			String savedKey = null;
			if(!scaned.equals(findStartKey)) {
//				savedData = this.contentIncludeKey ? scaned : scaned.replaceAll(findStartKey, "");
				
				//2017-06-05 时克英修改，对于单符号关键词，必须用转义表示正则表达式
				if(findStartKey.equals("{") || findStartKey.equals("[")){
					savedData = this.contentIncludeKey ? scaned : scaned.replaceAll("\\\\" + findStartKey, "");
				} else {
					savedData = this.contentIncludeKey ? scaned : scaned.replaceAll(findStartKey, "");
				}
			}
			savedKey = existKeysStack.peekLast();
			if(savedKey != null){
				int index = storedKeyCounter.get(savedKey);
				List<StringBuilder> sbs = result2.get(new KeyExpression(savedKey
						, startEndKeys.get(savedKey)));
				sbs.get(index).append(savedData == null ? "" : savedData);
//				result.get(new KeyExpression(savedKey
//						, startEndKeys.get(savedKey))).append(savedData == null ? "" : savedData);
			}
			
			existKeysStack.offerLast(findStartKey);
			scanStack.clear();
			return true;
		}
		
		String existStartKey = existKeysStack.peekLast();
		String endKey = existStartKey == null ? null : startEndKeys.get(existStartKey);
		
		String matchedEndKey = doMatchEndKey(scaned, existStartKey, endKey);
		if(matchedEndKey != null){
			existKeysStack.pollLast();
			scanStack.clear();
			return true;
		}
		return false;
	}
	
	private String doMatchEndKey(String scaned, String startKey, String endKey){
		int _ss = scaned.length();
		int size = 0;
		String cbCall = null;
		for(KeyExpression ke : keys){
			if(ke.getEndKey() == null) continue;
			if(!ke.getStartKey().equalsIgnoreCase(startKey)) continue; // 必须是与开始匹配的结束，否则不比较
			size = ke.getEndKey().length();
//			if(_ss >= size && scaned.indexOf(ke.getEndKey()) >= 0){
			if(_ss >= size && scaned.endsWith(ke.getEndKey()) && !inExcludedCharStack()){
				if(ke.getResultMode() == RESULT_MODE_STORE){
					writeResult2(scaned, ke);
					
				} else if(ke.getResultMode() == RESULT_MODE_REMOVE){
					if(this.contentIncludeKey)
						totalResult.append(ke.getEndKey());
					
				} else if(ke.getResultMode() == RESULT_MODE_REPLACE){
					writeResult2(ke.getReplace(), ke);
					
				} else if(ke.getResultMode() == RESULT_MODE_CALLBACK){
					cbCall = ke.getCallBack().afterSegment(scaned, ke.getStartKey(), ke.getEndKey());
					writeResult2(cbCall, ke);
				}
				return ke.getEndKey();
			}
		}
		return null;
	}
	
	private Map<String, Integer> storedKeyCounter = new HashMap<String, Integer>(2);
	
	private String doMatchStartKey(String scaned){
		int _ss = scaned.length();
		int size = 0;
		String startKey = null;
		String previousKey = null; // 栈中保存的开始关键词
		for(KeyExpression ke : keys){
			startKey = ke.getStartKey();
			size = ke.getStartKey().length();
			if(_ss >= size && scaned.endsWith(startKey)){
				/* 如果后续字符串中包含了开始关键词，我们并不处理，因为主要通过单词来区分而不是字符 */
				previousKey = existKeysStack.peekLast();
				if(previousKey != null && previousKey.equals(startKey))
					continue;
				
				/* 删除关键词优先处理，如果发现栈里面已经存在关键词（开始） */
				/* 并且是一个删除类型，那么后面嵌套的关键词就不再处理。 */
				if(hasRemovedKeyInStack()) continue;
				
				/* 遇到内容中存在多处相同的关键词时，我们需要同时保留这些分析结果 */
				if(ke.getResultMode() != RESULT_MODE_REMOVE){
					Integer i = storedKeyCounter.get(startKey);
					if(i == null){
						i = 0;
						storedKeyCounter.put(startKey, i);
						logger.debug("已存储的key '" + startKey + "' i=0.");
					} else {
						storedKeyCounter.put(startKey, ++i);
						logger.debug("已存储的key '" + startKey + "' i=" + i);
					}
					List<StringBuilder> sbs = result2.get(new KeyExpression(startKey
							, startEndKeys.get(startKey)));
					sbs.add(i, new StringBuilder());
					logger.debug("key '" + startKey + "' 创建了第" + i + "个StringBuilder.");
				}
				/*--------------------------------------------------*/
				
				if(this.contentIncludeKey){
					totalResult.append(scaned);
				} else {
//					totalResult.append(scaned.replaceAll(ke.getStartKey(), ""));
					if(scaned.endsWith(ke.getStartKey())){
						int indx = scaned.length() - ke.getStartKey().length();
						totalResult.append(scaned.substring(0, indx));
					} else
						totalResult.append(scaned);
				}
				return ke.getStartKey();
			}
		}
		return null;
	}
	
	private void writeResult2(String scaned, KeyExpression ke){
		writeResult2(scaned, ke, true);
	}
	private void writeResult2(String scaned, KeyExpression ke, boolean includeTotalResult){
		int index = storedKeyCounter.get(ke.getStartKey());
		if(this.contentIncludeKey){
			result2.get(ke).get(index).append(scaned);
			if(includeTotalResult)
				totalResult.append(scaned);
		} else {
//			result2.get(ke).get(index).append(scaned.replaceAll(, ""));
//			totalResult.append(scaned.replaceAll(ke.getEndKey(), ""));
			int eIndx = scaned.length() - ke.getEndKey().length();
			result2.get(ke).get(index).append(scaned.substring(0, eIndx));
			if(includeTotalResult)
				totalResult.append(scaned.substring(0, eIndx));
		}
	}
	
	/**
	 * 在关键词栈中已经存在了"删除类型的关键词"
	 * @return 如果存在返回<code>true</code>
	 */
	private boolean hasRemovedKeyInStack(){
		String _existKey = existKeysStack.peekLast();
		if(_existKey == null) return false;
		KeyExpression _k = new KeyExpression(_existKey, startEndKeys.get(_existKey));
		for(KeyExpression ke : keys){
			if(ke.equals(_k) && ke.getResultMode() == RESULT_MODE_REMOVE){
				return true;
			}
		}
		return false;
	}
	
	private String getScanedChars(){
		StringBuilder sb = new StringBuilder(8);
		for(char c : scanStack){
			sb.append(c);
		}
		return sb.toString();
	}
	
	/**
	 * 定义关键词表达式对象，内部用来处理关键词的各种属性和逻辑</br>
	 * 这是封装的一个好处，系统通过此对象来完成对关键词的各种操作。
	 * @author shikeying
	 *
	 */
	private class KeyExpression {
		private String startKey;
		private String endKey;
		private int resultMode = RESULT_MODE_STORE;
		private CallBack callBack;
		private String replace;
		
		public KeyExpression(String startKey, String endKey){
			assert (startKey != null && !startKey.equals(""));
			if(!keyCaseSensitive){
				this.startKey = startKey.toLowerCase();
				this.endKey = (endKey == null ? null : endKey.toLowerCase());
			} else {
				this.startKey = startKey;
				this.endKey = endKey;
			}
		}
		
		public String getStartKey() {
			return startKey;
		}

		public String getEndKey() {
			return endKey;
		}

		public String getReplace() {
			return replace;
		}

		public CallBack getCallBack() {
			return callBack;
		}

		public int getResultMode() {
			return resultMode;
		}

		public KeyExpression setResultMode(int mode){
			this.resultMode = mode;
			return this;
		}
		
		public KeyExpression setReplace(String replace){
			this.replace = replace;
			return this;
		}
		public KeyExpression setCallBack(CallBack callback){
			this.callBack = callback;
			return this;
		}
		
		public int hashCode(){
			return (31 + 13*this.startKey.hashCode() 
					+ (this.endKey == null ? 0 : this.endKey.hashCode()*13));
		}
		
		public boolean equals(Object o){
			if(o == null) return false;
			if(o instanceof KeyExpression){
				KeyExpression ke = (KeyExpression)o;
				if(ke == this) return true;
				if(ke.startKey.equals(this.startKey)){
					return (ke.endKey == null ? 
							(this.endKey == null ? true : false) 
							: (this.endKey != null && this.endKey.equals(ke.endKey) ? true : false));
				}
			}
			return false;
		}
		
		public String toString(){
			return new StringBuilder().append("{skey=").append(startKey)
					.append(", ekey=").append(endKey)
					.append(", mode=").append(resultMode)
					.append(", replace=").append(replace)
					.append(", callback=").append(callBack==null ? "" : callBack.getClass().getName())
					.append("}").toString();
		}
	}
	
	/**
	 * 分段语句处理回调函数，用户可以自定义实现系统分析后的结果
	 * @author shikeying
	 *
	 */
	protected interface CallBack{
		String afterSegment(String segmentResult, String keyStart, String keyEnd);
	}
	
	/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	 * test method
	 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
	void print(){
		System.out.println("previousRead = " + (int)previousRead);
		System.out.println("scanStack = " + scanStack.toArray());
		for(char c : scanStack)
			System.out.print(c);
	}
	
	public static void main(String[] args){
//		SegmentReader sr = new SegmentReader();
//		sr.addKey("boy", "girl");
//		sr.addKey("must ", null);
//		String result = sr.read("I am a boy, but my sister is     a good girl.");
//		sr.print();
//		System.out.println("========= result ======== \t");
//		System.out.println(result);
//		System.out.println("========= getKeys(boy,girl) ======== \t");
//		System.out.println(sr.getSolvedContent("boy", "girl"));
		
		StringBuilder test = new StringBuilder();
		test.append("OPEN out_cursor FOR\r\n");
		test.append("--查询电子钱包消费和月票消费\r\n");
		test.append("SELECT cardtype,\r\n");
		test.append("NVL (SUM (operno), 0) AS operno,\r\n");
		test.append("NVL (SUM (viceopermn), 0) AS viceopermn\r\n");
		test.append("to_char('sum',10,90) end");
		test.append("FROM (                              --电子钱包和月票钱包\r\n");
		test.append("select * FROM TABLE t WHERE opdt >= TO_DATE(prmsdate, 'YYYY-MM-DD HH24:MI;SS'));");
		test.append("ELSE \r\n");
		test.append("OPEN out_cursor FOR querysql;\r\n");
		System.out.println(test);
		System.out.println("--------- start... ---------");
		
		SegmentReader sr2 = new SegmentReader();
		sr2.setKeyCaseSensitive(true);
		sr2.addKey("OPEN out_cursor FOR", ";");
		sr2.addRemoveKey("--", "\r\n");
		sr2.addKey("to_char", "end");
		System.out.println(sr2.read(test.toString()));
		System.out.println("------------------");
		System.out.println(sr2.getSolvedList("OPEN out_cursor FOR", ";"));
		System.out.println("##########");
		System.out.println(sr2.getSolvedContent("to_char", "end"));
		
		//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		String srcSql = "select * from s_user_core where id = {uid}";
		SegmentReader sr = new SegmentReader();
//		sr.setKeyCaseSensitive(false);
		sr.addKey("{", "}");
		System.out.println(sr.read(srcSql));
		List<StringBuilder> paramList = sr.getSolvedList("{", "}");
		System.out.println(paramList);
	}
}