package service

import (
	"bytes"
	"context"
	"encoding/json"
	"html/template"
	"io"
	"net/url"
	"os"
	"regexp"
	"strconv"
	"strings"
	"time"

	"go-common/app/admin/ep/melloi/conf"
	"go-common/app/admin/ep/melloi/model"
	"go-common/library/ecode"
	"go-common/library/log"
)

//QueryScripts query scripts
func (s *Service) QueryScripts(script *model.Script, pn, ps int) (scripts []*model.Script, err error) {
	if ps <= 0 || pn <= 0 {
		ps = 10
		pn = 1
	}
	if scripts, err = s.dao.QueryScripts(script, pn, ps); err != nil {
		log.Error("s.dao.QueryScripts error :(%v)", err)
		return
	}
	for _, script := range scripts {
		if script.APIHeader != "" {
			if err = json.Unmarshal([]byte(script.APIHeader), &script.Headers); err != nil {
				log.Error("get script header err : (%v), scriptId:(%d)", err, script.ID)
			}
		}
		if script.ArgumentString != "" {
			if err = json.Unmarshal([]byte(script.ArgumentString), &script.ArgumentsMap); err != nil {
				log.Error("get script argument err: (%v), scriptId:(%d)", err, script.ID)
			}
		}
		if script.OutputParams != "" {
			if err = json.Unmarshal([]byte(script.OutputParams), &script.OutputParamsMap); err != nil {
				log.Error("get script OutputParams err: (%v), scriptId:(%d)", err, script.ID)
			}
		}
	}
	return
}

//CountQueryScripts count query scripts
func (s *Service) CountQueryScripts(script *model.Script) (total int) {
	return s.dao.CountQueryScripts(script)
}

//QueryScriptSnap query scriptSnap
func (s *Service) QueryScriptSnap(scriptSnap *model.ScriptSnap) (snaps []*model.ScriptSnap, err error) {
	return s.dao.QueryScriptSnap(scriptSnap)
}

//QueryScriptsByPage query script by page
func (s *Service) QueryScriptsByPage(c context.Context, sessionID string, qsrq *model.QueryScriptRequest) (rsp *model.QueryScriptResponse, err error) {
	// 获取服务树节点
	var (
		treeNodes  []string
		treeNodesd []string
	)
	if treeNodesd, err = s.QueryUserRoleNode(c, sessionID); err != nil {
		log.Error("QueryUserRoleNode err (%v):", err)
	}
	treeNodes = append(treeNodesd, "")
	if ExistsInSlice(qsrq.Executor, conf.Conf.Melloi.Executor) {
		//rsp, err = s.dao.QueryScriptsByPageWhiteName(&qsrq.Script, qsrq.PageNum, qsrq.PageSize)
		if rsp, err = s.dao.QueryScriptsByPageWhiteName(&qsrq.Script, qsrq.PageNum, qsrq.PageSize); err != nil {
			return
		}
	} else {
		if rsp, err = s.dao.QueryScriptsByPage(&qsrq.Script, qsrq.PageNum, qsrq.PageSize, treeNodes); err != nil {
			return
		}
	}

	for _, script := range rsp.Scripts {
		if script.APIHeader != "" {
			if err = json.Unmarshal([]byte(script.APIHeader), &script.Headers); err != nil {
				log.Error("get script header err : (%v), scriptId:(%d)", err, script.ID)
			}
		}
		if script.ArgumentString != "" {
			if err = json.Unmarshal([]byte(script.ArgumentString), &script.ArgumentsMap); err != nil {
				log.Error("get script argument err: (%v), scriptId:(%d)", err, script.ID)
			}
		}
		if script.OutputParams != "" {
			if err = json.Unmarshal([]byte(script.OutputParams), &script.OutputParamsMap); err != nil {
				log.Error("get script OutputParams err: (%v), scriptId:(%d)", err, script.ID)
			}
		}
	}

	// 获取label
	for _, script := range rsp.Scripts {
		lr := model.LabelRelation{Type: model.ScriptType, TargetID: int64(script.ID)}
		if script.Labels, err = s.dao.QueryLabelRelation(&lr); err != nil {
			return
		}
	}
	return
}

