package com.smtaiserver.smtaiserver.core;

import java.io.File;
import java.net.URLEncoder;
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.duckdb.DuckDBAppender;
import org.duckdb.DuckDBConnection;
import org.springframework.web.context.request.NativeWebRequest;


import com.smtservlet.core.SMTRequest;
import com.smtservlet.exception.SMTAuthorityException;
import com.smtservlet.util.Json;
import com.smtservlet.util.SMTJsonWriter;
import com.smtservlet.util.SMTStatic;
import com.smtaiserver.smtaiserver.database.SMTDatabase;
import com.smtaiserver.smtaiserver.database.SMTDatabase.DBRecord;
import com.smtaiserver.smtaiserver.database.SMTDatabase.DBRecords;
import com.smtaiserver.smtaiserver.javaai.qwen.SMTQwenApp;
import com.smtservlet.core.SMTApp.SMTRequestConfig;

public class SMTAIServerRequest extends SMTRequest 
{
	public static class AIAttachFile
	{
		public String				_fileId;
		public String				_fileName;
		public String				_fileText;
		
		public AIAttachFile(String fileId, String fileName, String fileText)
		{
			_fileId = fileId;
			_fileName = fileName;
			_fileText = fileText;
		}
		
		public String toAttachMessage()
		{
			return "附加文件 : " + _fileName + "\n" + _fileText + "\n";
		}
		
		public void addToJson(SMTJsonWriter jsonWr)
		{
			jsonWr.addKeyValue("file_id", _fileId);
			jsonWr.addKeyValue("file_name", _fileName);
			jsonWr.addKeyValue("file_content", _fileText);
		}
	}
	
	private static Logger 			_logger = LogManager.getLogger(SMTAIServerRequest.class);
	private static Set<String>		_setPublicUrl;
	private static List<String>		_listPublicUrl;

	
	static {
		_listPublicUrl = new ArrayList<>();
		_listPublicUrl.add("swagger-resources");
		_listPublicUrl.add("v2/api-docs");
		_listPublicUrl.add("swagger-json");
		
		_setPublicUrl = new HashSet<String>();
		
	}
	
	private String					_curGroupType = null;
	private boolean					_isChunked = false;
	private String					_chatHistoryId;
	private String					_aiQuestion;
	private String					_rawQuestion;
	private String					_asyncProcessId;
	private StringBuilder			_sbTraceQuestion;
	private SMTJsonWriter			_jsonWrParamJson;
	private SMTJsonWriter			_jsonWrExtCallJson;
	private SMTJsonWriter			_jsonWrAsyncQueryJson;
	private List<Json>				_listSupervisorJson;
	private Map<String, Json>		_mapId2CallFuncJson;
	private boolean 				_isAgentCheckMode = false;
	private List<Json>				_listChatExecProcess = null;
	private String[]				_chatOrderDimName = null;
	private List<String>			_contentSampleQuestion = null;
	private double[]				_curQuestionPos;
	private SMTDatabase				_dbDuckResult = null;
	private SMTJsonWriter			_jsonWrResult = null;
	private List<SMTJsonWriter>		_listJsonWrResult = null;
	private boolean					_disableConclusion = false;
	private List<AIAttachFile>		_listAttchFile = null;
	private Json					_jsonAttachTables = null;
	private Json					_jsonAttachMetrics = null;
	private long					_lastSendChunkedStreamBlockTick = 0;
	private boolean					_sendStarStream = false; // 将输出文字变成*


	@Override
	public void initInstance(NativeWebRequest webRequest, String requestCode, SMTRequestConfig requestConfig) throws Exception
	{
		super.initInstance(webRequest, requestCode, requestConfig);

		boolean isPublicUrl = false;
		for(String url : _listPublicUrl)
		{
			if(requestCode.startsWith(url))
			{
				isPublicUrl = true;
				break;
			}
		}
		
		if(!isPublicUrl && !_setPublicUrl.contains(requestCode) &&
		   !requestConfig._jsonConfig.safeGetBoolean("no_shrio", false))
		{
			if(this.getLoginUserId() == null)
				throw new SMTAuthorityException("无权限");
		}
	}
	
