package com.smtaiserver.smtaiserver.control;

import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.tree.DefaultText;
import org.springframework.web.servlet.ModelAndView;

import com.smtaiserver.smtaiserver.core.SMTAIServerApp;
import com.smtaiserver.smtaiserver.core.SMTAIServerRequest;
import com.smtaiserver.smtaiserver.core.SMTCheckChatStreamView;
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.agent.SMTQwenAgent;
import com.smtservlet.util.Json;
import com.smtservlet.util.SMTJsonWriter;
import com.smtservlet.util.SMTStatic;

public class SMTSupervisorManagerControl 
{
	public ModelAndView getDataSourceList(SMTAIServerRequest tranReq) throws Exception 
	{
		SMTDatabase db = SMTAIServerApp.getApp().allocDatabase();
		try
		{
			DBRecords recs = db.querySQL("SELECT ds_id, ds_title, ds_config, ds_type FROM " + SMTAIServerApp.getApp().getTableDataSource() + " ORDER BY ds_id", null);
			SMTJsonWriter jsonWr = tranReq.newReturnJsonWriter(true, null, null);
			jsonWr.beginArray("values");
			for(DBRecord rec : recs.getRecords())
			{
				jsonWr.beginMap(null);
				{
					jsonWr.addKeyValue("id", rec.getString("ds_id"));
					jsonWr.addKeyValue("title", rec.getString("ds_title"));
					jsonWr.addKeyValue("db_type", rec.getString("ds_type"));
					jsonWr.addKeyValue("type", "JDBC");
					
					Json jsonConfig = Json.read(rec.getString("ds_config"));
					jsonConfig.delAt("pass");
					jsonWr.addKeyRaw("config", jsonConfig);
				}
				jsonWr.endMap();
			}
			jsonWr.endArray();
			
			return tranReq.returnJson(jsonWr);
		}
		finally
		{
			db.close();
		}			
	}
	
	public ModelAndView getAmisDatabaseList(SMTAIServerRequest tranReq) throws Exception 
	{
		SMTDatabase db = SMTAIServerApp.getApp().allocDatabase();
		try
		{
			DBRecords recs = db.querySQL("SELECT ds_id, ds_title FROM " + SMTAIServerApp.getApp().getTableDataSource() + " ORDER BY ds_id", null);
			SMTJsonWriter jsonWr = tranReq.newReturnJsonWriter(true, null, null);
			jsonWr.beginArray("values");
			for(DBRecord rec : recs.getRecords())
			{
				jsonWr.beginMap(null);
				{
					jsonWr.addKeyValue("id", rec.getString("ds_id"));
					jsonWr.addKeyValue("title", rec.getString("ds_title"));
				}
				jsonWr.endMap();
			}
			jsonWr.endArray();
			
			return tranReq.returnJson(jsonWr);
		}
		finally
		{
			db.close();
		}		
	}
	
	public ModelAndView checkAmisSupervisorValidate(SMTAIServerRequest tranReq) throws Exception 
	{
		String agentId = tranReq.convParamToString("id", true);
		String question= tranReq.convParamToString("question", true);
		
		DBRecords recs;
		SMTDatabase db = SMTAIServerApp.getApp().allocDatabase();
		try
		{
			recs = db.querySQL("SELECT * FROM " + "ai_agent_amis" + " WHERE agent_id=?", new Object[] {
				agentId
			});
			if(recs.getRowCount() == 0)
				return tranReq.returnJsonState(false, "未发现记录", null);		
		}
		finally
		{
			db.close();
		}		
		
		DBRecord rec = recs.getRecord(0);
		SMTQwenAgent agent = (SMTQwenAgent) Class.forName(rec.getString("clz_name")).newInstance();
		agent.initInstance(rec);
		Map<String, SMTQwenAgent> mapId2Agent = new HashMap<>();
		mapId2Agent.put(agent.getAgentId(), agent);
		
		return new ModelAndView(new SMTCheckChatStreamView(tranReq, question, mapId2Agent));
	}
	
