package test

import (
	"encoding/json"
	"errors"
	"fmt"
	"os"
	"reflect"
	"regexp"
	"scd_check_tools/conf"
	"scd_check_tools/email"
	"scd_check_tools/logger"
	"scd_check_tools/models/bo"
	"scd_check_tools/tools"
	"strings"
	"sync"
	"time"
)

//单元测试时使用的固定的用户token
//在start时传入
var UnitTestToken = ""

//单元测试类
type UnitTest struct {
	UserInfo map[string]interface{}
}

func Start(testtoken string) {
	//判断当前运行模式，仅当runmode为test时才启动所有的测试
	//启动时会执行该方法中所有的测试过程
	if conf.GlobalConfig["unittest"] != "true" {
		return
	}
	UnitTestToken = testtoken
	go func() {
		time.Sleep(10 * time.Second)
		t := new(UnitTest)
		logger.Logger.Println("******************正在进行单元测试********************")
		if t.UserInfo == nil {
			t.UserInfo = map[string]interface{}{"name": "单元测试", "ip": "127.0.0.1"}
		}
		typ := reflect.TypeOf(t)
		val := reflect.ValueOf(t) //获取reflect.Type类型
		numOfMethod := typ.NumMethod()
		logger.Logger.Println(fmt.Sprintf("需要进行的单元测试有%d个", numOfMethod))
		for i := 0; i < numOfMethod; i++ {
			val.Method(i).Call(nil)
		}
	}()
}

func (t *UnitTest) TestReg() {
	return
	xmlStr := `<LN0 lineno="211125" nodeid="4211127" desc="" inst="" lnClass="LLN0" lnType="AutoPrefix1532860310_SAC_PSIU600_LLN0" prefix="">`
	pattern := `( lineno="\d{1,}" nodeid="\d{1,}")|(&#xA;)|( ix="")|(<ext:eOption.*?>.*?</ext:eOption>)` //替换其中的lineno和nodeid属性
	reg := regexp.MustCompile(pattern)
	xmlStr = reg.ReplaceAllString(xmlStr, "")
	fmt.Println(xmlStr)
}

//测试邮件发送
func (t *UnitTest) TestEmailSend() {
	return
	err := new(email.Send).SendEmail("3116246@qq.com", "测试", "这是邮件发送测试", []string{})
	if err != nil {
		logger.Logger.Error(err)
	} else {
		logger.Logger.Println("=====测试邮件已发送成功，请登录测试邮件确认！")
	}
}

//测试：根据告警等级统计结果
func (t *UnitTest) GetRuleLevelCheckList() {
	return
	//appport := conf.GlobalConfig["appport"]
	//url := "http://127.0.0.1:" + appport + "/api/model/get_south_model"
	//logger.Logger.Println(fmt.Sprintf("============正在测试GetModelList方法，请求URL:%s", url))
	//testResult, _ := tools.Get(url, UnitTestToken)
	//logger.Logger.Println(fmt.Sprintf("============GetModelList方法测试结果:%+v", testResult))
	testobj := new(bo.ScdNodeRule)
	testobj.ScdID = 16000007
	logger.Logger.Println(fmt.Sprintf("============正在测试[根据告警等级统计结果]方法，参数:"))
	result, err := testobj.ResultStatByLevel("", "", "", "", "")
	if err != nil {
		logger.Logger.Error(err)
	}
	resultStr, _ := json.Marshal(result)
	logger.Logger.Println(fmt.Sprintf("============[根据告警等级统计结果]测试结果:%+v", string(resultStr)))
}

//测试：获取规则校验统计结果
func (t *UnitTest) GetRuleCheckList() {
	return
	//appport := conf.GlobalConfig["appport"]
	//url := "http://127.0.0.1:" + appport + "/api/model/get_south_model"
	//logger.Logger.Println(fmt.Sprintf("============正在测试GetModelList方法，请求URL:%s", url))
	//testResult, _ := tools.Get(url, UnitTestToken)
	//logger.Logger.Println(fmt.Sprintf("============GetModelList方法测试结果:%+v", testResult))
	testobj := new(bo.ScdNodeRule)
	testobj.ScdID = 16000007
	logger.Logger.Println(fmt.Sprintf("============正在测试[获取规则校验统计结果]方法，参数:"))
	result, _, err := testobj.ResultList("", "", "", "", "", "", 1, 20)
	if err != nil {
		logger.Logger.Error(err)
	}
	resultStr, _ := json.Marshal(result)
	logger.Logger.Println(fmt.Sprintf("============[获取规则校验统计结果]测试结果:%+v", string(resultStr)))
}