	public boolean setSendStarStream(boolean isSetStartStream)
	{
		boolean org = _sendStarStream;
		if("true".equals(System.getProperty("show_ai_stream")))
			isSetStartStream = false;
		_sendStarStream = isSetStartStream; 
		return org;
	}
	
	public void setAttachTables(Json jsonTables)
	{
		_jsonAttachTables = jsonTables;
	}

	public void setJsonAttachMetrics(Json attachMetrics)
	{
		_jsonAttachMetrics = attachMetrics;
	}
	public String[] getAttachMessage()
	{
		List<String> list = new ArrayList<>();
		
		if(_listAttchFile != null)
		{
			for(AIAttachFile file : _listAttchFile)
			{
				list.add(file.toAttachMessage());
			}
		}
		
		if(_jsonAttachTables != null)
		{
			for(Json jsonAttachTable : _jsonAttachTables.asJsonList())
			{
				StringBuilder sbText = new StringBuilder();
				sbText.append("现有表格：" + jsonAttachTable.getJson("title").asString() + "\n");
				List<Json> jsonColumns = jsonAttachTable.getJson("columns").asJsonList();
				for(int i = 0; i < jsonColumns.size(); i ++)
				{
					if(i > 0)
						sbText.append(",");
					sbText.append(jsonColumns.get(i).asString());
				}
				sbText.append("\n");
				for(Json jsonRecord : jsonAttachTable.getJson("values").asJsonList())
				{
					List<Json> listRec = jsonRecord.asJsonList();
					for(int i = 0; i < listRec.size(); i ++)
					{
						if(i > 0)
							sbText.append(",");
						if(listRec.get(i).isNull())
							sbText.append("");
						else
							sbText.append(listRec.get(i).asString());						
					}
					sbText.append("\n");
				}
				sbText.append("\n");
				list.add(sbText.toString());
			}
		}
		
		if(_jsonAttachMetrics != null)
		{
			for(Json jsonAttachTable : _jsonAttachMetrics.asJsonList())
			{
				StringBuilder sbText = new StringBuilder();
				sbText.append("现有表格：" + jsonAttachTable.getJson("title").asString() + "\n");
				List<Json> jsonColumns = jsonAttachTable.getJson("columns").asJsonList();
				for(int i = 0; i < jsonColumns.size(); i ++)
				{
					if(i > 0)
						sbText.append(",");
					sbText.append(jsonColumns.get(i).asString());
				}
				sbText.append("\n");
				for(Json jsonRecord : jsonAttachTable.getJson("values").asJsonList())
				{
					List<Json> listRec = jsonRecord.asJsonList();
					for(int i = 0; i < listRec.size(); i ++)
					{
						if(i > 0)
							sbText.append(",");
						if(listRec.get(i).isNull())
							sbText.append("");
						else
							sbText.append(listRec.get(i).asString());						
					}
					sbText.append("\n");
				}
				sbText.append("\n");
				list.add(sbText.toString());
			}
		}

		
		return list.size() == 0 ? null : list.toArray(new String[list.size()]);
	}
	
	public void addAttachMessageToJson(Json jsonResult)
	{
		if(_listAttchFile != null)
		{
			SMTJsonWriter jsonWr = new SMTJsonWriter(true);
			for(AIAttachFile file : _listAttchFile)
			{
				jsonWr.beginMap(null);
				file.addToJson(jsonWr);
				jsonWr.endMap();
			}
			
			jsonResult.set("attach_files", jsonWr.getRootJson());
		}
		
		if(_jsonAttachTables != null)
		{
			jsonResult.set("attach_tables", _jsonAttachTables);
		}
		if(_jsonAttachMetrics != null)
		{
			jsonResult.set("attach_metrics", _jsonAttachMetrics);
		}
	}
	