	public ModelAndView updateAmisSupervisorPublish(SMTAIServerRequest tranReq) throws Exception 
	{
		String agentId = tranReq.convParamToString("id", true);
		String publish = tranReq.convParamToString("publish", true);
		
		SMTDatabase db = SMTAIServerApp.getApp().allocDatabase();
		try
		{
			DBRecords recs = db.querySQL("SELECT clz_arguments, agent_order FROM ai_agent_amis WHERE agent_id=?", new Object[] {
					agentId
				});
			if(recs.getRowCount() == 0)
				return tranReq.returnJsonState(false, "未发现记录", null);
			
			String curPublish = (recs.getRecord(0).getInteger("agent_order") > 0) ? "Y" : "N";
			SMTJsonWriter jsonWr = tranReq.newReturnJsonWriter(true, null, null);
			
			// 如果进入发布状态，则检查合法性
			if("Y".equals(publish))
			{
				String sClzArguments = recs.getRecord(0).getString("clz_arguments");
				if(SMTStatic.isNullOrEmpty(sClzArguments))
				{
					jsonWr.addKeyValue("fail_msg", "低代码页面未初始化");
					publish = "N";
				}
				
				Document doc;
				
				try
				{
					doc = SMTStatic.convStrToXmlDoc("<ROOT>" + sClzArguments + "</ROOT>");
					if(doc.selectSingleNode("ROOT/AMIS_JSON") == null)
					{
						jsonWr.addKeyValue("fail_msg", "低代码页面未配置");
						publish = "N";
					}
				}
				catch(Exception ex)
				{
					jsonWr.addKeyValue("fail_msg", ex.getMessage());
					publish = "N";
				}
			}
			
			db.executeSQL("UPDATE ai_agent_amis SET agent_order=? WHERE agent_id=?", new Object[] {
				"Y".equals(publish)	? 1 : 0,
			    agentId
			});
			jsonWr.addKeyValue("publish", publish);
			
			if(!curPublish.equals(publish))
				SMTAIServerApp.getApp().clearQwenAgentManager();
			
			return tranReq.returnJson(jsonWr);
		}
		finally
		{
			db.close();
		}
	}
	