//AddAndExcuScript add script and excute it
func (s *Service) AddAndExcuScript(c context.Context, script *model.Script, cookie string, scene *model.Scene, fileWrite, convjson bool) (resp model.DoPtestResp, err error) {
	var (
		scriptID     int
		groupID      int
		runOrder     int
		testNameNick string
		message      string
		scriptd      model.Script
		paramList    *model.ParamList
		isEdit       = false
	)

	if message, scriptd, err = s.AddScript(script, fileWrite); err != nil {
		log.Error("sorry, addScript fail : (%v)", err)
		return
	}
	headerString := MapToString(scriptd.Headers)
	argumentString := MapToString(scriptd.ArgumentsMap)
	scriptd.ArgumentString = argumentString
	scriptd.APIHeader = headerString
	scriptd.OutputParams = MapToString(scriptd.OutputParamsMap)
	//场景压测中选择已有接口时，去修改默认的熔断成功率的值（新增接口时不修改）
	if scene.IsBatch {
		scriptd.Fusing = scene.Fusing
	}

	if convjson {
		scriptd.ArgumentString = script.ArgumentString
		scriptd.APIHeader = script.APIHeader
		scriptd.OutputParams = script.OutputParams
	}
	//场景压测独有的逻辑
	if scriptd.TestType == model.SCENE_SCRIPT_TYPE {
		//根据接口参数依赖，计算出接口分组与执行顺序
		if paramList, err = s.dao.QueryParams(&scriptd, scene); err != nil {
			log.Error("s.dao.QueryParams err :(%v)", err)
			return
		}
		scriptd.GroupID, scriptd.RunOrder = GroupOrder(isEdit, &scriptd, scene, paramList)
	}

	//非debug 执行的 循环次数为-1 即永久
	if scriptd.Loops == -1 {
		if len(script.OutputParamsMap) == 0 || script.OutputParams == "[]" {
			scriptd.OutputParams = "[{\"\":\"\"}]"
		}
		if scriptID, groupID, runOrder, err = s.dao.AddScript(&scriptd); err != nil {
			log.Error("s.dao.AddScript err : (%v)", err)
			message = "sql excute err"
			return
		}
	}

	//如果不是复制脚本操作 或者 不是保存，则执行jmeter压测
	if !script.IsCopy && !script.IsSave {
		tim := strconv.FormatInt(time.Now().Unix(), 10)
		testNameNick = scriptd.TestName + tim
		log.Info("开始调用压测job-------\n")
		ptestParam := model.DoPtestParam{
			UserName:            scriptd.UpdateBy,                // 用户名
			LoadTime:            scriptd.LoadTime,                //运行时间
			TestNames:           StringToSlice(scriptd.TestName), //接口名转数组
			FileName:            scriptd.SavePath,                // jmx文件
			ResJtl:              scriptd.ResJtl,                  // jtl 文件
			JmeterLog:           scriptd.JmeterLog,               // jmeterlog时间戳
			Department:          script.Department,
			Project:             script.Project,
			APP:                 script.App,
			ScriptID:            scriptID,
			IsDebug:             script.IsDebug, //false
			Cookie:              cookie,         // 用不到
			URL:                 scriptd.URL,    // 微信通知URL
			LabelIDs:            script.LabelIds,
			Domain:              scriptd.Domain,
			FileSplit:           script.FileSplit, // 文件切割
			SplitNum:            script.SplitNum,  // 切割数量
			Fusing:              script.Fusing,
			APIHeader:           scriptd.APIHeader,
			ExecuDockerSum:      script.ExecuDockerSum,
			UseBusinessStop:     script.UseBusinessStop,
			BusinessStopPercent: script.BusinessStopPercent,
		}
		if resp, err = s.DoPtestByJmeter(c, ptestParam, StringToSlice(testNameNick)); err != nil {
			log.Error("DoPtestByJmeter err :(%v)", err)
			message = "DoPtestByJmeter err "
			return
		}
		resp.Message = message
	}
	resp.ScriptID = scriptID
	resp.GroupID = groupID
	resp.RunOrder = runOrder
	return
}

//AddScript add script
func (s *Service) AddScript(script *model.Script, fileWrite bool) (message string, scriptd model.Script, err error) {
	var (
		buff           *template.Template
		file           *os.File
		scriptPath     string
		u              *url.URL
		sinfoJSON      []byte
		JSON           []byte
		JSONExtractors string
		dataFileName   string
		Assertionsd    []string
	)
	log.Info("threadsSum :(%d)", script.ThreadsSum)
	if script.LoadTime > s.c.Jmeter.TestTimeLimit {
		script.LoadTime = s.c.Jmeter.TestTimeLimit
	}
	//判断url
	if !strings.Contains(script.URL, "http://") && !strings.Contains(script.URL, "https://") {
		script.URL = "http://" + script.URL
	}
	if script.Delimiter == "" {
		script.Delimiter = ","
	}
	if u, err = url.Parse(script.URL); err != nil || u == nil {
		log.Error("sorry,url is not standard,error(%v)", err)
		err = ecode.MelloiUrlParseError
		return
	}
	if script.Data == "" {
		buff, err = template.ParseFiles(s.c.Jmeter.JmeterScUcodedTmp)
	} else {
		buff, err = template.ParseFiles(s.c.Jmeter.JmeterScTmp)
	}
	if err != nil {
		log.Error("open file failed! error %v", err)
		return
	}
	if script.Assertion != "" {
		script.UseAssertion = true
		Assertions := strings.Split(script.Assertion, "|")
		for _, assert := range Assertions {
			Assertionsd = append(Assertionsd, model.AssertionStart+assert+model.AssertionEnd)
		}
		script.AssertionString = unescaped(SliceToString(Assertionsd, " "))
	}
	if len(script.OutputParamsMap) > 0 && script.OutputParams != "[{\"\":\"\"}]" && script.OutputParams != "[]" && script.OutputParams != "" {
		if JSONExtractors, err = s.SetJSONExtractors(script); err != nil {
			return
		}
		if JSONExtractors != "" {
			script.JSONExtractor = unescaped(JSONExtractors)
		}
	}

	// POST 请求的 binary 逻辑
	if script.MultipartFile != "" && script.MultipartPath != "" {
		script.UseMultipart = true
		multiPartInfo := SetMultiPartInfo(script)
		script.MultiPartInfo = unescaped(multiPartInfo)
	}
	stringHeader := SetHeaders(script.Headers, script.ID)
	ArgmentStr := SetArguments(script.ArgumentsMap, script.ID)
	ArgmentString := unescaped(ArgmentStr)
	script.Arguments = ArgmentString
	stringHeaderd := unescaped(stringHeader)
	script.HeaderString = stringHeaderd
	script.ProcType = u.Scheme
	script.Domain = u.Hostname()
	script.Port = u.Port()
	if u.RawQuery == "" {
		script.Path = u.Path
		script.RowQuery = "appkey=" + conf.Conf.Melloi.AppkeyProd
	} else {
		script.Path = u.Path + "?" + u.RawQuery
		script.RowQuery = u.RawQuery + "&appkey=" + conf.Conf.Melloi.AppkeyProd
	}

	if script.UseSign {
		script.Path = u.Path + "?${params}"
	}
	dataFileName = script.FileName
	script.FileName = script.ScriptPath + script.FileName
	if script.ScriptPath != "" && script.FileName == "" && !script.Upload {
		message = "dataFile is not exists"
		log.Error(message)
		return
	}

	if script.Loops == 0 {
		script.Loops = -1
	}
	//极速模式（线程NIO模式）
	if script.IsAsync {
		script.AsyncInfo = unescaped(model.AsyncInfo)
	}
	//生成压测脚本
	if sinfoJSON, err = json.Marshal(script); err != nil {
		log.Error("script err (%v):", err)
		return
	}
	sc := string(sinfoJSON)
	log.Info("script :(%s)", sc)
	//判断是否使用内置参数
	if strings.Contains(sc, "${mid}") || strings.Contains(sc, "${access_key}") || script.UseSign {
		script.UseBuiltinParam = true
	}
	//fileWrite = true ,需要创建文件，为 false ，不需要创建文件
	if fileWrite {
		//创建脚本保存路径
		if script.ScriptPath == "" {
			if scriptPath, err = s.uniqueFolderPath(script.SavePath); err != nil {
				return
			}
		} else {
			scriptPath = script.ScriptPath
		}
		SavePath := scriptPath + script.TestName + "/"
		log.Info("SavePath****:  " + SavePath)
		if err = os.MkdirAll(SavePath, 0755); err != nil {
			log.Error("Create SavePath Err :(%v)", err)
			return
		}
		///创建脚本保存路径 脚本存放路径：部门/项目/应用/项目名/,须判断路径是否包含.jmx
		if !strings.Contains(script.SavePath, ".jmx") {
			// 创建脚本文件 部门/项目/应用/项目名/**.jmx
			if file, err = os.Create(SavePath + script.TestName + ".jmx"); err != nil {
				log.Error("create file error :(%v)", err)
				message = "create .jmx error"
				return
			}
			defer file.Close()
			//jtl 路径
			script.ResJtl = SavePath + script.TestName + ".jtl"
			//jmeter-log 路径
			script.JmeterLog = SavePath + script.TestName + ".log"

		} else {
			// 如果路径钟包含 .jmx ,则直接根据路径创建
			if file, err = os.Create(script.SavePath); err != nil {
				log.Error("create file error :(%v)", err)
				message = "create .jmx error"
				return
			}
			defer file.Close()
		}
		buff = buff.Funcs(template.FuncMap{"unescaped": unescaped})
		buff.Execute(io.Writer(file), script)
		script.SavePath = file.Name()
	}
	script.Ctime = time.Now()
	script.ProjectName = script.TestName
	if JSON, err = json.Marshal(script); err != nil {
		return
	}
	if err = json.Unmarshal([]byte(JSON), &scriptd); err != nil {
		log.Error("sorry,scriptd err(%v)", err)
		return
	}
	scriptd.HeaderString = stringHeaderd
	scriptd.Arguments = ArgmentString
	scriptd.JSONExtractor = script.JSONExtractor
	scriptd.Data = script.Data
	scriptd.FileName = dataFileName
	if script.FileName == "" || script.ParamsName == "" {
		scriptd.UseDataFile = false
	} else {
		scriptd.UseDataFile = true
	}

	if len(Assertionsd) > 0 {
		scriptd.AssertionString = unescaped(SliceToString(Assertionsd, " "))
	}
	return
}