	public void addAttachFile(AIAttachFile attachFile)
	{
		if(_listAttchFile == null)
			_listAttchFile = new ArrayList<>();
		
		_listAttchFile.add(attachFile);
	}
	
	public void setDisableConclusion(boolean set)
	{
		_disableConclusion = set;
	}
	
	public boolean isDisableConclusion()
	{
		return _disableConclusion;
	}
	
	public SMTJsonWriter finishResultJsonWr()
	{
		SMTJsonWriter jsonWrResult = _jsonWrResult;
		_jsonWrResult = null;
		
		if(jsonWrResult == null || jsonWrResult.getRootJson().asJsonMap().size() == 0)
		{
			_listChatExecProcess = null;
			_mapId2CallFuncJson = null;
			return null;
		}
		
		if(_listJsonWrResult == null)
			_listJsonWrResult = new ArrayList<>();
		
		// "exec_process"输出，并清空
		if(_listChatExecProcess != null)
		{
			Object[] array = new Object[_listChatExecProcess.size()];
			for(int i = 0; i < _listChatExecProcess.size(); i ++)
			{
				array[i] = _listChatExecProcess.get(i);
			}
			
			jsonWrResult.addKeyRaw("exec_process", Json.array(array));
			_listChatExecProcess = null;
		}
		
		// call_func不在此处
		if(_mapId2CallFuncJson != null)
		{
			jsonWrResult.beginMap("call_func");
			for(Entry<String, Json> entry : _mapId2CallFuncJson.entrySet())
			{
				jsonWrResult.addKeyRaw(entry.getKey(), entry.getValue());
			}
			jsonWrResult.endMap();
			
			_mapId2CallFuncJson = null;
		}
		
		_listJsonWrResult.add(jsonWrResult);
		
		return jsonWrResult;
	}
	
	public List<SMTJsonWriter>	getResultJsonWrList()
	{
		return _listJsonWrResult;
	}
	
	public SMTJsonWriter getResultJsonWr()
	{
		if(_jsonWrResult == null)
			_jsonWrResult = new SMTJsonWriter(false);
		
		return _jsonWrResult;
	}
	
	public void clearChatStreamReplyValue() throws Exception
	{
		SMTAIServerApp.getApp().clearChatStreamReply(this.getSessionId());		
	}
	
	public void setChatStreamReplyValue(String replyId, Json jsonReply) throws Exception
	{
		SMTAIServerApp.getApp().setChatStreamReply(this.getSessionId(), replyId, jsonReply);
	}
	
	public Json getChatStreamReplyValue(String replyId) throws Exception
	{
		Json jsonReply = SMTAIServerApp.getApp().getChatStreamReply(this.getSessionId(), replyId);
		return jsonReply;
	}
	
	public void timeBucketTable(String tableName, String timeField, String aggSQL, String aggField, int stepUnit, int stepValue) throws Exception
	{
		SMTDatabase dbResult = this.getResultDB();
		
		String oldTableName = "d_" + SMTStatic.newUUID();
		String newTableName = tableName; 
		dbResult.executeSQL("ALTER TABLE " + tableName + " RENAME TO " + oldTableName, null);
		
		String sql = 
			  " SELECT _BUCKET_OTIME_ AS " + timeField + ", " + aggField + " FROM ("
			+ " SELECT time_bucket(INTERVAL '" + SMTStatic.toString(stepValue) + " " + (stepUnit == 0 ? "minute" : "month") + "'," + timeField + ") AS _BUCKET_OTIME_, "
		    + aggSQL + " AS " + aggField
			+ " FROM " + oldTableName 
			+ " GROUP BY _BUCKET_OTIME_"
			+ " ) T"
			+ " ORDER BY OTIME"
			;
		
		DuckDBAppender[] appender = new DuckDBAppender[1];
		try
		{
			_logger.info("timeBucketTable SQL:\n" + sql);
			dbResult.querySQLNotify(sql, null, new SMTDatabase.DBQueryNotifyMeta()
			{
				@Override
				public boolean onMetaInfo(DBRecords metaInfo, String[] colTypes) throws Exception
				{
					SMTDatabase dbResult = createResultTable(newTableName, metaInfo, colTypes);
					appender[0] = ((DuckDBConnection)dbResult.getConnection()).createAppender(DuckDBConnection.DEFAULT_SCHEMA, newTableName);
					
					return true;
				}
				
				@Override
				public boolean onNextRecord(DBRecord rec) throws Exception 
				{
					Object[] values = rec.getValues();
					appender[0].beginRow();
					for(Object value : values)
					{
						if(value == null)
							appender[0].append(null);
						else
							appender[0].append(SMTStatic.toString(value));
					}
					appender[0].endRow();
					return true;
				}
			});
		}
		finally
		{
			if(appender[0] != null)
			{
				appender[0].close();
				appender[0] = null;
			}
		}
		dbResult.executeSQL("DROP TABLE " + oldTableName, null);
	}
	