	public ModelAndView updateAmisSupervisorSql(SMTAIServerRequest tranReq) throws Exception 
	{
		String agentId  	= tranReq.convParamToString("id", true);
		Json   jsonArgs 	= tranReq.convParamToJson("args", false);
		Json   jsonMatches 	= tranReq.convParamToJson("matches", false);
		Json   jsonDefRsList 	= tranReq.convParamToJson("def_rs_json", false);
		Json   jsonAsyncRsList 	= tranReq.convParamToJson("async_rs_json", false);
		

		
		SMTDatabase db = SMTAIServerApp.getApp().allocDatabase();
		try
		{
			DBRecords recs = db.querySQL("SELECT clz_arguments, agent_xml FROM " + "ai_agent_amis" + " WHERE agent_id=?", new Object[] {
				agentId
			});
			if(recs.getRowCount() == 0)
				return tranReq.returnJsonState(false, "未发现记录", null);
			
			// 解析agent_xml
			String agentXmlStr;
			{
				String sAgentXml = recs.getRecord(0).getString("agent_xml");
				Document doc = SMTStatic.convStrToXmlDoc("<ROOT>" + sAgentXml + "</ROOT>");
				Element xmlRoot = (Element) doc.selectSingleNode("ROOT");
				Element xmlArgs = SMTStatic.getOrCreateXmlNode(xmlRoot, "ARGS");
				xmlArgs.clearContent();
				if(jsonArgs != null)
				{
					for(Json jsonArg : jsonArgs.asJsonList())
					{
						boolean required = jsonArg.safeGetBoolean("required", false);

						
						String argType = jsonArg.safeGetStr("type", "S");
						char cArgType = argType.charAt(0);
						if(cArgType != 'S' && cArgType != 'D' && cArgType != 'T' && cArgType != 'I')
							throw new Exception("arg type error : " + argType);
						
						Element xmlArg = xmlArgs.addElement("ARG");
						xmlArg.addAttribute("name", jsonArg.getJson("name").asString());
						xmlArg.addAttribute("check", jsonArg.safeGetStr("check", ""));
						xmlArg.addAttribute("required", required ? "true" : "false");
						xmlArg.addAttribute("type", argType);
						xmlArg.setText(jsonArg.getJson("prompt").asString());
					}
				}
				
				if(jsonMatches != null)
				{
					Element xmlMatches = SMTStatic.getOrCreateXmlNode(xmlRoot, "MATCHES");
					xmlMatches.clearContent();
					for(Json jsonMatch : jsonMatches.asJsonList())
					{
						Element xmlRegex = xmlMatches.addElement("REGEX");
						xmlRegex.setText(jsonMatch.asString());
					}
				}
				
				agentXmlStr = SMTAIServerApp.formatXmlToNoRootStr(doc);
			}
			
			
			
			// 解析clz_arguments
			String clzArgumentXmlStr;
			{
				String sXmlArguments = recs.getRecord(0).getString("clz_arguments");
				if(SMTStatic.isNullOrEmpty(sXmlArguments))
					sXmlArguments = "";
				
				Document doc = SMTStatic.convStrToXmlDoc("<ROOT>" + sXmlArguments + "</ROOT>");
				Element xmlRoot = (Element) doc.selectSingleNode("ROOT");
				
				// 创建RECORD记录集
				Element xmlRecs = SMTStatic.getOrCreateXmlNode(xmlRoot, "RECORDS");
				xmlRecs.clearContent();
				
				Map<String, String> mapId2SQL = new HashMap<>();
				
				if(jsonDefRsList != null)
				{
					for(Json jsonDefRs : jsonDefRsList.asJsonList())
					{
						String rsType = jsonDefRs.safeGetStr("type", "SQL");
						String rsId = jsonDefRs.getJson("id").asString();
						if("SQL".equals(rsType))
						{
							Element xmlSQL = xmlRecs.addElement(rsType);
							xmlSQL.addAttribute("id", rsId);
							xmlSQL.addAttribute("type", rsType);
							xmlSQL.addAttribute("database", jsonDefRs.getJson("database").asString());
							String sql = SMTStatic.convStringToHtmlBody(jsonDefRs.getJson("sql").asString()).replace("${", "<").replace("}$", ">");
							String sqlId = SMTStatic.newUUID();
							mapId2SQL.put(sqlId, sql);
							xmlSQL.setText(sqlId);
						}
						else
						{
							throw new Exception("unknow recordset type : " + rsType);
						}
	
					}
				}
				
				// 创建REF_RECS记录集
				Element xmlAsyncRecs = SMTStatic.getOrCreateXmlNode(xmlRoot, "AMIS_ASYNCS");
				xmlAsyncRecs.clearContent();
				if(jsonAsyncRsList != null)
				{
					for(Json jsonAsyncRs : jsonAsyncRsList.asJsonList())
					{
						Element xmlAsyncRec = xmlAsyncRecs.addElement("AMIS_ASYNC");
						xmlAsyncRec.addAttribute("rec_id", jsonAsyncRs.getJson("rec_id").asString());
						xmlAsyncRec.addAttribute("async_id", jsonAsyncRs.getJson("async_id").asString());
						xmlAsyncRec.addAttribute("amis_path", jsonAsyncRs.getJson("amis_path").asString());
					}
				}
			
				clzArgumentXmlStr = SMTAIServerApp.formatXmlToNoRootStr(doc);
				
				for(Entry<String, String> entry : mapId2SQL.entrySet())
				{
					clzArgumentXmlStr = clzArgumentXmlStr.replace(entry.getKey(), entry.getValue());
				}
				
				// 判断xml格式是否合法
				SMTStatic.convStrToXmlDoc("<ROOT>" + clzArgumentXmlStr + "</ROOT>"); 
			}
			
			db.executeSQL("UPDATE " +  "ai_agent_amis" + " SET clz_arguments=?, agent_xml=?, agent_order=0, update_time=? WHERE agent_id=?", new Object[] {
					clzArgumentXmlStr,
					agentXmlStr,
					new Date(),
					agentId
				});
				
			SMTJsonWriter jsonWr = tranReq.newReturnJsonWriter(true, null, null);
			jsonWr.addKeyValue("publish", "N");
			
			return tranReq.returnJsonState(true, null, null);
		}
		finally
		{
			db.close();
		}		

	}
	