//DelScript sel script
func (s *Service) DelScript(id int) error {
	return s.dao.DelScript(id)
}

//UpdateScript update script info
func (s *Service) UpdateScript(script *model.Script) (updateResult string, err error) {
	var (
		buff           *template.Template
		stringHeader   string
		Headers        []map[string]string
		stringArgument string
		Arguments      []map[string]string
		scriptd        *model.Script
		u              *url.URL
		file           *os.File
		sinfoJSON      []byte
		sinfoJSONd     []byte
		JSONExtractors string
		Assertionsd    []string
	)
	if scriptd, err = s.dao.QueryScriptByID(script.ID); err != nil {
		log.Error("query script fail , error %v", err)
		return
	}
	if script.Data == "" {
		buff, err = template.ParseFiles(s.c.Jmeter.JmeterScUcodedTmp)
	} else {
		buff, err = template.ParseFiles(s.c.Jmeter.JmeterScTmp)
	}
	if err != nil {
		log.Error("open file failed! error %v", err)
		return
	}
	if u, err = url.Parse(script.URL); err != nil || u == nil {
		log.Error("sorry,url is not standard,error(%v)", err)
		err = ecode.MelloiUrlParseError
		return
	}
	// 修改laodTime 和 threadsSum
	// ThreadGroup.ramp_time">{{.ReadyTime}}</stringProp>
	if file, err = os.Create(scriptd.SavePath); err != nil {
		log.Error("create file failed! error %v", err)
		return
	}
	defer file.Close()
	if err = json.Unmarshal([]byte(scriptd.APIHeader), &Headers); err != nil {
		updateResult = " scriptd.APIHeade json 不合法"
		log.Error("scriptd.APIHeader switch map failed! error %v", err)
		return
	}

	if err = json.Unmarshal([]byte(scriptd.ArgumentString), &Arguments); err != nil {
		updateResult = "scriptd.ArgumentString  json 不合法"
		log.Error("scriptd.ArgumentString switch map failed! error %v", err)
		return
	}
	if len(scriptd.OutputParamsMap) > 0 && scriptd.OutputParams != "" && scriptd.OutputParams != "[{\"\":\"\"}]" && scriptd.OutputParams != "[]" {
		if err = json.Unmarshal([]byte(scriptd.OutputParams), &scriptd.OutputParamsMap); err != nil {
			log.Error("scriptd.OutputParams switch map failed! error %v", err)
			return
		}
	}
	stringHeader = SetHeaders(Headers, scriptd.ID)
	stringArgument = SetArguments(Arguments, scriptd.ID)
	if len(scriptd.OutputParamsMap) > 0 && scriptd.OutputParams != "[{\"\":\"\"}]" && scriptd.OutputParams != "[]" && script.OutputParams != "" {
		if JSONExtractors, err = s.SetJSONExtractors(scriptd); err != nil {
			return
		}
		if JSONExtractors != "" {
			script.JSONExtractor = unescaped(JSONExtractors)
		}
	}
	scriptd.HeaderString = unescaped(stringHeader)
	scriptd.Arguments = unescaped(stringArgument)
	scriptd.Data = script.Data
	scriptd.Assertion = script.Assertion
	scriptd.ReadyTime = script.ReadyTime
	scriptd.ThreadsSum = script.ThreadsSum
	scriptd.LoadTime = script.LoadTime
	scriptd.ProcType = u.Scheme
	scriptd.Domain = u.Hostname()
	scriptd.Port = u.Port()
	scriptd.TestName = script.TestName
	scriptd.FileName = scriptd.ScriptPath + scriptd.FileName
	if scriptd.Assertion != "" {
		scriptd.UseAssertion = true
		Assertions := strings.Split(scriptd.Assertion, "|")
		for _, assert := range Assertions {
			Assertionsd = append(Assertionsd, model.AssertionStart+assert+model.AssertionEnd)
		}
		scriptd.AssertionString = unescaped(SliceToString(Assertionsd, " "))
	}

	//判断是否使用内置参数
	if sinfoJSON, err = json.Marshal(script); err != nil {
		log.Error("script err :(%s)", err)
		return
	}
	if sinfoJSONd, err = json.Marshal(scriptd); err != nil {
		log.Error("script err :(%s)", err)
		return
	}
	sc := string(sinfoJSON) + string(sinfoJSONd)
	if strings.Contains(sc, "${mid}") || strings.Contains(sc, "${access_key}") || script.UseSign {
		scriptd.UseBuiltinParam = true
	}
	if u.RawQuery == "" {
		scriptd.Path = u.Path
		scriptd.RowQuery = "appkey=" + conf.Conf.Melloi.AppkeyProd
	} else {
		scriptd.Path = u.Path + "?" + u.RawQuery
		scriptd.RowQuery = u.RawQuery + "&appkey=" + conf.Conf.Melloi.AppkeyProd
	}
	if scriptd.UseSign {
		scriptd.Path = u.Path + "?${params}"
	}
	// POST 请求的 binary 逻辑
	if scriptd.MultipartFile != "" && scriptd.MultipartPath != "" {
		scriptd.UseMultipart = true
		multiPartInfo := SetMultiPartInfo(scriptd)
		scriptd.MultiPartInfo = unescaped(multiPartInfo)
	}
	if scriptd.IsAsync {
		scriptd.AsyncInfo = unescaped(model.AsyncInfo)
	}
	buff = buff.Funcs(template.FuncMap{"unescaped": unescaped})
	buff.Execute(io.Writer(file), scriptd)
	script.ProjectName = script.TestName
	script.KeepAlive = scriptd.KeepAlive
	if err = s.dao.UpdateScriptPart(script); err != nil {
		log.Error("s.dao.UpdateScript err :(%v)", err)
		return
	}
	updateResult = "success"
	return
}