	public SMTDatabase createResultTable(String tableName, DBRecords metaInfo, String[] sColTypes) throws Exception
	{
		// 生成创建结果表的SQL，并创建结果表
		StringBuilder sbFields = new StringBuilder();
		for(Entry<String, Integer> entry : metaInfo.getFieldMap().entrySet())
		{
			if(sbFields.length() > 0)
				sbFields.append(",");
			sbFields.append(entry.getKey() + " " + sColTypes[entry.getValue()]);
		}
		
		SMTDatabase dbResult = this.getResultDB();
		dbResult.executeSQL("CREATE TABLE " + tableName + "(" + sbFields.toString() + ")", null);
		
		return dbResult;
	}
	
	public SMTDatabase	getResultDB() throws Exception
	{
		if(_dbDuckResult == null)
		{
			String fileName = System.getProperty("result_duckdb", "");
			if(!SMTStatic.isNullOrEmpty(fileName))
			{
				File file = new File(fileName);
				file.delete();
			}
			Connection conn = DriverManager.getConnection("jdbc:duckdb:" + fileName);
			_dbDuckResult = new SMTDatabase(conn);
		}
		return _dbDuckResult;
	}
	
	public void closeQuestionResource() throws Exception
	{
		this.clearChatStreamReplyValue();

		if(_dbDuckResult != null)
		{
			_dbDuckResult.close();
			_dbDuckResult = null;
		}
	}
	
	public void setCurQuestionPos(double[] pos) throws Exception
	{
		if(pos != null)
			_curQuestionPos = SMTAIServerApp.getApp().convGisToMapTransform(pos);
		else
			_curQuestionPos = null;
	}
	
	public double[] getCurQuestionPos()
	{
		return _curQuestionPos;
	}
	
	public int getContentSampleQuestionCount()
	{
		return _contentSampleQuestion == null ? 0 : _contentSampleQuestion.size();
	}
	
	public void setCurGroupType(String groupType)
	{
		_curGroupType = groupType;
	}
	
	public String getCurGroupType()
	{
		return _curGroupType;
	}
	
	
	public void setAgentGroupSet(Set<String> setAgentGroup) throws Exception
	{
		setSessionAttribute("login_agent_group", setAgentGroup);
	}
	
	@SuppressWarnings("unchecked")
	public Set<String> getAgentGroupSet() throws Exception
	{
		Set<String> setResult = (Set<String>) this.getSessionAttribute("login_agent_group");
		if(setResult == null)
			return new HashSet<>();
		
		return setResult;
	}
	
	public void addContentSampleQuestion(String question)
	{
		if(_contentSampleQuestion == null)
			_contentSampleQuestion = new ArrayList<>();
		
		_contentSampleQuestion.add(question);
	}
	
	public void limitContentSampleQuestion(int limit)
	{
		while(_contentSampleQuestion.size() > limit)
			_contentSampleQuestion.remove(_contentSampleQuestion.size() - 1);

	}
	
	public List<String> getContentSampleQuestion()
	{
		return _contentSampleQuestion;
	}
	