	public ModelAndView updateAmisSupervisorJson(SMTAIServerRequest tranReq) throws Exception 
	{
		String agentId  = tranReq.convParamToString("id", true);
		String amisJson = tranReq.convParamToString("amis_json", true);
	
		// 检测json是否合法
		Json.read(amisJson);

		SMTDatabase db = SMTAIServerApp.getApp().allocDatabase();
		try
		{
			DBRecords recs = db.querySQL("SELECT clz_arguments FROM " + "ai_agent_amis" + " WHERE agent_id=?", new Object[] {
				agentId
			});
			if(recs.getRowCount() == 0)
				return tranReq.returnJsonState(false, "未发现记录", null);
	
			String sXmlArguments = recs.getRecord(0).getString("clz_arguments");
			if(SMTStatic.isNullOrEmpty(sXmlArguments))
				sXmlArguments = "";
			
			Document doc = SMTStatic.convStrToXmlDoc("<ROOT>" + sXmlArguments + "</ROOT>");
			Element xmlRoot = (Element) doc.selectSingleNode("ROOT");
			
			// 创建AMIS_JSON记录集
			Element xmlAmisJson = SMTStatic.getOrCreateXmlNode(xmlRoot, "AMIS_JSON");
			xmlAmisJson.setText(amisJson);
			String xmlAmisJsonStr = SMTAIServerApp.formatXmlToNoRootStr(doc);
			
			db.executeSQL("UPDATE " +  "ai_agent_amis" + " SET clz_arguments=?, agent_order=0, update_time=? WHERE agent_id=?", new Object[] {
				xmlAmisJsonStr,
				new Date(),
				agentId
			});
			
			SMTJsonWriter jsonWr = tranReq.newReturnJsonWriter(true, null, null);
			jsonWr.addKeyValue("publish", "N");
			
			return tranReq.returnJsonState(true, null, null);
		}
		finally
		{
			db.close();
		}
	}
	
	private String convSQLXMLToString(Element xmlSQL)
	{
		StringBuilder sbXml = new StringBuilder();
		for (Iterator<Node> iterInner = xmlSQL.nodeIterator(); iterInner.hasNext();)
		{
			Node nodeInner = iterInner.next();
			if(nodeInner.getNodeType() == Node.TEXT_NODE)
			{
				sbXml.append(((DefaultText)nodeInner).getText());
			}
			else
			{
				String strXml = SMTStatic.convHtmlBodyToString(nodeInner.asXML().replace("<", "${").replace(">", "}$"));
				sbXml.append(strXml);
			}
		}
		
		return sbXml.toString();
	}
	