//UpdateScriptAll update script all
func (s *Service) UpdateScriptAll(script *model.Script, scene *model.Scene) (updateResult string, err error) {
	var (
		scriptd   model.Script
		paramList *model.ParamList
		isEdit    = true
		groupId   int
		runOrder  int
		fileWrite bool
	)
	id := script.ID
	script.ID = 0
	// script test_type 为1 表示 http 脚本
	if script.TestType == model.HTTP_SCRIPT_TYPE {
		fileWrite = true
	}
	if _, scriptd, err = s.AddScript(script, fileWrite); err != nil {
		log.Error("sorry, addScript fail : (%v)", err)
		return
	}

	if script.TestType == model.SCENE_SCRIPT_TYPE {
		//根据接口参数依赖，计算出接口分组与执行顺序
		if paramList, err = s.dao.QueryParams(&scriptd, scene); err != nil {
			log.Error("s.dao.QueryParams err :(%v)", err)
			return
		}
		groupId, runOrder = GroupOrderByEdit(isEdit, id, &scriptd, scene, paramList)
		if groupId != 0 && runOrder != 0 {
			scriptd.GroupID = groupId
			scriptd.RunOrder = runOrder
		}
	}

	scriptd.ID = id
	scriptd.SavePath = ""

	if scriptd.Loops == -1 {
		headerString := MapToString(scriptd.Headers)
		argumentString := MapToString(scriptd.ArgumentsMap)
		scriptd.OutputParams = MapToString(scriptd.OutputParamsMap)
		scriptd.ArgumentString = argumentString
		scriptd.APIHeader = headerString
		if err = s.dao.UpdateScript(&scriptd); err != nil {
			log.Error("s.dao.UpdateScript err : (%v)", err)
			return
		}
	}
	updateResult = "success"
	return
}