	public void setChatOrderDimName(String dimName, String orderDir)
	{
		_chatOrderDimName = new String[] {dimName.toLowerCase(), orderDir.toUpperCase()};
	}
	
	public String[] getChatOrderDimName()
	{
		return _chatOrderDimName;
	}
	
	public List<Json> getChatExecProcessList()
	{
		return _listChatExecProcess;
	}
	
	public void setChunkedMode(boolean set)
	{
		_isChunked = set;
	}
	
	public Json sendReplyChunkedBlock(String replyId, Json jsonAsk) throws Exception
	{
		if(!_isChunked)
			return null;
		
		sendChunkedBlock("question", jsonAsk);
		this.setChatStreamReplyValue(replyId, Json.object());
		
		while(true)
		{
			Json jsonReply = this.getChatStreamReplyValue(replyId);
			if(jsonReply == null)
				return null;
			if(jsonReply.safeGetBoolean("json_reply", false))
				return jsonReply;
			
			Thread.sleep(1000);
		}
	}
	
	public void sendChunkedResultBlock() throws Exception
	{
		SMTJsonWriter jsonWrResult = finishResultJsonWr();
		if(jsonWrResult != null)
		{
			sendChunkedBlock("result", jsonWrResult.getRootJson());
		}
	}
	
	public void sendChunkedStreamBlock(String stream) throws Exception
	{
		if(_sendStarStream)
		{
			if((System.currentTimeMillis() - _lastSendChunkedStreamBlockTick) < 2000)
				return;
			
			_lastSendChunkedStreamBlockTick = System.currentTimeMillis();
			
			stream = "#";
			if(stream.indexOf("\n") >= 0)
				stream += "\n";
		}
		sendChunkedBlock("send_stream", stream);
	}
	
	public void sendChunkedBlock(String mode, Object value) throws Exception
	{
		Json jsonResult;
		
		if(value == null)
		{
			jsonResult = Json.object("mode", mode, "type", "null");
		}
		else if(value instanceof String)
		{
			jsonResult = Json.object("mode", mode, "type", "string", "value", value);
		}
		else if(value instanceof Json)
		{
			jsonResult = Json.object("mode", mode, "type", "json", "value", value);
		}
		else if(value instanceof SMTJsonWriter)
		{
			jsonResult = Json.object("mode", mode, "type", "json", "value", ((SMTJsonWriter)value).getRootJson());
		}
		else
		{
			throw new Exception("unknow chunked value type : " + value.getClass().toString());
		}
	
		if(!"result".equals(mode))
		{
			if(_listChatExecProcess == null)
				_listChatExecProcess = new ArrayList<>();
			_listChatExecProcess.add(jsonResult);
		}
		
		if(!_isChunked)
		{
			_logger.info("NO sendChunkedBlock:" + jsonResult.toString());
		}
		else
		{
			_logger.info("sendChunkedBlock:" + jsonResult.toString());
			String text = URLEncoder.encode(jsonResult.toString(), "UTF-8").replace("+", "%20") + "\n";
		
			this.getResponse().getOutputStream().write(text.getBytes("UTF-8"));
			
	//		this.getResponse().getWriter().print(String.format(
	//			"%d\r\n%s\r\n", text.length(), text
	//			));
			this.getResponse().flushBuffer();
		}
	}
	
	public String getClientAddr()
	{
		return SMTStatic.getClientAddr(this.getRequest());
	}
	
	public void appendOperateLog(SMTDatabase db, String type, String note) throws Exception
	{
		db.executeSQL("INSERT INTO sys_operate_log(op_id, op_type, op_time, op_user, op_note, client_ip)VALUES(?,?,?,?,?,?)", new Object[] {
    			SMTStatic.newUUID(),
    			type,
    			new Date(),
    			this.getLoginUserId(),
    			note,
    			getClientAddr()
    		});
	}
	
	public boolean isAgentCheckMode()
	{
		return _isAgentCheckMode;
	}
	
	public void setAgentCheckMode(boolean set)
	{
		_isAgentCheckMode = set;
	}
	