	public ModelAndView getAmisSupervisorXml(SMTAIServerRequest tranReq) throws Exception 
	{
		String agentId = tranReq.convParamToString("id", true);
		SMTDatabase db = SMTAIServerApp.getApp().allocDatabase();
		try
		{
			DBRecords recs = db.querySQL("SELECT clz_arguments, agent_xml FROM " + "ai_agent_amis" + " WHERE agent_id=?", new Object[] {
				agentId
			});
			if(recs.getRowCount() == 0)
				return tranReq.returnJsonState(false, "未发现记录", null);
			
			SMTJsonWriter jsonWr = tranReq.newReturnJsonWriter(true, null, null);
			
			{
				Document doc = SMTStatic.convStrToXmlDoc("<ROOT>" + recs.getRecord(0).getString("agent_xml") + "</ROOT>");
	
				jsonWr.beginArray("args");
				for(Node nodeArg : doc.selectNodes("ROOT/ARGS/ARG"))
				{
					Element xmlArg = (Element)nodeArg;
					jsonWr.beginMap(null);
					{
						jsonWr.addKeyValue("name", SMTStatic.getXmlAttr(xmlArg, "name"));
						jsonWr.addKeyValue("prompt", SMTStatic.trimStrLines(xmlArg.getText()));
						jsonWr.addKeyValue("check", SMTStatic.getXmlAttr(xmlArg, "check", ""));
						jsonWr.addKeyValue("required", "true".equals(SMTStatic.getXmlAttr(xmlArg, "required", "false")));
						jsonWr.addKeyValue("type", SMTStatic.getXmlAttr(xmlArg, "type", "S"));
					}
					jsonWr.endMap();
				}
				jsonWr.endArray();
				
				jsonWr.beginArray("matches");
				for(Node nodeMatch : doc.selectNodes("ROOT/MATCHES/REGEX"))
				{
					Element xmlMatch = (Element)nodeMatch;
					jsonWr.addKeyValue(null, xmlMatch.getText());
				}
				jsonWr.endArray();
			}
			
			String sxml = recs.getRecord(0).getString("clz_arguments");
			if(!SMTStatic.isNullOrEmpty(sxml))
			{
				Document doc = SMTStatic.convStrToXmlDoc("<ROOT>" + sxml + "</ROOT>");

				jsonWr.beginArray("def_rs_json");
				for(Node nodeSQL : doc.selectNodes("ROOT/RECORDS/SQL"))
				{
					Element xmlSQL = (Element)nodeSQL;
					jsonWr.beginMap(null);
					{
						jsonWr.addKeyValue("id", SMTStatic.getXmlAttr(xmlSQL, "id"));
						jsonWr.addKeyValue("database", SMTStatic.getXmlAttr(xmlSQL, "database"));
						jsonWr.addKeyValue("type", SMTStatic.getXmlAttr(xmlSQL, "type", "SQL"));
						jsonWr.addKeyValue("sql", convSQLXMLToString(xmlSQL));
					}
					jsonWr.endMap();
				}
				jsonWr.endArray();
				
				jsonWr.beginArray("async_rs");
				for(Node nodeSQL : doc.selectNodes("ROOT/AMIS_ASYNCS/AMIS_ASYNC"))
				{
					Element xmlSQL = (Element)nodeSQL;
					jsonWr.beginMap(null);
					{
						jsonWr.addKeyValue("rec_id", SMTStatic.getXmlAttr(xmlSQL, "rec_id"));
						jsonWr.addKeyValue("async_id", SMTStatic.getXmlAttr(xmlSQL, "async_id"));
						jsonWr.addKeyValue("amis_path", SMTStatic.getXmlAttr(xmlSQL, "amis_path"));
					}
					jsonWr.endMap();
				}
				jsonWr.endArray();
				
				Node nodeAmis = doc.selectSingleNode("ROOT/AMIS_JSON");
				if(nodeAmis != null)
				{
					jsonWr.addKeyRaw("amis_json", ((Element)nodeAmis).getText());
				}

			}
			
			return tranReq.returnJson(jsonWr);
		}
		finally
		{
			db.close();
		}

	}
	
	public ModelAndView deleteAmisSupervisorInfo(SMTAIServerRequest tranReq) throws Exception 
	{
		String id = tranReq.convParamToString("id", true);
		SMTDatabase db = SMTAIServerApp.getApp().allocDatabase();
		try
		{
			db.executeSQL("DELETE FROM " + "ai_agent_amis" + " WHERE agent_id=?", new Object[] {id});
			
			return tranReq.returnJsonState(true, null, null);
		}
		finally
		{
			db.close();
		}	
	}
	