//AddJmeterSample add jmeter sample
func (s *Service) AddJmeterSample(script *model.Script) (result string, err error) {
	var (
		buff           *template.Template
		u              *url.URL
		b              = bytes.NewBuffer(nil)
		JSONExtractors string
		Assertionsd    []string
	)

	if script.Data == "" {
		buff, err = template.ParseFiles(s.c.Jmeter.JmeterSampleTmp)
	} else {
		buff, err = template.ParseFiles(s.c.Jmeter.JmeterSamplePostTmp)
	}
	if err != nil {
		log.Info("open template failed! (%v)", err)
		return
	}
	//判断url
	if !strings.Contains(script.URL, "http://") && !strings.Contains(script.URL, "https://") {
		script.URL = "http://" + script.URL
	}
	if script.Delimiter == "" {
		script.Delimiter = ","
	}
	if u, err = url.Parse(script.URL); err != nil || u == nil {
		log.Error("sorry,url is not standard,error(%v)", err)
		err = ecode.MelloiUrlParseError
		return
	}
	stringHeader := SetHeaders(script.Headers, script.ID)
	ArgmentStr := SetArguments(script.ArgumentsMap, script.ID)
	ArgmentString := unescaped(ArgmentStr)
	if len(script.OutputParamsMap) > 0 && script.OutputParams != "[{\"\":\"\"}]" && script.OutputParams != "[]" && script.OutputParams != "" {
		if JSONExtractors, err = s.SetJSONExtractors(script); err != nil {
			return
		}
		if JSONExtractors != "" {
			script.JSONExtractor = unescaped(JSONExtractors)
		}
	}
	script.Arguments = ArgmentString
	stringHeaderd := unescaped(stringHeader)
	script.HeaderString = stringHeaderd
	script.ProcType = u.Scheme
	script.Domain = u.Hostname()
	script.Port = u.Port()
	script.FileName = script.ScriptPath + script.FileName
	if u.RawQuery == "" {
		script.Path = u.Path
		script.RowQuery = "appkey=" + conf.Conf.Melloi.AppkeyProd
	} else {
		script.Path = u.Path + "?" + u.RawQuery
		script.RowQuery = u.RawQuery + "&appkey=" + conf.Conf.Melloi.AppkeyProd
	}
	if script.UseSign {
		script.Path = u.Path + "?${params}"
	}
	if script.Assertion != "" {
		script.UseAssertion = true
		Assertions := strings.Split(script.Assertion, "|")
		for _, assert := range Assertions {
			Assertionsd = append(Assertionsd, model.AssertionStart+assert+model.AssertionEnd)
		}
		script.AssertionString = unescaped(SliceToString(Assertionsd, " "))
	}
	if script.ConstTimer > 0 && script.RandomTimer == 0 {
		constTimer := strings.Replace(model.ConstTimer, "1000", strconv.Itoa(script.ConstTimer), -1)
		script.ConstTimerInfo = unescaped(constTimer)
	}
	if script.ConstTimer > 0 && script.RandomTimer > 0 {
		constTimerd := strings.Replace(model.RandomTimer, "1000", strconv.Itoa(script.ConstTimer), -1)
		randomTimerd := strings.Replace(constTimerd, "500", strconv.Itoa(script.RandomTimer), -1)
		script.RandomTimerInfo = unescaped(randomTimerd)
	}
	buff = buff.Funcs(template.FuncMap{"unescaped": unescaped})
	buff.Execute(b, script)
	result = b.String()
	return
}

//AddThreadGroup add thread group
func (s *Service) AddThreadGroup(script *model.Script, sceneType int) (result string, err error) {
	var (
		buff    *template.Template
		scriptd model.Script
		b       = bytes.NewBuffer(nil)
	)

	if _, scriptd, err = s.AddScript(script, false); err != nil {
		log.Error("s.AddScript err :(%v)", err)
		return
	}
	//并行get
	if sceneType == 1 && script.Data == "" {
		buff, err = template.ParseFiles(s.c.Jmeter.JmeterThGroupTmp)
	}

	//并行post
	if sceneType == 1 && script.Data != "" {
		buff, err = template.ParseFiles(s.c.Jmeter.JmeterThGroupPostTmp)
	}

	//串行get
	if sceneType == 2 && script.Data == "" {
		buff, err = template.ParseFiles(s.c.Jmeter.JmeterThGroupDuliTmp)
	}

	//串行 post
	if sceneType == 2 && script.Data != "" {
		buff, err = template.ParseFiles(s.c.Jmeter.JmeterThGroupPostDuliTmp)
	}

	if err != nil {
		log.Info("open template failed! (%v)", err)
		return
	}
	buff = buff.Funcs(template.FuncMap{"unescaped": unescaped})
	scriptd.FileName = scriptd.ScriptPath + scriptd.FileName
	buff.Execute(b, scriptd)
	result = b.String()
	return
}

//GetThreadGroup get thread group
func (s *Service) GetThreadGroup(scrThreadGroup model.ScrThreadGroup) (threadGroup string, err error) {
	var (
		threadGroups   []string
		IsSerial       bool
		groups         []int
		groupMap       = make(map[int]int)
		RunOrders      []int
		scriptsd       []*model.Script
		scriptsds      [][]*model.Script
		threadGroupd   string
		threadGroupds  []string
		threadSamples  []string
		threadSample   string
		threadSamplesd string
		threadGrou     string
	)
	for _, script := range scrThreadGroup.Scripts {
		RunOrders = append(RunOrders, script.RunOrder)
		groupMap[script.GroupID]++
		if script.APIHeader != "" && script.APIHeader != "[{\"\":\"\"}]" {
			if err = json.Unmarshal([]byte(script.APIHeader), &script.Headers); err != nil {
				log.Error("get script header err : (%v), scriptId:(%d)", err, script.ID)
			}
		}
		if script.ArgumentString != "" && script.ArgumentString != "[{\"\":\"\"}]" {
			if err = json.Unmarshal([]byte(script.ArgumentString), &script.ArgumentsMap); err != nil {
				log.Error("get script argument err: (%v), scriptId:(%d)", err, script.ID)
			}
		}
		if script.OutputParams != "" && script.OutputParams != "[{\"\":\"\"}]" && script.OutputParams != "[]" {
			if err = json.Unmarshal([]byte(script.OutputParams), &script.OutputParamsMap); err != nil {
				log.Error("get script OutputParams err: (%v), scriptId:(%d)", err, script.ID)
			}
		}
	}
	for _, order := range RunOrders {
		if order > 1 {
			IsSerial = true
			break
		}
	}
	for k := range groupMap {
		groups = append(groups, k)
	}
	//并行脚本逻辑
	if !IsSerial {
		for _, script := range scrThreadGroup.Scripts {
			if threadGrou, err = s.AddThreadGroup(script, 1); err != nil {
				log.Error("d.GetThroupGroupJmeter:  error(%v)", err)
				return
			}
			threadGroups = append(threadGroups, threadGrou)
		}
		for _, thgroup := range threadGroups {
			threadGroupd = threadGroupd + thgroup
		}
		threadGroup = threadGroupd
		return
	}

	//串行脚本逻辑
	for _, group := range groups {
		for i := 0; i < len(scrThreadGroup.Scripts); i++ {
			if scrThreadGroup.Scripts[i].GroupID == group {
				scriptsd = append(scriptsd, scrThreadGroup.Scripts[i])
			}
		}
		scriptsds = append(scriptsds, scriptsd)
		scriptsd = []*model.Script{}
	}

	// 每个线程组内的接口，按照接口的 RunOrder 属性进行排序
	for _, scriptsd := range scriptsds {
		for i := 0; i < len(scriptsd)-1; i++ {
			for j := i + 1; j < len(scriptsd); j++ {
				if scriptsd[i].RunOrder > scriptsd[j].RunOrder {
					tmp := scriptsd[i]
					scriptsd[i] = scriptsd[j]
					scriptsd[j] = tmp
				}
			}
		}
	}

	for k := 0; k < len(scriptsds); k++ {
		if len(scriptsds[k]) == 1 {
			if threadGroupd, err = s.AddThreadGroup(scriptsds[k][0], 1); err != nil {
				log.Error("d.GetThroupGroupJmeter:  error(%v)", err)
				return
			}
		} else {
			//生成一个线程组，再往线程组插入 sample
			if threadGroupd, err = s.AddThreadGroup(scriptsds[k][0], 2); err != nil {
				log.Error(" s.AddScript err :(%v)", err)
				return
			}
			for i := 0; i < len(scriptsds[k]); i++ {
				//从第二个接口开始生成 sample
				if i > 0 {
					if threadSample, err = s.AddJmeterSample(scriptsds[k][i]); err != nil {
						log.Error("s.dao.GetThroupSeriesSample err :(%v)", err)
						return
					}
					threadSamples = append(threadSamples, threadSample)
				}
			}
		}
		for j := 0; j < len(threadSamples); j++ {
			threadSamplesd = threadSamplesd + threadSamples[j]
		}
		//生成一个 线程组
		threadGroupM := strings.Replace(threadGroupd, "+-+-+*", threadSamplesd, -1)

		//多个线程组
		threadGroupds = append(threadGroupds, threadGroupM)
		threadSamples = []string{}
		threadSamplesd = ""
	}

	for _, threadGrou := range threadGroupds {
		threadGroup = threadGroup + threadGrou
	}
	return
}