//测试：解析scd文件的间隔和装置
func (t *UnitTest) PScdIed() {
	return
	appport := conf.GlobalConfig["appport"]
	url := "http://127.0.0.1:" + appport + "/api/screen/scd/parse/step1"
	logger.Logger.Println(fmt.Sprintf("============正在测试解析scd文件的间隔和装置方法，请求URL:%s", url))
	postdata := []string{"station_id=861", "scd_path=\\static\\download\\曲山20210520.scd", "scd_name=曲山20210520.scd"}
	postdataStr := strings.Join(postdata, "&")
	testResult, _ := tools.Post(url, postdataStr, UnitTestToken)
	logger.Logger.Println(fmt.Sprintf("============解析scd文件的间隔和装置方法测试结果:%+v", testResult))
}

//测点：创建测试任务
func (t *UnitTest) CTask() {
	return
	appport := conf.GlobalConfig["appport"]
	url := "http://127.0.0.1:" + appport + "/api/task/save"
	logger.Logger.Println(fmt.Sprintf("============正在测试创建任务方法，请求URL:%s", url))
	postdata := []string{"id=0", "name=UnitTest_检测任务", "station_id=861", "memo=这是一个检测任务", "report_id=10", "scd_id=10", "modelids=[[1,2]]"}
	postdataStr := strings.Join(postdata, "&")
	testResult, _ := tools.Post(url, postdataStr, UnitTestToken)
	logger.Logger.Println(fmt.Sprintf("============创建任务方法测试结果:%+v", testResult))
}

//测点：删除测试任务
func (t *UnitTest) DTask() {
	return
	appport := conf.GlobalConfig["appport"]
	url := "http://127.0.0.1:" + appport + "/api/task/delete"
	logger.Logger.Println(fmt.Sprintf("============正在测试删除任务方法，请求URL:%s", url))
	postdata := []string{"id=91"}
	postdataStr := strings.Join(postdata, "&")
	testResult, _ := tools.Post(url, postdataStr, UnitTestToken)
	logger.Logger.Println(fmt.Sprintf("============删除任务方法测试结果:%+v", testResult))
}

//测试：添加接线方式
func (t *UnitTest) AddTest12() {
	return
	appport := conf.GlobalConfig["appport"]
	url := "http://127.0.0.1:" + appport + "/api/admin/linkstyle/save"
	logger.Logger.Println(fmt.Sprintf("============正在测试添加接线方式方法，请求URL:%s", url))
	postdata := []string{"id=2", "name=单2母方式", "vol_id=152"}
	postdataStr := strings.Join(postdata, "&")
	testResult, _ := tools.Post(url, postdataStr, UnitTestToken)
	logger.Logger.Println(fmt.Sprintf("============添加接线方式方法测试结果:%+v", testResult))
}

//测试：查询接线方式
func (t *UnitTest) AddTest13() {
	return
	appport := conf.GlobalConfig["appport"]
	url := "http://127.0.0.1:" + appport + "/api/admin/linkstyle/list"
	logger.Logger.Println(fmt.Sprintf("============正在测试查询接线方式方法，请求URL:%s", url))
	//postdata := []string{"id=2", "name=单2母方式", "vol_id=152"}
	//postdataStr := strings.Join(postdata, "&")
	testResult, _ := tools.Get(url, UnitTestToken)
	logger.Logger.Println(fmt.Sprintf("============查询接线方式方法测试结果:%+v", testResult))
}

//测试：添加内置模型
func (t *UnitTest) AddTest14() {
	return
	appport := conf.GlobalConfig["appport"]
	url := "http://127.0.0.1:" + appport + "/api/admin/sysmodel/save"
	logger.Logger.Println(fmt.Sprintf("============正在测试添加内置模型方法，请求URL:%s", url))
	postdata := []string{"id=1", "model_name=线路保护", "vol_id=152", "area_type=116330", "ied_types=P,M,I,C,MM,PM", "line_link_style=2", "relation_json="}
	postdataStr := strings.Join(postdata, "&")
	testResult, _ := tools.Post(url, postdataStr, UnitTestToken)
	logger.Logger.Println(fmt.Sprintf("============添加内置模型方法测试结果:%+v", testResult))
}

//测试：查询内置模型
func (t *UnitTest) AddTest15() {
	return
	appport := conf.GlobalConfig["appport"]
	url := "http://127.0.0.1:" + appport + "/api/admin/sysmodel/list"
	logger.Logger.Println(fmt.Sprintf("============正在测试查询内置模型方法，请求URL:%s", url))
	//postdata := []string{"id=2", "name=单2母方式", "vol_id=152"}
	//postdataStr := strings.Join(postdata, "&")
	testResult, _ := tools.Get(url, UnitTestToken)
	logger.Logger.Println(fmt.Sprintf("============查询内置模型方法测试结果:%+v", testResult))
}