	public ModelAndView addAmisSupervisorInfo(SMTAIServerRequest tranReq) throws Exception 
	{
		String title = tranReq.convParamToString("title", true);
		String prompt = tranReq.convParamToString("prompt", true);
		String note = tranReq.convParamToString("note", false);
		String groupId = tranReq.convParamToString("group", true);
		String question = tranReq.convParamToString("question", false);
		
		StringBuilder sbXML = new StringBuilder();
		sbXML.append("<TITLE>" + prompt.replace("\"",  "&quot;") + "</TITLE>\n");
		
		SMTDatabase db = SMTAIServerApp.getApp().allocDatabase();
		try
		{
			String agentId = "agent_" + SMTStatic.newUUID();
			
			db.executeSQL(
				  " INSERT INTO " + "ai_agent_amis" 
				+ " (agent_id,agent_type,agent_xml,clz_name,agent_order,agent_title,agent_note,create_user,create_time,update_time,agent_group,check_question)VALUES"
				+ " (?,?,?,?,?,?,?,?,?,?,?,?)"
				, new Object[] {
				  agentId,
				  "summary",
				  sbXML.toString(),
				  "com.smtaiserver.smtaiserver.javaai.qwen.agent.SMTQwenAgentSummaryAMIS",
				  0,
				  title,
				  note,
				  tranReq.getLoginUserId(),
				  new Date(),
				  new Date(),
				  groupId,
				  question
				});
			
			SMTJsonWriter jsonWr = tranReq.newReturnJsonWriter(true, null, null);
			jsonWr.addKeyValue("agent_id", agentId);
			return tranReq.returnJson(jsonWr);
		}
		finally
		{
			db.close();
		}		

	}
	
	public ModelAndView updateAmisSupervisorInfo(SMTAIServerRequest tranReq) throws Exception 
	{
		String id = tranReq.convParamToString("id", true);
		String title = tranReq.convParamToString("title", true);
		String prompt = tranReq.convParamToString("prompt", true);
		String note = tranReq.convParamToString("note", false);
		String question = tranReq.convParamToString("question", false); 
		
		SMTDatabase db = SMTAIServerApp.getApp().allocDatabase();
		try
		{
			DBRecords recs = db.querySQL("SELECT agent_xml FROM " + "ai_agent_amis" + " WHERE agent_id=?", new Object[] {
				id	
			});
			if(recs.getRowCount() == 0)
				return tranReq.returnJsonState(false, "未发现id", null);
			
			Document doc = SMTStatic.convStrToXmlDoc("<ROOT>" + recs.getRecord(0).getString(0) + "</ROOT>");
			Element xmlTitle = (Element)doc.selectSingleNode("ROOT/TITLE");
			xmlTitle.setText(prompt);
			String xmlText = SMTAIServerApp.formatXmlToNoRootStr(doc);
			
			db.executeSQL(
				  " UPDATE " + "ai_agent_amis" 
				+ " SET agent_xml=?, agent_title=?, agent_note=?, update_time=?, check_question=?"
				+ " WHERE agent_id=?"
				, new Object[] {
					xmlText,
					title,
					note,
					new Date(),
					question,
					id
				});
		}
		finally
		{
			db.close();
		}		
		return tranReq.returnJsonState(true, null, null);
	}
	