//URLCheck url check
func (s *Service) URLCheck(script *model.Script) (urlEncode *model.URLEncode, err error) {
	var (
		tempUrl *url.URL
	)
	urlEncode = &model.URLEncode{}
	if strings.Contains(script.URL, "?") {
		if tempUrl, err = url.Parse(script.URL); err != nil {
			return
		}
		params := tempUrl.RawQuery
		paramList := strings.Split(params, "&")
		for _, param := range paramList {
			value := strings.Split(param, "=")[1]
			var myMap map[string]interface{}
			if err = json.Unmarshal([]byte(value), &myMap); err != nil {
				urlEncode.ParamsType = "nojson"
				urlEncode.NewUrl = script.URL
				continue
			}
			urlEncode.ParamsType = "json"
			newParams := tempUrl.Query().Encode()
			urlEncode.NewUrl = strings.Split(script.URL, "?")[0] + "?" + newParams
			return
		}
	}
	return
}

//AddTimer add Timer
func (s *Service) AddTimer(script *model.Script) error {
	return s.dao.AddScriptTimer(script)
}

//SetHeaders set headers
func SetHeaders(Headers []map[string]string, scriptId int) (stringHeader string) {
	var (
		stringHeaders []string
		HeaderString  string
	)

	// 表示直接生成的脚本，非修改
	if scriptId == 0 {
		for _, header := range Headers {
			k := header["key"]
			v := header["value"]
			HeaderString = model.HeaderStart + k + model.HeaderMid + v + model.HeaderEnd
			stringHeaders = append(stringHeaders, HeaderString)
		}
	} else {
		//修改脚本，header 从数据库取出的
		for _, header := range Headers {
			for k, v := range header {
				HeaderString = model.HeaderStart + k + model.HeaderMid + v + model.HeaderEnd
				stringHeaders = append(stringHeaders, HeaderString)
			}
		}
	}

	for _, str := range stringHeaders {
		stringHeader = stringHeader + str + "\r\n"
	}
	return
}

//SetArguments  set argument
func SetArguments(Arguments []map[string]string, scriptId int) (stringArgument string) {
	var (
		stringArguments []string
		ArgumentString  string
	)

	// 表示直接生成的脚本，非修改
	if scriptId == 0 {
		for _, argument := range Arguments {
			k := argument["key"]
			v := argument["value"]
			ArgumentString = model.ElementPropName + k + model.HTTPArgument + model.HTTPArgumentEncode + model.ArgumentStart + v + model.ArgumentMid + k + model.ArgumentEnd
			stringArguments = append(stringArguments, ArgumentString)
		}
	} else {
		//修改脚本，argument 从数据库取出的
		for _, argument := range Arguments {
			for k, v := range argument {
				ArgumentString = model.ElementPropName + k + model.HTTPArgument + model.HTTPArgumentEncode + model.ArgumentStart + v + model.ArgumentMid + k + model.ArgumentEnd
				stringArguments = append(stringArguments, ArgumentString)
			}
		}
	}

	for _, str := range stringArguments {
		stringArgument = stringArgument + str + "\r\n"
	}
	return
}

//SetJSONExtractor set JSONExtractorgo
func (s *Service) SetJSONExtractor(jsonExt model.JSONExtractor) (JSONExtractor string, err error) {
	var (
		buff *template.Template
		b    = bytes.NewBuffer(nil)
	)
	buff, err = template.ParseFiles(s.c.Jmeter.JSONExtractorTmp)
	if err != nil {
		log.Info("open template failed! (%v)", err)
		return
	}
	buff = buff.Funcs(template.FuncMap{"unescaped": unescaped})
	buff.Execute(b, jsonExt)
	JSONExtractor = b.String()
	return
}