func (t *UnitTest) Test16() {
	return
	testobj := new(bo.CheckAreaMgr)
	testobj.ScdId = 4000002
	logger.Logger.Println(fmt.Sprintf("============正在测试[生成检测模型间隔]方法，参数:"))
	testobj.Reset()
}

func (t *UnitTest) Test17() {
	return
	logger.Logger.Println(fmt.Sprintf("============正在测试[模型复制]方法，参数:"))
	testobj := new(bo.SysCheckModelMgr)
	testobj.Model.ModelName = "[15]"
	testobj.Copy(9)
}

func (t *UnitTest) Test18() {
	return
	logger.Logger.Println(fmt.Sprintf("============正在测试[删除模型]方法，参数:"))
	testobj := new(bo.SysCheckModelMgr)
	testobj.Model.Id = 32
	testobj.Delete()
}

func (t *UnitTest) Test19() {
	return
	logger.Logger.Println(fmt.Sprintf("=============正在测试生成报告"))
	appport := conf.GlobalConfig["appport"]
	url := "http://127.0.0.1:" + appport + "/api/report/make"
	logger.Logger.Println(fmt.Sprintf("============正在测试报告生成，请求URL:%s", url))
	postdata := []string{"task_id=131"}
	postdataStr := strings.Join(postdata, "&")
	testResult, _ := tools.Post(url, postdataStr, UnitTestToken)
	logger.Logger.Println(fmt.Sprintf("============测试结果报告生成:%+v", testResult))
}

func (t *UnitTest) TestDoiNameRex(regstr, soruce string) {

	defer func() {
		os.Exit(0)
	}()
	regstrs := strings.Split(regstr, "&")
	if len(regstrs) == 1 {
		//未分组时，直接匹配
		fcdarex, err2 := regexp.Compile(regstr)
		if err2 != nil {
			logger.Logger.Error(err2, regstr)
			return
		}
		r := fcdarex.MatchString(soruce)
		if !r {
			logger.Logger.Debug(errors.New("表达式验证未通过：" + regstr + "   匹配目标：" + soruce))
		}
		fmt.Println(fmt.Sprintf("匹配结果%+v", r))
		return
	}
	wg := sync.WaitGroup{}
	wg.Add(len(regstrs))
	wgResultFalse := sync.Map{}
	for _, item := range regstrs {
		go func(item string) {
			fcdarex, err2 := regexp.Compile(item)
			r := true
			if err2 != nil {
				logger.Logger.Error(err2, item)
				r = false
				wgResultFalse.Store("false", r)
			} else if !fcdarex.MatchString(soruce) {
				r = false
				wgResultFalse.Store("false", r)
			}
			fmt.Println(fmt.Sprintf("表达式%s匹配结果%+v", item, r))
			wg.Done()
		}(item)
	}
	wg.Wait()
	fmt.Println(fmt.Sprintf("匹配结果%+v", wgResultFalse))
	matchSuccess := true
	if _, h := wgResultFalse.Load("false"); h {
		matchSuccess = false
	}
	fmt.Println(fmt.Sprintf("总的匹配结果：%+v", matchSuccess))
}

func (t *UnitTest) TestIntAddrParse() {
	return
	defer func() {
		os.Exit(0)
	}()
	intAddr := ""
	addrs := strings.Split(intAddr, ":")
	if len(addrs) == 2 {
		intAddr = addrs[1]
	}
	intAddrs := strings.Split(intAddr, "/")
	if len(intAddrs) == 1 {
		logger.Logger.Error(errors.New(fmt.Sprintf("无效的intAddr：%s", intAddr)))
		return
	}
	ldinst := intAddrs[0]
	lnstr := intAddrs[1]
	v_tmpAry := strings.Split(lnstr, ".")
	if len(v_tmpAry) < 2 {
		logger.Logger.Error(errors.New(fmt.Sprintf("无效的intAddr：%s", intAddr)))
		return
	}
	doda := v_tmpAry[1:]
	doname := ""
	daname := ""
	if len(doda) == 1 {
		//只有do
		doname = doda[0]
	} else {
		doname = doda[0]
		daname = strings.Join(doda[1:], ".") //还原da
	}
	fmt.Println(fmt.Sprintf("lnstr:%s,ldinst:%s,doname:%s,daname:%s", lnstr, ldinst, doname, daname))
}