	public ModelAndView getAmisSupervisorList(SMTAIServerRequest tranReq) throws Exception 
	{
		SMTDatabase db = SMTAIServerApp.getApp().allocDatabase();
		try
		{
			DBRecords recs = db.querySQL(
				  " SELECT A.*, U.user_name FROM" 
				+ " (SELECT agent_id, agent_xml, agent_order, create_user, create_time, update_time, agent_note, agent_title, agent_group,check_question FROM ai_agent_amis" 
				+ "  WHERE clz_name='com.smtaiserver.smtaiserver.javaai.qwen.agent.SMTQwenAgentSummaryAMIS')A"
				+ " LEFT JOIN sys_user_info U ON A.create_user=U.user_id"
				+ " ORDER BY A.agent_id"
				, null);
			SMTJsonWriter jsonWr = tranReq.newReturnJsonWriter(true, null, null);
			jsonWr.beginArray("values");
			for(DBRecord rec : recs.getRecords())
			{
				jsonWr.beginMap(null);
				parseSupervisorRec(rec, jsonWr);
				jsonWr.endMap();
			}
			jsonWr.endArray();
			
			return tranReq.returnJson(jsonWr);
		}
		finally
		{
			db.close();
		}
	}
	
	private void parseSupervisorRec(DBRecord rec, SMTJsonWriter jsonWr) throws Exception
	{
		Document doc = SMTStatic.convStrToXmlDoc("<ROOT>" + rec.getString("agent_xml") + "</ROOT>");
		String prompt = SMTStatic.trimStrLines(doc.selectSingleNode("ROOT/TITLE").getText());

		jsonWr.addKeyValue("id", rec.getString("agent_id"));
		jsonWr.addKeyValue("title", rec.getString("agent_title"));
		jsonWr.addKeyValue("prompt", prompt);
		jsonWr.addKeyValue("published", rec.getInteger("agent_order") > 0 ? "Y" : "N");
		jsonWr.addKeyValue("creator", rec.getString("user_name"));
		jsonWr.addKeyValue("create_time", rec.getString("create_time"));
		jsonWr.addKeyValue("update_time", rec.getString("update_time"));
		jsonWr.addKeyValue("note", rec.getString("agent_note"));
		jsonWr.addKeyValue("group_id", rec.getString("agent_group"));
		jsonWr.addKeyValue("question", rec.getString("check_question"));
	}
	
	public ModelAndView getSceneGroupTree(SMTAIServerRequest tranReq) throws Exception 
    {
    	SMTDatabase db = SMTAIServerApp.getApp().allocDatabase();
    	try
    	{
     		DBRecords recs = db.querySQL("SELECT group_id, group_name, p_group_id, group_title FROM ai_scene_group ORDER BY group_name", null);

    		SMTJsonWriter jsonWr = tranReq.newReturnJsonWriter(true, null, null);
    		jsonWr.beginArray("groups");
    		for(DBRecord rec : recs.getRecords())
    		{
    			jsonWr.beginMap(null);
    			{
    				jsonWr.addKeyValue("group_id", rec.getString("group_id"));
    				jsonWr.addKeyValue("group_name", rec.getString("group_name"));
    				jsonWr.addKeyValue("p_group_id", rec.getString("p_group_id"));
    				jsonWr.addKeyValue("group_title", rec.getString("group_title"));
    			}
    			jsonWr.endMap();
    		}
    		jsonWr.endArray();
    		
    		return tranReq.returnJson(jsonWr);
    	}
    	finally
    	{
    		db.close();
    	}   	
    }

	
	public ModelAndView updateSceneGroupInfo(SMTAIServerRequest tranReq) throws Exception 
	{
	   	String groupId = tranReq.convParamToString("group_id", true);
	   	String groupName = tranReq.convParamToString("group_name", true);
	   	String groupTitle = tranReq.convParamToString("group_title", true);
    	
    	SMTDatabase db = SMTAIServerApp.getApp().allocDatabase();
    	try
    	{
     		db.executeSQL("UPDATE ai_scene_group SET group_name=?, group_title=? WHERE group_id=?", new Object[] {
     			groupName,
     			groupTitle,
     			groupId
     		});

    		return tranReq.returnJsonState(true, null, null);
    	}
    	finally
    	{
    		db.close();
    	}   	
    }
	    

}