//SetJSONExtractors Set JSONExtractors
func (s *Service) SetJSONExtractors(script *model.Script) (JSONExtractors string, err error) {
	var (
		JSONExtractords []string
		jsonExt         model.JSONExtractor
		JSONExtractord  string
	)
	// 表示直接生成的脚本，非修改
	if script.ID == 0 {
		for _, OutputParam := range script.OutputParamsMap {
			jsonExt.JSONName = OutputParam["key"]
			jsonExt.JSONPath = OutputParam["value"]
			if jsonExt.JSONName != "" && jsonExt.JSONPath != "" {
				if JSONExtractord, err = s.SetJSONExtractor(jsonExt); err != nil {
					log.Error("SetJSONExtractor err :(%v) ", err)
					return
				}
				JSONExtractords = append(JSONExtractords, JSONExtractord)
			}
		}
	} else {
		//修改脚本，header 从数据库取出的
		for _, OutputParam := range script.OutputParamsMap {
			for k, v := range OutputParam {
				jsonExt.JSONName = k
				jsonExt.JSONPath = v
			}
			if jsonExt.JSONName != "" && jsonExt.JSONPath != "" {
				if JSONExtractord, err = s.SetJSONExtractor(jsonExt); err != nil {
					log.Error("SetJSONExtractor err :(%v) ", err)
					return
				}
				JSONExtractords = append(JSONExtractords, JSONExtractord)
			}
		}
	}
	JSONExtractors = SliceToString(JSONExtractords, " ")
	return
}

//SetMultiPartInfo Set MultiPartInfo
func SetMultiPartInfo(script *model.Script) (multiPartInfo string) {
	multiPartInfo = model.MultipartName + script.MultipartPath + script.MultipartFile + model.MultipartFilePath +
		script.MultipartPath + script.MultipartFile + model.MultipartFilePathd + script.MultipartParam +
		model.MultipartMimetype + script.MimeType + model.MultipartEnd
	return
}

//MapToString map to string
func MapToString(strMapArr []map[string]string) (headerString string) {
	for _, strMap := range strMapArr {
		k, keyOk := strMap["key"]
		v, valueOK := strMap["value"]
		if keyOk != valueOK {
			return
		}
		if keyOk {
			delete(strMap, "key")
			delete(strMap, "value")
			strMap[k] = v
		}
	}
	headers, _ := json.Marshal(strMapArr)
	headerString = string(headers)
	return
}

//StringToMap string to map
func StringToMap(headerString string) (mapHeaders []map[string]string) {
	if headerString != "[{\"\":\"\"}]" {
		if err := json.Unmarshal([]byte(headerString), &mapHeaders); err != nil {
			return
		}
	}
	return
}

func unescaped(x string) interface{} {
	return template.HTML(x)
}

//HostInfo add hostinfo
func HostInfo(domain string, apiHeader string) (hostInfo string) {
	mapHeaders := StringToMap(apiHeader)
	reg := regexp.MustCompile(`.com|.co`)
	strs := reg.FindAllString(domain, -1)
	if len(strs) != 0 {
		for _, str := range strs {
			if (strings.Contains(str, ".com") || strings.Contains(str, ".co")) && strings.Contains(apiHeader, domain) { //绑定至用户指定的ip
				for _, header := range mapHeaders {
					for host := range header {
						conf.Conf.Paas.HostInfo = domain + ":" + host
						hostInfo = conf.Conf.Paas.HostInfo
					}
				}
			} else if strings.Contains(str, ".com") || strings.Contains(str, ".co") { //默认绑定至172.22.22.222
				conf.Conf.Paas.HostInfo = domain + ":" + conf.Conf.Melloi.DefaultHost
				hostInfo = conf.Conf.Paas.HostInfo
			}
		}
	}
	return
}

//HostInfoList add hostinfo list
func HostInfoList(scripts []*model.Script) (hostInfo string) {
	for _, script := range scripts {
		mapHeaders := StringToMap(script.APIHeader)
		reg := regexp.MustCompile(`.com|.co`)
		strs := reg.FindAllString(script.Domain, -1)
		if len(strs) != 0 {
			for _, str := range strs {
				if (strings.Contains(str, ".com") || strings.Contains(str, ".co")) && strings.Contains(script.APIHeader, script.Domain) { //绑定至用户指定的ip
					for _, header := range mapHeaders {
						for host := range header {
							conf.Conf.Paas.HostInfo = script.Domain + ":" + host
							hostInfo = conf.Conf.Paas.HostInfo
						}
					}
				} else if strings.Contains(str, ".com") || strings.Contains(str, ".co") { //默认绑定至172.22.22.222
					hostInfo = hostInfo + script.Domain + ":" + conf.Conf.Melloi.DefaultHost + ","
				}
			}
		}
	}
	conf.Conf.Paas.HostInfo = hostInfo
	return
}

//HostInfoByUploadSc host info By UploadSc
func HostInfoByUploadSc(domain string) (hostInfo string) {
	domains := strings.Split(domain, ",")
	for _, dom := range domains {
		hostInfo = hostInfo + dom + ":" + conf.Conf.Melloi.DefaultHost + ","
	}
	conf.Conf.Paas.HostInfo = hostInfo
	return
}