	public void appendCallFuncJson(String key, Json jsonCallFunc)
	{
		if(_mapId2CallFuncJson == null)
			_mapId2CallFuncJson = new LinkedHashMap<>();
		_mapId2CallFuncJson.put(key, jsonCallFunc);
	}
	
	public void appendSupervisorJson(List<Json> jsonSupervisorList)
	{
		_listSupervisorJson = jsonSupervisorList;
	}
	
	public List<Json> getSupervisorJsonList()
	{
		return _listSupervisorJson;
	}
	
	public Map<String, Json> getCallFuncJsonMap()
	{
		return _mapId2CallFuncJson;
	}
	
	public String getChatHistoryId()
	{
		if(_chatHistoryId == null)
			_chatHistoryId = SMTStatic.newUUID();
		return _chatHistoryId;
	}
	
	public SMTJsonWriter prepareAsyncQueryJson()
	{
		if(_jsonWrAsyncQueryJson == null)
			_jsonWrAsyncQueryJson = new SMTJsonWriter(false);
		
		return _jsonWrAsyncQueryJson;
	}
	
	public SMTJsonWriter getAsyncQueryJson()
	{
		if(_jsonWrAsyncQueryJson == null)
			return null;
		return _jsonWrAsyncQueryJson;
	}
	
	public SMTJsonWriter prepareExtCallJsonWriter()
	{
		if(_jsonWrExtCallJson == null)
			_jsonWrExtCallJson = new SMTJsonWriter(true);
		
		return _jsonWrExtCallJson;
	}
	
	public Json getExtCallJsonWriter()
	{
		if(_jsonWrExtCallJson == null)
			return null;
		Json json = _jsonWrExtCallJson.getRootJson();
		if(json.asJsonList().size() == 0)
			return null;
		
		return json;
	}
	
	public SMTJsonWriter prepareParamJsonWriter()
	{
		if(_jsonWrParamJson == null)
			_jsonWrParamJson = new SMTJsonWriter(false);
		
		return _jsonWrParamJson;
	}
	
	public Json getParamJson()
	{
		if(_jsonWrParamJson == null)
			return null;
		
		Json json = _jsonWrParamJson.getRootJson();
		if(json.asJsonMap().size() == 0)
			return null;
		
		return json;
	}
	
	public void setRawQuestion(String rawQuestion)
	{
		_rawQuestion = rawQuestion;
	}
	
	public void setAIQuestion(String aiQuestion)
	{
		_aiQuestion = aiQuestion;
	}
	
	public String getAIQuestion()
	{
		return _aiQuestion;
	}
	
	public String getRawQuestion()
	{
		return _rawQuestion;
	}

	
	public void clearSession() throws Exception
	{
		this.getSession().removeAttribute(_requestUserIdKey);
	}
	
	public void setAsynProcessId(String processId)
	{
		_asyncProcessId = processId;
	}
	
	public void removeAsynProcessId() throws Exception
	{
		if(_asyncProcessId == null)
			return;
		SMTAIServerApp.getApp().removeAsyncProcessText(this.getSessionId(), _asyncProcessId);
	}
	
	public void setAsynProcessText(String text) throws Exception
	{
		if(_asyncProcessId == null)
			return;
		
		SMTAIServerApp.getApp().setAsyncProcessText(this.getSessionId(), _asyncProcessId, text);
	}
	
	public String getTraceLLMDebug()
	{
		if(_sbTraceQuestion == null)
			return null;
		
		return _sbTraceQuestion.toString();
	}
	
	public void traceLLMDebug(String trace)
	{
		if(_sbTraceQuestion == null)
			_sbTraceQuestion = new StringBuilder();
		_sbTraceQuestion.append(SMTStatic.toString(new Date()) + " - " + trace + "\n");
		
		if(SMTQwenApp.getApp().isTraceLLM())
			_logger.info(trace);
	}
	
	public void traceLLMPrompt(String trace)
	{
		_logger.info("大模型提示词:\n[=======================\n" + trace + "\n=======================]\n");
	}
}