// GroupOrder Group Order
func GroupOrder(isEdit bool, script *model.Script, scene *model.Scene, paramList *model.ParamList) (groupId int, runOrder int) {
	var (
		flag = 0
		//tmpIndex = 0
		u   *url.URL
		err error
	)
	if u, err = url.Parse(script.URL); err != nil || u == nil {
		log.Error("sorry, url is wrong, please check. error(%v)", err)
		err = ecode.MelloiUrlParseError
		return
	}
	if len(paramList.ParamList) > 0 {
		for _, paramList := range paramList.ParamList {
			tempList := strings.Split(u.RawQuery, "&")
			tempHeaderList := strings.Split(script.APIHeader, ",")
			tempArgumentList := strings.Split(script.ArgumentString, ",")
			tempDataList := strings.Split(script.Data, ",")
			if u.RawQuery == "" && (script.APIHeader == "[{\"\":\"\"}]" || script.APIHeader == "[]") && script.Data == "" && (script.ArgumentString == "[{\"\":\"\"}]" || script.ArgumentString == "[]") {
				if scene.SceneType == 1 || scene.SceneType == 0 {
					groupId = paramList.GroupID + 1
					runOrder = 1
					continue
				} else if scene.SceneType == 2 {
					groupId = paramList.GroupID
					runOrder = paramList.RunOrder + 1
					continue
				}
			}
			//url params check
			if u.RawQuery != "" {
				if groupId, runOrder, flag, err = OrderEach(isEdit, tempList, paramList, scene.SceneType); err != nil || (runOrder != 1 && flag == 0) {
					return
					//} else if flag == 2 {
					//	tmpIndex = index
					//	break
				}
			}
			//APIHeader params check
			if script.APIHeader != "[{\"\":\"\"}]" && script.APIHeader != "[]" {
				if groupId, runOrder, flag, err = OrderEach(isEdit, tempHeaderList, paramList, scene.SceneType); err != nil || (runOrder != 1 && flag == 0) {
					return
				}
			}
			//ArgumentString params check
			if script.ArgumentString != "[{\"\":\"\"}]" && script.ArgumentString != "[]" {
				if groupId, runOrder, flag, err = OrderEach(isEdit, tempArgumentList, paramList, scene.SceneType); err != nil || (runOrder != 1 && flag == 0) {
					return
				}
			}
			//body params check
			if script.Data != "" {
				if groupId, runOrder, flag, err = OrderEach(isEdit, tempDataList, paramList, scene.SceneType); err != nil || (runOrder != 1 && flag == 0) {
					return
				}
			}
		}
		//for i := tmpIndex; i < len(paramList.ParamList); i++ {
		//	if err = s.dao.UpdateRunOrder(paramList.ParamList[i].); err != nil {
		//		log.Error("s.dao.UpdateScript err :(%v)", err)
		//		return
		//	}
		//}
	} else if script.GroupID != 0 {
		groupId = script.GroupID
		runOrder = 1
	} else {
		groupId = 1
		runOrder = 1
	}
	return
}

// GroupOrderByEdit Group Order By Edit
func GroupOrderByEdit(isEdit bool, id int, script *model.Script, scene *model.Scene, paramList *model.ParamList) (groupId int, runOrder int) {
	var (
		flag = 0
		//tmpIndex = 0
		u   *url.URL
		err error
	)
	if u, err = url.Parse(script.URL); err != nil || u == nil {
		log.Error("sorry, url is wrong, please check. error(%v)", err)
		err = ecode.MelloiUrlParseError
		return
	}
	if len(paramList.ParamList) > 0 {
		for _, paramList := range paramList.ParamList {
			if paramList.ID != id {
				tempList := strings.Split(u.RawQuery, "&")
				tempHeaderList := strings.Split(script.APIHeader, ",")
				tempArgumentList := strings.Split(script.ArgumentString, ",")
				tempDataList := strings.Split(script.Data, ",")
				//url params check
				if u.RawQuery != "" {
					if groupId, runOrder, flag, err = OrderEach(isEdit, tempList, paramList, scene.SceneType); err != nil || (runOrder != 1 && flag == 0) {
						return
					}
				}
				//APIHeader params check
				if script.APIHeader != "[{\"\":\"\"}]" && script.APIHeader != "[]" {
					if groupId, runOrder, flag, err = OrderEach(isEdit, tempHeaderList, paramList, scene.SceneType); err != nil || (runOrder != 1 && flag == 0) {
						return
					}
				}
				//ArgumentString params check
				if script.ArgumentString != "[{\"\":\"\"}]" && script.ArgumentString != "[]" {
					if groupId, runOrder, flag, err = OrderEach(isEdit, tempArgumentList, paramList, scene.SceneType); err != nil || (runOrder != 1 && flag == 0) {
						return
					}
				}
				//body params check
				if script.Data != "" {
					if groupId, runOrder, flag, err = OrderEach(isEdit, tempDataList, paramList, scene.SceneType); err != nil || (runOrder != 1 && flag == 0) {
						return
					}
				}
			}
		}
	}
	return
}

// OrderEach Order Each
func OrderEach(isEdit bool, strList []string, paramList *model.Params, sceneType int) (groupId int, runOrder int, flag int, err error) {
	for _, paramPage := range strList {
		if strings.Contains(paramPage, "$") {
			tempParam := strings.Split(paramPage, "$")[1]
			param := RegularTrans(tempParam)
			//several params
			if strings.Contains(paramList.OutputParams, ",") {
				dbTempList := strings.Split(paramList.OutputParams, ",")
				for _, dbParam := range dbTempList {
					flag = 0
					finalParam := strings.Split(strings.Split(dbParam, "\":\"")[0], "\"")[1]
					if param == finalParam {
						groupId = paramList.GroupID
						runOrder = paramList.RunOrder + 1
						return
					}
					if !isEdit {
						if sceneType == 1 || sceneType == 0 {
							groupId = paramList.GroupID + 1
							runOrder = 1
						} else if sceneType == 2 {
							groupId = paramList.GroupID
							runOrder = paramList.RunOrder + 1
							flag = 1
						}
					}
				}
			} else { //single param
				dbParam := paramList.OutputParams
				finalParam := strings.Split(strings.Split(dbParam, "\":\"")[0], "\"")[1]
				if param == finalParam {
					groupId = paramList.GroupID
					runOrder = paramList.RunOrder + 1
					return
				}
				if !isEdit {
					if sceneType == 1 || sceneType == 0 {
						groupId = paramList.GroupID + 1
						runOrder = 1
					} else if sceneType == 2 {
						groupId = paramList.GroupID
						runOrder = paramList.RunOrder + 1
						flag = 1
					}
				}
			}
		} else {
			if !isEdit {
				if sceneType == 1 || sceneType == 0 {
					groupId = paramList.GroupID + 1
					runOrder = 1
				} else if sceneType == 2 {
					groupId = paramList.GroupID
					runOrder = paramList.RunOrder + 1
					flag = 1
				}
			}
		}
	}
	return
}

// RegularTrans Regular Trans
func RegularTrans(tempStr string) (targetStr string) {
	reg := regexp.MustCompile(`[\w]+`)
	str := reg.FindAllString(tempStr, -1)
	if len(str) != 0 {
		targetStr = str[0]
	}
	return targetStr
}