ouchn/student/student.go

package student

import (
	"bufio"
	"bytes"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"math/rand"
	"net/http"
	"os"
	"ouchn/config"
	"regexp"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/tebeka/selenium/chrome"

	"github.com/google/uuid"

	"github.com/go-vgo/robotgo"

	"github.com/syndtr/goleveldb/leveldb"

	"github.com/tebeka/selenium"
	"github.com/tidwall/gjson"
)

func GetRecord(filename string) map[string]bool {
	ret := map[string]bool{}
	fi, err := os.Open(filename)
	if err != nil {
		return ret
	}
	defer fi.Close()

	br := bufio.NewReader(fi)
	for {
		a, _, c := br.ReadLine()
		//fmt.Printf("xx:%s\n", a)
		if c == io.EOF {
			break
		}
		array := strings.Split(string(a), " ")
		if len(array) != 3 {
			continue
		}
		ret[array[0]] = true
	}
	return ret
}
func GetAcounts(filename string) ([][]string, error) {
	visited := GetRecord("record.txt")
	fi, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer fi.Close()
	ret := [][]string{}
	br := bufio.NewReader(fi)
	for {
		a, _, c := br.ReadLine()
		if c == io.EOF {
			break
		}
		array := strings.Split(string(a), ";")
		if len(array) != 3 {
			continue
		}
		if visited[array[0]] {
			//fmt.Printf("visited:%v\n", array[2])
			continue
		}
		item := []string{array[0], array[1], array[2]}
		ret = append(ret, item)
	}
	return ret, nil
}

func Displayed(by, elementName string) func(selenium.WebDriver) (bool, error) {
	return func(wd selenium.WebDriver) (ok bool, err error) {

		var el selenium.WebElement
		el, err = wd.FindElement(by, elementName)
		if err != nil {
			ok = false
			err = nil
			return
		}
		ok, err = el.IsDisplayed()
		return
	}
}

func Check415Error(wd selenium.WebDriver) error {
	e, err := wd.FindElement(selenium.ByTagName, "body")
	if err != nil {
		return err

	}

	text, _ := e.Text()
	str := "错误代码：415"
	if len(text) <= len(str) {
		return nil
	}
	if text[:len(str)] == str {
		return errors.New("访问受限")
	}
	return nil
}

func commonVerify(image string) string {
	//# 数英汉字类型
	//# 通用数英1-4位 10110
	//# 通用数英5-8位 10111
	//# 通用数英9~11位 10112
	//# 通用数英12位及以上 10113
	//# 通用数英1~6位plus 10103
	//# 定制-数英5位~qcs 9001
	//# 定制-纯数字4位 193
	//# 中文类型
	//# 通用中文字符1~2位 10114
	//# 通用中文字符 3~5位 10115
	//# 通用中文字符6~8位 10116
	//# 通用中文字符9位及以上 10117
	//# 定制-XX西游苦行中文字符 10107
	//# 计算类型
	//# 通用数字计算题 50100
	//# 通用中文计算题 50101
	//# 定制-计算题 cni 452
	config := map[string]interface{}{}
	config["image"] = image
	config["type"] = "30009"
	//config["extra"] = "click"
	config["token"] = "2EEYFMjDVpMTky-Z_BCgt_I14g4qq_D63S3NsQesfMc"
	configData, _ := json.Marshal(config)
	body := bytes.NewBuffer([]byte(configData))
	resp, err := http.Post("http://api.jfbym.com/api/YmServer/customApi", "application/json;charset=utf-8", body)
	defer resp.Body.Close()
	if err != nil {
		return ""
	}
	data, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(data), err)
	return string(data)
}

func codeGetNew(data []byte, account string, token string) string {
	name := account + ".png"
	ioutil.WriteFile(name, data, 0666)
	//fmt.Println(name)
	defer func() {
		os.Remove(name)
	}()
	/*	bodyBuffer := &bytes.Buffer{}
		bodyWriter := multipart.NewWriter(bodyBuffer)
		bodyWriter.WriteField("token", token)
		bodyWriter.WriteField("type", "local")
		fileWriter, _ := bodyWriter.CreateFormFile("file", name)
	*/
	file, _ := os.Open(name)
	defer file.Close()

	fileInfo, _ := file.Stat()
	imageSize := fileInfo.Size()
	imageData := make([]byte, imageSize)
	_, err := file.Read(imageData)
	if err != nil {
		fmt.Println("保存文件失败")
	}

	base64Data := base64.StdEncoding.EncodeToString(imageData)
	respData := commonVerify(base64Data)
	fmt.Println("验证码识别结果：", respData)

	code := gjson.Get(respData, "code").Int()
	if code != 10000 {
		fmt.Println("验证码识别失败:", gjson.Get(respData, "msg").String())
		return ""
	}
	return gjson.Get(respData, "data.data").String()
}

/*
	func codeGet(data []byte, account string, token string) (bool, string) {
		name := account + ".png"
		ioutil.WriteFile(name, data, 0666)
		defer func() {
			os.Remove(name)
		}()
		bodyBuffer := &bytes.Buffer{}
		bodyWriter := multipart.NewWriter(bodyBuffer)
		bodyWriter.WriteField("token", token)
		bodyWriter.WriteField("type", "local")
		fileWriter, _ := bodyWriter.CreateFormFile("file", name)

		file, _ := os.Open(name)
		defer file.Close()

		io.Copy(fileWriter, file)

		contentType := bodyWriter.FormDataContentType()
		bodyWriter.Close()

		resp, err := http.Post("http://www.bhshare.cn/imgcode/", contentType, bodyBuffer)
		fmt.Println("验证码识别 err :", err)
		defer resp.Body.Close()

		resp_body, _ := ioutil.ReadAll(resp.Body)
		defer resp.Body.Close()
		fmt.Printf("验证码识别响应 %s\n", resp_body)
		timesExist := gjson.GetBytes(resp_body, "times").Exists()
		//fmt.Printf("%v,%v\n", gjson.GetBytes(resp_body, "times").Exists(),gjson.GetBytes(resp_body, "times").Int())
		if !timesExist {
			return false, ""
		}
		times := gjson.GetBytes(resp_body, "times").Int()
		if times < 1 {
			return true, ""
		}
		return false, gjson.GetBytes(resp_body, "data").String()
	}
*/
var dbMutex sync.Mutex
var db *leveldb.DB

func TokenDbOpen() {
	dbMutex.Lock()
	defer dbMutex.Unlock()
	if db != nil {
		return
	}
	db, _ = leveldb.OpenFile("tokens", nil)
}

func TokenDbClear() {
	dbMutex.Lock()
	defer dbMutex.Unlock()
	if db == nil {
		return
	}
	for _, v := range config.Conf.CodeTokens {
		_ = db.Delete([]byte(v), nil)
	}
}

func TokenDbClose() {
	dbMutex.Lock()
	defer dbMutex.Unlock()
	if db == nil {
		return
	}
	db.Close()
	db = nil
}

func TokenDbGet(token string) string {
	dbMutex.Lock()
	defer dbMutex.Unlock()
	if db == nil {
		return ""
	}
	bytes, _ := db.Get([]byte(token), nil)
	return string(bytes)
}

func TokenDbPut(token string, value string) {
	dbMutex.Lock()
	defer dbMutex.Unlock()
	if db == nil {
		return
	}
	_ = db.Put([]byte(token), []byte(value), nil)
}

func codeGetHandle(data []byte, account string, tokens []string) string {
	//return "77,173|75,115|183,180"
	return codeGetNew(data, account, "")

	/*now := time.Now()
	day := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
	dayStr := fmt.Sprintf("%d", day.Unix())
	for _, token := range tokens {
		if db != nil {
			str := TokenDbGet(token)
			if str == dayStr {
				continue
			}
		}

		timesIsLimit, code := codeGet(data, account, token)

		if timesIsLimit {
			TokenDbPut(token, dayStr)
		}

		if code != "" && code[0] >= '0' && code[0] <= '9' {
			return code
		}

	}
	return ""*/
}
func StartOneStudent(usernameText string, passwordText string, realName string) (service *selenium.Service, wd selenium.WebDriver, err error) {
	defer func() {
		if r := recover(); r != nil {
			err = errors.New(fmt.Sprintf("panic error %v-%v", err, r))
		}
	}()
	service, wd, err = StartOneStudentHandle(usernameText, passwordText, usernameText)
	return service, wd, err
}

func nextPage(wd selenium.WebDriver) []selenium.WebElement {
	next, err := wd.FindElement(selenium.ByXPATH, "//button[@class='btn-next']")
	if err != nil {
		return nil
	}
	disable, _ := next.GetAttribute("disabled")
	fmt.Printf("disable:%v\n", disable)
	if disable == "disabled" || disable == "true" {
		return nil
	}
	tryClick(wd, next)
	time.Sleep(5 * time.Second)
	buttons, _ := wd.FindElements(selenium.ByXPATH, "//a[text()='去学习']")
	if len(buttons) == 0 {
		return nil
	}
	return buttons
}

func tryChangePassSure(wd selenium.WebDriver) bool {
	act, err := wd.ActiveElement()
	if err != nil {
		fmt.Printf("find active element\n")
		return false
	}
	_, err = act.FindElement(selenium.ByXPATH, "//div[contains(text(), '请尽快修改密码')]")
	if err != nil {
		fmt.Printf("find active element to change pass\n")
		return false
	}
	sure, err := act.FindElement(selenium.ByXPATH, "//span[text()='确定']")
	if err != nil {
		fmt.Printf("find active element to change pass sure\n")
		return false
	}
	err = tryClick(wd, sure)
	if err != nil {
		fmt.Printf("find active element to click\n")
		return false
	}
	return true
}

func generateMoodleSession() string {
	// 生成随机的UUID作为moodleSession值
	id := uuid.New()
	return id.String()
}
func StartOneStudentHandle(usernameText string, passwordText string, realName string) (*selenium.Service, selenium.WebDriver, error) {

	var (
		//driverPath = `C:\Users\lqzlt\AppData\Local\Google\Chrome\Application\chromedriver.exe`
		driverPath = `./chromedriver.exe`
		port       = 60002
	)

	// chrome服务
	service, err := selenium.NewChromeDriverService(driverPath, port, []selenium.ServiceOption{}...)
	if nil != err {
		return nil, nil, err
	}
	defer func() {
		//_ = service.Stop()
	}()

	// Connect to the WebDriver instance running locally.
	caps := selenium.Capabilities{"browserName": "chrome"}
	imagCaps := map[string]interface{}{
		"profile.managed_default_content_settings.cookies": 1,
		"same-site-by-default-cookies":                     2,
		"cookies-without-same-site-must-be-secure":         2,
		"search_engine_is_default":                         false,
	}
	chromeCaps := chrome.Capabilities{
		Prefs:           imagCaps,
		Path:            "",
		ExcludeSwitches: []string{"enable-automation"},
		Args: []string{
			"--start-maximized",
			"--disable-blink-features=AutomationControlled",
			//"--no-sandbox",
			//"--disable-gpu-sandbox",
			"--accept-encoding=gzip, deflate, br",
			"--accept-language=zh-CN,zh;q=0.9",
			//	"--cache-control=max-age=0",
			//"--abc=d",
			//"--load-extention=D:\\sql2struct",
			//fmt.Sprintf("--moodleSession=%s", generateMoodleSession()),
			//"--upgrade-insecure-requests=1",
			"--connection=keep-alive",
			"--accept=text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
			"--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36",
		},
	}

	caps.AddChrome(chromeCaps)

	wd, err := selenium.NewRemote(caps, fmt.Sprintf("http://localhost:%d/wd/hub", port))
	if err != nil {
		return service, nil, errors.New(fmt.Sprintf("connect to the webDriver failed:%v\n", err))
	}
	//wd.MaximizeWindow("test")
	defer func() {
		//_ = wd.Close()
	}()

	//wd.Get("file:///C:/Users/lqzlt/Desktop/1.html")
	//time.Sleep(1*time.Second)
	//handleQuestionWebTest(wd)
	//time.Sleep(1000*time.Second)
	//return service, wd, nil

	//err = wd.Get("https://menhu.pt.ouchn.cn/")
	//err = wd.Get("https://iam.pt.ouchn.cn/am/UI/Login?realm=%2F&service=initService&goto=https%3A%2F%2Fiam.pt.ouchn.cn%2Fam%2Foauth2%2Fauthorize%3Fservice%3DinitService%26response_type%3Dcode%26client_id%3D345fcbaf076a4f8a%26scope%3Dall%26redirect_uri%3Dhttps%253A%252F%252Fmenhu.pt.ouchn.cn%252Fouchnapp%252Fwap%252Flogin%252Findex%26decision%3DAllow")
	err = wd.Get("https://iam.pt.ouchn.cn/am/UI/Login")

	if err != nil {
		return service, wd, err
	}
	if config.Conf.Timeout == 0 {
		config.Conf.Timeout = 20
	}
	if config.Conf.QuestionCount == 0 {
		config.Conf.QuestionCount = 2
	}
	//time.Sleep(2 * time.Second)
	fmt.Printf("查找登录按钮\n")

	// 进入登录页面
	err = wd.WaitWithTimeout(Displayed(selenium.ByID, "form_button"), time.Duration(config.Conf.Timeout)*time.Second)
	if err != nil {
		return service, wd, errors.New(fmt.Sprintf("获取登录页面失败：%v\n", err))
	}
	fmt.Printf("开始获取用户名按钮\n")
	username, err := wd.FindElement(selenium.ByID, "loginName")
	if err != nil {
		return service, wd, errors.New(fmt.Sprintf("获取用户名按钮：%v\n", err))
	}
	fmt.Printf("开始获取密码按钮\n")
	password, err := wd.FindElement(selenium.ByID, "password")
	if err != nil {
		return service, wd, errors.New(fmt.Sprintf("获取密码按钮：%v\n", err))
	}
	fmt.Printf("开始获取登录按钮\n")
	submit, err := wd.FindElement(selenium.ByID, "form_button")
	if err != nil {
		return service, wd, errors.New(fmt.Sprintf("获取登录按钮：%v\n", err))
	}
	fmt.Println("填充用户名：", usernameText)
	err = username.SendKeys(usernameText)
	if err != nil {
		return service, wd, errors.New(fmt.Sprintf("填充用户名：%v\n", err))
	}

	fmt.Println("填充密码：", passwordText)
	err = password.SendKeys(passwordText)
	if err != nil {
		return service, wd, errors.New(fmt.Sprintf("填充密码：%v\n", err))
	}
	/*fmt.Printf("开始获取验证码按钮\n")
	verifyCode, err := wd.FindElement(selenium.ByID, "captcha")
	if err != nil {
		return service, wd, errors.New(fmt.Sprintf("获取验证码按钮失败：%v\n", err))
	}

	fmt.Printf("点击验证码按钮\n")
	err = verifyCode.Click()
	if err != nil {
		return service, wd, errors.New(fmt.Sprintf("点击验证码按钮失败：%v\n", err))
	}*/
	err = tryClick(wd, submit)
	if err != nil {
		return service, wd, errors.New(fmt.Sprintf("点击登录：%v\n", err))
	}
	innerHeight, err := wd.ExecuteScript("return window.innerHeight", nil)
	if err != nil {

	}
	//fmt.Println("INNERhEIG:", innerHeight)
	fheight := innerHeight.(float64)
	aheight := int(fheight)
	//fmt.Println("addressBarHeight:", innerHeight, aheight)

	outerHeight, err := wd.ExecuteScript("return window.outerHeight", nil)
	if err != nil {

	}
	fheight = outerHeight.(float64)
	aheight = int(fheight) - aheight

	fmt.Println("addressBarHeight:", innerHeight, outerHeight, aheight)

	if config.Conf.CodeManual {
		time.Sleep(1 * time.Hour)
		/*count := 0
		for count < 60 {
			time.Sleep(1 * time.Second)
			value, _ := verifyCode.GetAttribute("value")
			if len(value) < 4 {
				continue
			}
			break
		}
		if count >= 60 {
			return service, wd, errors.New("未输入验证码")
		}*/
	} else {
		time.Sleep(1 * time.Second)
		// //div[@class='geetest_box_f3dbc8bc geetest_box']
		//image, err := wd.FindElement(selenium.ByXPATH, "//img[@id='kaptchaImage']")
		// time.Sleep(10 * time.Second)
		fmt.Println("获取验证码")

		err = wd.WaitWithTimeout(Displayed(selenium.ByXPATH, "/html/body/div[4]/div[1]/div[1]"), time.Duration(config.Conf.Timeout)*time.Second)
		if err != nil {
			return service, wd, errors.New("验证码获取失败1111111")
		}

		image, err := wd.FindElement(selenium.ByXPATH, "/html/body/div[4]/div[1]/div[1]")
		if err != nil {
			return service, wd, errors.New("验证码获取失败")
		}
		fmt.Println("验证码获取成功")
		data, _ := image.Screenshot(false)
		code := codeGetHandle(data, usernameText, config.Conf.CodeTokens)
		if code == "" {
			return service, wd, errors.New("验证码识别失败\n")
		}

		//codeData := gjson.Get(code, "data").String()
		fmt.Println("CODE data:", code)
		codeList := strings.Split(code, "|")
		for _, v := range codeList {
			codeX := strings.Split(v, ",")
			if len(codeX) < 2 {
				break
			}

			x, _ := strconv.Atoi(codeX[0])
			y, _ := strconv.Atoi(codeX[1])
			point, _ := image.Location()
			robotgo.Move(x+point.X, y+point.Y+aheight)
			robotgo.Click("left")
			time.Sleep(1 * time.Second)
		}
		/*time.Sleep(time.Minute)
		os.Exit(1)*/

		/*err = verifyCode.SendKeys(code)
		if err != nil {
			return service, wd, errors.New(fmt.Sprintf("填充验证码：%v\n", err))
		}*/
	}

	imageSubmitButton, err := wd.FindElement(selenium.ByXPATH, "/html/body/div[4]/div[1]/div[1]/div[2]/div/div/div[2]")

	//err = submit.Click()
	err = tryClick(wd, imageSubmitButton)
	if err != nil {
		return service, wd, errors.New(fmt.Sprintf("点击提交失败：%v\n", err))
	}
	//time.Sleep(1200 *time.Second)
	//return service, wd, errors.New("登录测试")

	time.Sleep(2 * time.Second)
	tryChangePassSure(wd)
	// 进入学生主页
	err = wd.WaitWithTimeout(Displayed(selenium.ByXPATH, "//a[text()='去学习']"), time.Duration(config.Conf.Timeout)*time.Second)
	if err != nil {

		if !tryChangePassSure(wd) {
			return service, wd, errors.New(fmt.Sprintf("进入学生主页失败:%v\n", err))
		}
		time.Sleep(2 * time.Second)
		err = wd.WaitWithTimeout(Displayed(selenium.ByXPATH, "//a[text()='去学习']"), time.Duration(config.Conf.Timeout)*time.Second)
		if err != nil {
			fmt.Printf("find active element to find page\n")
			return service, wd, errors.New(fmt.Sprintf("进入学生主页失败:%v\n", err))
		}

	}
	fmt.Printf("进入学生主页\n")

	buttons, _ := wd.FindElements(selenium.ByXPATH, "//a[text()='去学习']")
	currentWindow, err := wd.CurrentWindowHandle()
	if err != nil {
		return service, wd, errors.New(fmt.Sprintf("获取当前窗口失败:%v\n", err))
	}
	for buttons != nil {
		for i := 0; i < len(buttons); i++ {
			button := buttons[i]
			text, _ := button.Text()
			if text != "去学习" {
				continue
			}

			if true {
				ptag, err := button.FindElement(selenium.ByXPATH, "./preceding-sibling::div/p")
				if err != nil {
					fmt.Printf("查找课程失败:%v\n", err)
					return service, wd, err
				}
				txt, _ := ptag.Text()
				array := strings.Split(txt, " ")
				if len(array) > 1 {
					txt = array[1]
				}
				txt = strings.TrimSpace(txt)

				if !checkCourseExist(config.Conf.Courses, txt) {
					fmt.Println("不执行课程:", txt)

					continue
				}
				fmt.Println("要执行课程:", txt)
			}

			//button.Click()
			tryClick(wd, button)

			//time.Sleep(60*time.Second)
			count := 0
			handled := ""
			// 等待新页面弹出
			for count < 5 {
				time.Sleep(1 * time.Second)
				handles, _ := wd.WindowHandles()
				if len(handles) > 1 {
					handled = handles[len(handles)-1]
					//
					wd.SwitchWindow(handled)
					break
				}
				count++
			}
			if count > 5 {
				continue
			}

			if err := Check415Error(wd); err != nil {
				return service, wd, err
			}
			// 处理课程

			//time.Sleep(4000 * time.Second)
			err = CourseHandle(wd, realName)
			if err != nil {
				return service, wd, err
			}
			//fmt.Printf("xxxxerr:%v\n", err)
			// 关闭当前课程窗口
			wd.CloseWindow(handled)
			// 切换到学生主页窗口（有进入学习按钮的窗口）
			wd.SwitchWindow(currentWindow)
			runtime.GC()
		}
		buttons = nextPage(wd)
	}

	return service, wd, err
}

// 等待url变化
func waitUrl(wd selenium.WebDriver, url1 string, url2 string, count int) string {
	for count >= 0 {
		time.Sleep(100 * time.Millisecond)
		url, _ := wd.CurrentURL()
		if url != url1 && url != url2 {
			return url
		}
		count--
	}
	return ""
}

func getCookies(wd selenium.WebDriver) (string, error) {
	cookies, err := wd.GetCookies()
	if err != nil {
		return "", errors.New(fmt.Sprintf("获取cookie 失败，%v\n", err))
	}
	if len(cookies) == 0 {
		return "", errors.New(fmt.Sprintf("获取cookie 失败，%v\n", "cookie为空"))
	}
	ret := ""
	for _, v := range cookies {
		item := fmt.Sprintf("%s=%s", v.Name, v.Value)
		if ret == "" {
			ret = item
			continue
		}
		ret = ret + ";"
		ret = ret + item
	}
	return ret, nil
}

func checkCourseExist(courses []string, course string) bool {
	for _, v := range courses {
		if v == course {
			return true
		}
	}
	return false
}

type ElementInfo struct {
	Element selenium.WebElement
}

type AnswerInfo struct {
	Text  string
	Radio *ElementInfo
	Ptag  *ElementInfo
}

type QuestionInfo struct {
	Text          string
	Tag           int
	Number        string
	AnswerArray   []*AnswerInfo
	ChoosedAnswer []int
}

func GenerateRandom(length int) int {
	time.Sleep(1 * time.Microsecond)
	rand.Seed(time.Now().UnixNano())
	return rand.Intn(length)
}

// 计算题
func shortAnswer(question QuestionInfo, questionM map[string][]string) error {
	if len(question.AnswerArray) == 0 {
		return errors.New(fmt.Sprintf("%s 选项为空", question.Text))
	}
	//fmt.Println("收集的答案000000000000000000000000：", questionM)
	str := TrimSpace(question.Text)
	str = ParseHan(str)
	str = fmt.Sprintf("%d-", question.Tag) + str
	//fmt.Println("问答题目1111111111111111111111111：", str)
	answerstrs, _ := questionM[str]
	//fmt.Println("问答答案2222222222222222222222222：", answerstrs)
	if len(answerstrs) == 0 {
		str = strings.TrimRight(str, "分")
		answerstrs, _ = questionM[str]
		if len(answerstrs) == 0 {
			return errors.New("没有答案")
		}
	}
	index := GenerateRandom(len(answerstrs))
	question.AnswerArray[0].Ptag.Element.Clear()
	question.AnswerArray[0].Ptag.Element.SendKeys(answerstrs[index])
	//fmt.Println("问答选择答案2222222222222222222222222：", answerstrs[index])
	time.Sleep(500 * time.Millisecond)
	return nil
}
func tryClick(wd selenium.WebDriver, element selenium.WebElement) error {

	array := []interface{}{element}
	_, err := wd.ExecuteScript("arguments[0].click()", array)
	if err != nil {
		fmt.Printf("按钮点击失败:%v\n", err)
	}

	return err

}

var questionTagM = map[int]string{
	1: "单选题",
	2: "判断题",
	3: "多选题",
	4: "计算题/简答题",
}

func getTagName(tag int) string {
	ret := questionTagM[tag]
	if ret == "" {
		return "未知题型"
	}
	return ret
}

// 题目号个数-本来就随机的题数， 再随机生成错误个数， 根据错误个数随机选择题号
func getRandErrorNumber(emptyCount int, originNumber map[int]bool, maxNumber int) map[int]bool {

	questionCount := len(originNumber) - emptyCount
	if questionCount <= 2 || maxNumber <= 2 {
		return map[int]bool{}
	}
	count := 0
	if questionCount < 5 {
		count = 1
	} else {
		rand.Seed(time.Now().UnixNano())
		count = rand.Intn(3)
		if count == 0 {
			count = 1
		}
	}

	m := map[int]bool{}
	for len(m) < count {
		number := rand.Intn(maxNumber + 1)
		if originNumber[number] {
			m[number] = true
		}
	}
	return m

}

func random(count int) int {
	rand.Seed(time.Now().UnixNano())
	return rand.Intn(count)
}

func chooseAnswer2(wd selenium.WebDriver, questions []QuestionInfo, questionM map[string][]string) error {
	if config.Conf.NewStyle {
		return chooseAnswer2New(wd, questions, questionM)
	}
	emptyCount := 0
	if false {
		emptyCount = 3
	}
	// 选择或判断题目号
	originNumber := map[int]bool{}
	// 选择或判断最大题目号
	maxNumber := 0
	// 先收集答案
	for i, _ := range questions {
		questions[i].ChoosedAnswer = []int{}
		fmt.Printf("\n题目类型:%s\n", getTagName(questions[i].Tag))
		fmt.Printf("题目:%s\n", questions[i].Text)

		for _, v := range questions[i].AnswerArray {
			fmt.Printf("选项:%s\n", v.Text)
		}
		if questions[i].Tag == 4 {
			shortAnswer(questions[i], questionM)
			continue
		}

		if len(questions[i].AnswerArray) == 0 {
			return errors.New(fmt.Sprintf("%s 选项为空", questions[i].Text))

		}
		str := TrimSpace(questions[i].Text)
		str = ParseHan(str)
		//str = trimQuestionPrefix(str)
		str = fmt.Sprintf("%d-", questions[i].Tag) + str

		answerstrs, _ := questionM[str]

		if len(answerstrs) == 0 || answerstrs[0] == "" {
			emptyCount++
			if emptyCount > config.Conf.QuestionCount {
				return errors.New(fmt.Sprintf("%s 题库答案为空", questions[i].Text))
			}
			fmt.Printf("%s 题库答案为空, 空答案数小于%d，进行随机选择", questions[i].Text, config.Conf.QuestionCount)
			questions[i].ChoosedAnswer = append(questions[i].ChoosedAnswer, random(len(questions[i].AnswerArray)))
			continue

		}
		find := 0
		// 单选
		if questions[i].Tag == 1 {
			//answerstrs = answerstrs[:1]
		}
		if questions[i].Tag == 3 {
			//fmt.Printf("*****************************************:%s,%v\n", questions[i].Text,answerstrs)
		}

		for _, answerstr := range answerstrs {
			if answerstr == "" {
				continue
			}
			for j, v := range questions[i].AnswerArray {
				if questions[i].Tag == 1 && find > 0 {
					break
				}
				right := false
				if questions[i].Tag == 3 {
					right = TrimSpace(answerstr) == TrimSpace(v.Text)
				} else {
					right = tryEqual(answerstr, TrimSpace(v.Text))
				}

				if right {
					fmt.Printf("选择答案:%s\n", answerstr)
					questions[i].ChoosedAnswer = append(questions[i].ChoosedAnswer, j)
					originNumber[i] = true
					maxNumber = i
					//ppp, _ := v.Radio.Element.FindElement(selenium.ByXPATH, "./following-sibling::span")
					//txt, _ := ppp.Text()
					//fmt.Printf("kkkkkkkkkkkkkkkkkkk:%s,%s\n", txt, answerstr)
					if questions[i].Tag == 3 {
						//time.Sleep(10*time.Second)
					}
					find++
					//time.Sleep(1 * time.Second)
					break
				}
			}
		}

		if find == 0 {
			emptyCount++
			if emptyCount > config.Conf.QuestionCount {
				return errors.New(fmt.Sprintf("%s 题库答案为空2", questions[i].Text))
			}
			fmt.Printf("未找到匹配答案,题库中的答案有:%v\n", answerstrs)
			questions[i].ChoosedAnswer = append(questions[i].ChoosedAnswer, random(len(questions[i].AnswerArray)))
			continue
			//return errors.New(fmt.Sprintf("%s 未找到匹配答案", questions[i].Text))
		}
	}

	// 选择答案, 先随机生成需故意填错的错误题号
	errorNumber := getRandErrorNumber(emptyCount, originNumber, maxNumber)
	defer func() {
		errorNumber = nil
	}()

	for i, _ := range questions {
		if len(questions[i].ChoosedAnswer) == 0 {
			continue
		}
		// 不需要故意填错
		if !errorNumber[i] {
			for _, v := range questions[i].ChoosedAnswer {
				err := tryClick(wd, questions[i].AnswerArray[v].Radio.Element)
				if err != nil {
					fmt.Printf("点击答案错误:%v\n", err)
					return err
				}
				time.Sleep(1 * time.Second)
			}
			continue
		}
		// 需要故意填错时，随机选择错误答案

		// 正确答案map
		cm := map[int]bool{}
		for _, j := range questions[i].ChoosedAnswer {
			cm[j] = true
		}

		// 可供选择的错误答案
		array := []int{}
		for j, _ := range questions[i].AnswerArray {
			if !cm[j] {
				array = append(array, j)
			}
		}

		// 随机生成索引
		arrayIndex := random(len(array))

		// 获取错误答案索引
		errorIndex := 0
		if len(array) > 0 {
			errorIndex = array[arrayIndex]
		} else {
			errorIndex = random(len(questions[i].AnswerArray))
		}
		err := tryClick(wd, questions[i].AnswerArray[errorIndex].Radio.Element)
		if err != nil {
			fmt.Printf("点击答案错误:%v\n", err)
			return err
		}
		time.Sleep(1 * time.Second)

	}

	return nil
}

func chooseAnswer2New(wd selenium.WebDriver, questions []QuestionInfo, questionM map[string][]string) error {
	emptyCount := 0
	if false {
		emptyCount = 3
	}
	// 选择或判断题目号
	originNumber := map[int]bool{}
	// 选择或判断最大题目号
	maxNumber := 0
	// 先收集答案
	for i, _ := range questions {
		questions[i].ChoosedAnswer = []int{}
		fmt.Printf("\n题目类型:%s\n", getTagName(questions[i].Tag))
		fmt.Printf("题目:%s\n", questions[i].Text)

		for _, v := range questions[i].AnswerArray {
			fmt.Printf("选项:%s\n", v.Text)
		}
		if questions[i].Tag == 4 {
			shortAnswer(questions[i], questionM)
			continue
		}

		if len(questions[i].AnswerArray) == 0 {
			return errors.New(fmt.Sprintf("%s 选项为空", questions[i].Text))

		}
		str := TrimSpace(questions[i].Text)
		str = ParseHan(str)
		//str = trimQuestionPrefix(str)
		str = fmt.Sprintf("%d-", questions[i].Tag) + str

		answerstrs, _ := questionM[str]

		if len(answerstrs) == 0 || answerstrs[0] == "" {
			emptyCount++
			if emptyCount > config.Conf.QuestionCount {
				return errors.New(fmt.Sprintf("%s 题库答案为空", questions[i].Text))
			}
			fmt.Printf("%s 题库答案为空, 空答案数小于%d，进行随机选择", questions[i].Text, config.Conf.QuestionCount)
			questions[i].ChoosedAnswer = append(questions[i].ChoosedAnswer, random(len(questions[i].AnswerArray)))
			continue

		}
		find := 0
		// 单选
		if questions[i].Tag == 1 {
			//answerstrs = answerstrs[:1]
		}
		if questions[i].Tag == 3 {
			//fmt.Printf("*****************************************:%s,%v\n", questions[i].Text,answerstrs)
		}

		for _, answerstr := range answerstrs {
			if answerstr == "" {
				continue
			}
			for j, _ := range questions[i].AnswerArray {
				if questions[i].Tag == 1 && find > 0 {
					break
				}
				right := false
				if questions[i].Tag == 1 || questions[i].Tag == 3 {
					//right = TrimSpace(answerstr) == TrimSpace(v.Text)
					right = j == SelectAnswerFlagMap[answerstr]

				} else {
					//right = tryEqual(answerstr, TrimSpace(v.Text))
					right = j == JudgeAnswerMap[answerstr]
				}

				if right {
					fmt.Printf("选择答案:%s\n", answerstr)
					questions[i].ChoosedAnswer = append(questions[i].ChoosedAnswer, j)
					originNumber[i] = true
					maxNumber = i
					//ppp, _ := v.Radio.Element.FindElement(selenium.ByXPATH, "./following-sibling::span")
					//txt, _ := ppp.Text()
					//fmt.Printf("kkkkkkkkkkkkkkkkkkk:%s,%s\n", txt, answerstr)
					if questions[i].Tag == 3 {
						//time.Sleep(10*time.Second)
					}
					find++
					//time.Sleep(1 * time.Second)
					break
				}
			}
		}

		if find == 0 {
			emptyCount++
			if emptyCount > config.Conf.QuestionCount {
				return errors.New(fmt.Sprintf("%s 题库答案为空2", questions[i].Text))
			}
			fmt.Printf("未找到匹配答案,题库中的答案有:%v\n", answerstrs)
			questions[i].ChoosedAnswer = append(questions[i].ChoosedAnswer, random(len(questions[i].AnswerArray)))
			continue
			//return errors.New(fmt.Sprintf("%s 未找到匹配答案", questions[i].Text))
		}
	}

	// 选择答案, 先随机生成需故意填错的错误题号
	errorNumber := getRandErrorNumber(emptyCount, originNumber, maxNumber)
	defer func() {
		errorNumber = nil
	}()

	for i, _ := range questions {
		if len(questions[i].ChoosedAnswer) == 0 {
			continue
		}
		// 不需要故意填错
		if !errorNumber[i] {
			for _, v := range questions[i].ChoosedAnswer {
				err := tryClick(wd, questions[i].AnswerArray[v].Radio.Element)
				if err != nil {
					fmt.Printf("点击答案错误:%v\n", err)
					return err
				}
				time.Sleep(1 * time.Second)
			}
			continue
		}
		// 需要故意填错时，随机选择错误答案

		// 正确答案map
		cm := map[int]bool{}
		for _, j := range questions[i].ChoosedAnswer {
			cm[j] = true
		}

		// 可供选择的错误答案
		array := []int{}
		for j, _ := range questions[i].AnswerArray {
			if !cm[j] {
				array = append(array, j)
			}
		}

		// 随机生成索引
		arrayIndex := random(len(array))

		// 获取错误答案索引
		errorIndex := 0
		if len(array) > 0 {
			errorIndex = array[arrayIndex]
		} else {
			errorIndex = random(len(questions[i].AnswerArray))
		}
		err := tryClick(wd, questions[i].AnswerArray[errorIndex].Radio.Element)
		if err != nil {
			fmt.Printf("点击答案错误:%v\n", err)
			return err
		}
		time.Sleep(1 * time.Second)

	}

	return nil
}

func chooseAnswer(wd selenium.WebDriver, questions []QuestionInfo, questionM map[string][]string) error {
	// 正常选择答案
	if !config.Conf.QuestionRandom {
		return chooseAnswer2(wd, questions, questionM)
	}
	// 全部随机选
	for i, _ := range questions {
		fmt.Printf("\n题目类型:%s\n", getTagName(questions[i].Tag))
		fmt.Printf("题目:%s\n", questions[i].Text)

		for _, v := range questions[i].AnswerArray {
			fmt.Printf("选项:%s\n", v.Text)
		}
		if questions[i].Tag == 4 {
			shortAnswer(questions[i], questionM)
			continue
		}

		if len(questions[i].AnswerArray) == 0 {
			return errors.New(fmt.Sprintf("%s 选项为空", questions[i].Text))
		}
		str := TrimSpace(questions[i].Text)
		str = ParseHan(str)
		//str = trimQuestionPrefix(str)
		str = fmt.Sprintf("%d-", questions[i].Tag) + str

		answerstrs, _ := questionM[str]

		if len(answerstrs) == 0 || answerstrs[0] == "" {
			er := tryClick(wd, questions[i].AnswerArray[random(len(questions[i].AnswerArray))].Radio.Element)
			if er != nil {
				fmt.Printf("radio click:%v\n", er)
				return er
			}
			time.Sleep(1 * time.Second)
			continue

		}
		find := 0
		// 单选
		if questions[i].Tag == 1 {
			//answerstrs = answerstrs[:1]
		}
		if questions[i].Tag == 3 {
			//fmt.Printf("*****************************************:%s,%v\n", questions[i].Text,answerstrs)
		}

		for _, answerstr := range answerstrs {
			if answerstr == "" {
				continue
			}
			for _, v := range questions[i].AnswerArray {
				if questions[i].Tag == 1 && find > 0 {
					break
				}
				right := false
				if questions[i].Tag == 3 {
					right = TrimSpace(answerstr) == TrimSpace(v.Text)
				} else {
					right = tryEqual(answerstr, TrimSpace(v.Text))
				}
				if right {

					fmt.Printf("选择答案:%s\n", answerstr)

					er := tryClick(wd, v.Radio.Element)
					if er != nil {
						fmt.Printf("radio click:%v\n", er)
						return er
					}
					//ppp, _ := v.Radio.Element.FindElement(selenium.ByXPATH, "./following-sibling::span")
					//txt, _ := ppp.Text()
					//fmt.Printf("kkkkkkkkkkkkkkkkkkk:%s,%s\n", txt, answerstr)
					if questions[i].Tag == 3 {
						//time.Sleep(10*time.Second)
					}
					find++
					time.Sleep(1 * time.Second)
					break
				}
			}
		}

		if find == 0 {
			er := tryClick(wd, questions[i].AnswerArray[random(len(questions[i].AnswerArray))].Radio.Element)
			if er != nil {
				fmt.Printf("radio click:%v\n", er)
				return er
			}
			//fmt.Printf("未找到匹配答案,题库中的答案有:%v\n", answerstrs)
			continue
			//return errors.New(fmt.Sprintf("%s 未找到匹配答案", questions[i].Text))
		}
	}
	return nil
}

func getCourseId(src string) string {
	array := strings.Split(src, "/")
	if len(array) < 5 {
		return ""
	}
	return array[4]
}

type CourseModule struct {
	Name     string
	ModuleId string
}

func getUploadIds(moduleId string, cookie string) ([]int64, error) {
	url := fmt.Sprintf("https://lms.ouchn.cn/api/activities/%s", moduleId)
	request, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}

	request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	request.Header.Set("Cookie", cookie)
	request.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.81 Safari/537.36")
	//request.Header.Set("Host", "chengdu.ouchn.cn")

	client := http.Client{}
	resp, err := client.Do(request)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	respBytes, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	ret := []int64{}
	uploads := gjson.GetBytes(respBytes, "uploads").Array()
	for _, upload := range uploads {
		id := upload.Get("id").Int()
		ret = append(ret, id)
	}

	return ret, nil
}

func getCourseModules(courceId string, cookie string, specialCourse bool) ([]CourseModule, error) {
	url := fmt.Sprintf("https://lms.ouchn.cn/api/courses/%s/modules", courceId)
	request, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}

	request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	request.Header.Set("Cookie", cookie)
	request.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.81 Safari/537.36")
	//request.Header.Set("Host", "chengdu.ouchn.cn")

	client := http.Client{}
	resp, err := client.Do(request)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	respBytes, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	ret := []CourseModule{}
	mos := gjson.GetBytes(respBytes, "modules").Array()
	for _, mo := range mos {
		if (len(mo.Get("syllabuses").Array())) == 0 && !specialCourse {
			continue
		}
		item := CourseModule{}
		item.ModuleId = fmt.Sprintf("%d", mo.Get("id").Int())
		item.Name = mo.Get("name").String()
		ret = append(ret, item)
	}

	return ret, nil
}

type ModuleSubInfo struct {
	Name       string
	Id         string
	Stype      string
	SyllabusId int64
	Type       int // 1 page,2 vedio
}

type ModuleInfo struct {
	TxtInfos   []ModuleSubInfo
	ExamInfos  []ModuleSubInfo
	VedioInfos []ModuleSubInfo
}

func GetModuleInfo(courseId string, moduleId string, cookie string) (*ModuleInfo, error) {
	url := fmt.Sprintf("https://lms.ouchn.cn/api/course/%s"+
		"/all-activities?module_ids=[%s]"+
		"&activity_types=learning_activities,exams,classrooms,"+
		"live_records,rollcalls&no-loading-animation=true", courseId, moduleId)
	request, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}

	request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	request.Header.Set("Cookie", cookie)
	request.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.81 Safari/537.36")
	//request.Header.Set("Host", "chengdu.ouchn.cn")

	client := http.Client{Timeout: 60 * time.Second}
	resp, err := client.Do(request)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	respBytes, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	ret := &ModuleInfo{}
	// 试题
	exams := []ModuleSubInfo{}
	examsArray := gjson.GetBytes(respBytes, "exams").Array()
	for _, v := range examsArray {
		item := ModuleSubInfo{}
		item.Name = v.Get("title").String()
		unikey := v.Get("unique_key").String()
		array := strings.Split(unikey, "-")
		if len(array) < 2 {
			continue
		}
		item.Id = array[1]
		exams = append(exams, item)
	}

	// 文档和视频
	texts := []ModuleSubInfo{}
	vedios := []ModuleSubInfo{}
	array := gjson.GetBytes(respBytes, "learning_activities").Array()
	for _, v := range array {
		stype := v.Get("type").String()
		syllabusId := v.Get("syllabus_id").Int()
		item := ModuleSubInfo{}
		item.Name = v.Get("title").String()
		item.SyllabusId = syllabusId
		item.Stype = stype
		unikey := v.Get("unique_key").String()
		array := strings.Split(unikey, "-")
		if len(array) < 2 {
			continue
		}
		item.Id = array[1]
		if stype == "page" {
			item.Type = 1
			texts = append(texts, item)
			vedios = append(vedios, item)
		} else if stype == "online_video" || (stype == "web_link" && strings.Contains(item.Name, "视频")) || stype == "material" {
			index := -1
			item.Type = 2
			for i := len(vedios) - 1; i >= 0; i-- {
				if item.SyllabusId == vedios[i].SyllabusId {
					index = i
					break
				}
			}
			if index == -1 || index == len(vedios)-1 {
				vedios = append(vedios, item)
			} else {
				tmp := []ModuleSubInfo{}
				tmp = append(tmp, vedios[:index+1]...)
				tmp = append(tmp, item)
				tmp = append(tmp, vedios[index+1:]...)
				vedios = tmp

			}

		}
	}
	ret.ExamInfos = exams
	ret.TxtInfos = texts
	ret.VedioInfos = vedios
	return ret, nil
}

func MakeTxtUrl(courseId string, moduleId string, id string) string {
	return fmt.Sprintf("https://lms.ouchn.cn/course/%s/learning-activity/full-screen#/%s", courseId, id)
}
func MakeExamUrl(courseId string, moduleId string, id string) string {
	return fmt.Sprintf("https://lms.ouchn.cn/course/%s/learning-activity/full-screen#/exam/%s", courseId, id)
}

func VedioCompleteHandle(cookie string, id string) error {

	count := 0
	start, end := int64(0), int64(1000)
	for count < 5 {
		finish, err := VedioComplete(cookie, id, start, end)
		if err != nil {
			return err
		}
		if finish < 100 {
			start = end
			end += 1000
			count++
			continue
		}
		return nil
	}
	return errors.New("视频处理失败")
}

func VedioComplete(cookie string, id string, start, end int64) (int64, error) {
	url := fmt.Sprintf("https://lms.ouchn.cn/api/course/activities-read/%s", id)
	//fmt.Printf("get sections:%v,%v\n", str, cookie)
	m := map[string]interface{}{
		"start": start,
		"end":   end,
	}
	content, _ := json.Marshal(m)
	reader := bytes.NewReader(content)
	fmt.Printf("post data:%s\n", content)
	request, err := http.NewRequest("POST", url, reader)
	if err != nil {
		return 0, err
	}

	request.Header.Set("Content-Type", "application/json")
	request.Header.Set("Cookie", cookie)
	request.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.81 Safari/537.36")

	client := http.Client{}
	resp, err := client.Do(request)
	if err != nil {
		return 0, err
	}
	defer resp.Body.Close()

	respBytes, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return 0, err
	}
	fmt.Printf("get bytes:%s\n", respBytes)
	if gjson.GetBytes(respBytes, "activity_id").Int() == 0 {
		return 0, errors.New("视频处理失败")
	}
	str := gjson.GetBytes(respBytes, "data").Get("completeness").String()
	if str == "full" {
		return 100, nil
	}
	if str == "part" {
		return 10, nil
	}
	return gjson.GetBytes(respBytes, "data").Get("completeness").Int(), nil
}

func examHandleJump(wd selenium.WebDriver, courseId, moduleId, id string) error {
	curl, _ := wd.CurrentURL()
	fmt.Printf("url1:%s\n", curl)
	url := MakeExamUrl(courseId, moduleId, id)
	wd.Get(url)
	time.Sleep(2 * time.Second)
	curl, _ = wd.CurrentURL()
	fmt.Printf("url2:%s\n", curl)
	return nil
}

func examHandleStart(wd selenium.WebDriver) error {
	// 点击答题按钮
	err := wd.WaitWithTimeout(Displayed(selenium.ByXPATH, "//a[@class='button button-green take-exam ng-scope']"), time.Duration(config.Conf.Timeout)*time.Second)
	if err != nil && strings.Contains(err.Error(), "timeout") {
		curl, _ := wd.CurrentURL()
		fmt.Printf("再次尝试：%s\n", curl)
		wd.Get(curl)
		time.Sleep(2 * time.Second)
		err = wd.WaitWithTimeout(Displayed(selenium.ByXPATH, "//a[@class='button button-green take-exam ng-scope']"), time.Duration(config.Conf.Timeout)*time.Second)
	}
	if err != nil {
		return err
	}
	button, err := wd.FindElement(selenium.ByXPATH, "//a[@class='button button-green take-exam ng-scope']")
	if err != nil {
		return err
	}
	//button.Click()
	tryClick(wd, button)
	fmt.Printf("点击答题按钮\n")

	time.Sleep(2 * time.Second)
	active, _ := wd.ActiveElement()

	// 勾选同意框
	chbox, err := active.FindElement(selenium.ByXPATH, "//input[@type='checkbox' and @name='confirm']")
	if err != nil {
		fmt.Printf("未找到同意勾选框：%v\n", err)
		return err
	}
	//err = chbox.Click()
	err = tryClick(wd, chbox)
	if err != nil {
		fmt.Printf("同意勾选框：%v\n", err)
		return err
	}
	fmt.Printf("勾选同意框\n")

	time.Sleep(1 * time.Second)
	// 点击答题
	button, err = active.FindElement(selenium.ByXPATH, "//button[text()='开始答题' or text()='继续答题']")
	if err != nil {
		fmt.Printf("未找到开始答题按钮：%v\n", err)
		return err
	}
	//err = button.Click()
	err = tryClick(wd, button)
	if err != nil {
		fmt.Printf("开始答题按钮：%v\n", err)
		return err
	}
	fmt.Printf("弹窗中点击答题按钮\n")

	time.Sleep(3 * time.Second)
	return nil
}

func examHandleSimpleAnswer(wd selenium.WebDriver) ([]QuestionInfo, error) {
	p, err := wd.FindElement(selenium.ByXPATH, "//div[@class='exam-subjects']/ol[@class='subjects-jit-display']")
	if err != nil {
		return nil, err
	}
	path := fmt.Sprintf("./following-sibling::li[@class='subject ng-scope short_answer']")
	ret := []QuestionInfo{}
	count := 0
	for {
		if count == 0 {
			path = fmt.Sprintf("./li[@class='subject ng-scope short_answer']")
		}
		p, err = p.FindElement(selenium.ByXPATH, path)
		if err != nil {
			break
		}
		div, err := p.FindElements(selenium.ByXPATH, "./div/div/div/span/p")
		if err != nil {
			fmt.Printf("简答题目:%v\n", err)
			break
		}

		txt, err := div[len(div)-1].Text()
		fmt.Printf("简答题:%s,%v\n", txt, err)

		item := QuestionInfo{Text: txt, Tag: 4}
		ptag, err := p.FindElement(selenium.ByXPATH, "./div/div/div/div/div/div/div/p")
		if err != nil {
			fmt.Printf("简答题框未找到:%v\n", err)
			break
		}
		if false {
			ptag.Clear()
			err = ptag.SendKeys("test test")
			fmt.Printf("sendkeys error:%v\n", err)
		}
		anserItem := AnswerInfo{Ptag: &ElementInfo{Element: ptag}}
		item.AnswerArray = append(item.AnswerArray, &anserItem)
		ret = append(ret, item)
		count++
	}
	if len(ret) == 0 {
		return nil, errors.New("未找到题")
	}
	//fmt.Printf("yyyyyyyy:%v\n", ret)
	return ret, nil
}

func examHandleSpecialQuestion(wd selenium.WebDriver) ([]QuestionInfo, error) {
	fmt.Printf("正在搜集题目和选项请等待\n")
	err := wd.WaitWithTimeout(Displayed(selenium.ByXPATH, "//div[@class='exam-subjects']/ol[@class='subjects-jit-display']"), time.Duration(config.Conf.Timeout)*time.Second)
	if err != nil {
		return nil, err
	}
	ol, err := wd.FindElement(selenium.ByXPATH, "//div[@class='exam-subjects']/ol[@class='subjects-jit-display']")
	if err != nil {
		return nil, err
	}
	time.Sleep(2 * time.Second)
	lis1, _ := ol.FindElements(selenium.ByXPATH, "./li")
	if len(lis1) == 0 {
		return nil, errors.New("未找到题")
	}
	ret := []QuestionInfo{}
	for _, li1 := range lis1 {
		attr, _ := li1.GetAttribute("class")
		tag := 0
		if strings.Contains(attr, "true_or_false") {
			tag = 2
		}
		if strings.Contains(attr, "single_selection") {
			tag = 1
		}
		if strings.Contains(attr, "multiple_selection") {
			tag = 3
		}
		if strings.Contains(attr, "short_answer") {
			tag = 4
		}

		if tag == 0 {
			continue
		}
		item := QuestionInfo{Tag: tag}
		p, err := li1.FindElement(selenium.ByXPATH, "./div/div/div/span/p")
		if err != nil {
			return nil, err
		}
		txt, _ := p.Text()

		item.Text = trimQuestionPrefix(txt)
		//fmt.Println("1111111111111111112222222222222222222222222222222 text:", txt, item.Text)
		if tag == 4 {
			ptag, err := li1.FindElement(selenium.ByXPATH, "./div/div/div/div/div/div/div/p")
			if err != nil {
				fmt.Printf("简单题err:%v\n", err)
				break
			}

			item.Text = TrimSpace(item.Text)
			item.Text = ParseHan(item.Text)

			/*itemTxt := ""
			itemList := strings.Split(item.Text, ".")
			if len(itemList) > 1 {
				for index, v := range itemList {
					if index == 0 {
						continue
					}
					itemTxt = itemTxt + v
				}
				item.Text = strings.TrimSpace(itemTxt)
			}
			*/
			//fmt.Println("1111111111111111112222222222222222222222222222222 text finishi:", item.Text)
			anserItem := &AnswerInfo{Ptag: &ElementInfo{Element: ptag}}
			item.AnswerArray = append(item.AnswerArray, anserItem)
			ret = append(ret, item)
			continue
		} else {
			// 题目选项
			ol, _ := li1.FindElement(selenium.ByXPATH, "./div/div/ol")
			lis, _ := ol.FindElements(selenium.ByXPATH, "./li")
			for _, li := range lis {
				answerIterm := AnswerInfo{}
				if tag == 2 {
					radio, err := li.FindElement(selenium.ByXPATH, "./label/span/input")
					if err != nil {
						return nil, err
					}
					answerIterm.Radio = &ElementInfo{Element: radio}
					answer, err := li.FindElement(selenium.ByXPATH, "./label/div/span")
					if err != nil {
						return nil, err
					}
					txt, _ := answer.Text()
					answerIterm.Text = txt
					//fmt.Printf("收集题目答案:%s\n", txt)
				} else if tag == 1 || tag == 3 {
					radio, err := li.FindElement(selenium.ByXPATH, "./label/span/input")
					if err != nil {
						return nil, err
					}
					answerIterm.Radio = &ElementInfo{Element: radio}
					answer, err := li.FindElement(selenium.ByXPATH, "./label/div/span")
					if err != nil {
						return nil, err
					}
					txt, _ := answer.Text()
					answerIterm.Text = txt
					//fmt.Printf("收集题目答案:%s\n", txt)
					if tag == 3 {
						txt, _ := radio.GetAttribute("class")
						if strings.Contains(txt, "ng-not-empty") {
							//radio.Click()
							tryClick(wd, radio)
						}
					}

					//ppp, _ := radio.FindElement(selenium.ByXPATH, "./following-sibling::span")
					//txt, _ = ppp.Text()
					//fmt.Printf("kkkkkkkkkkkkkkkkkkkaa:%s,%s\n", txt, answerIterm.Text)

				}
				item.AnswerArray = append(item.AnswerArray, &answerIterm)

			}
		}
		ret = append(ret, item)
	}
	return ret, nil
}

func trimQuestionPrefix(txt string) string {
	if len(txt) < 2 {
		return txt
	}
	regstr := `^[1-9][0-9]*(\.|、|．)`
	//regstr := `^[1-9][0-9]*、`
	reg := regexp.MustCompile(regstr)
	prefix := reg.FindString(txt)
	return txt[len(prefix):]
}
func examHandleQuestion(wd selenium.WebDriver, specialCourse bool) ([]QuestionInfo, error) {
	if specialCourse {
		return examHandleSpecialQuestion(wd)
	}
	err := wd.WaitWithTimeout(Displayed(selenium.ByXPATH, "//li[@class='subject ng-scope text']"), time.Duration(config.Conf.Timeout)*time.Second)
	if err != nil {
		return examHandleSimpleAnswer(wd)
	}
	questionClasses, _ := wd.FindElements(selenium.ByXPATH, "//li[@class='subject ng-scope text']")
	ret := []QuestionInfo{}
	for _, v := range questionClasses {
		p, err := v.FindElement(selenium.ByXPATH, "./div/div/div/span/p[@class='ng-scope']")
		if err != nil {
			return nil, err
		}
		txt, _ := p.Text()
		//fmt.Printf("题类%s\n", txt)
		className := ""
		tag := 0
		// 题目类型
		if strings.Contains(txt, "单项选择") || strings.Contains(txt, "单选") {
			className = "subject ng-scope single_selection"
			tag = 1
		} else if strings.Contains(txt, "判断") {
			className = "subject ng-scope true_or_false"
			tag = 2
		} else if strings.Contains(txt, "多项选择题") || strings.Contains(txt, "多选") {
			tag = 3
			className = "subject ng-scope multiple_selection"
		} else if strings.Contains(txt, "计算题") || strings.Contains(txt, "简答题") {
			tag = 4
			className = "subject ng-scope short_answer"
		}
		if className == "" {
			continue
		}
		p = v
		path := fmt.Sprintf("./following-sibling::li[@class='%s']", className)
		for {
			item := QuestionInfo{Tag: tag}
			// 题目
			p, err = p.FindElement(selenium.ByXPATH, path)
			if err != nil {
				//fmt.Printf("err:%v\n", err)
				break
			}
			x, err := p.FindElement(selenium.ByXPATH, "./div/div/div/span/p[@class='ng-scope']")
			if err != nil {
				break
			}
			txt, _ := x.Text()
			// 题目描述
			txt = strings.TrimSpace(txt)

			item.Text = trimQuestionPrefix(txt)

			if tag == 4 {
				ptag, err := p.FindElement(selenium.ByXPATH, "./div/div/div/div/div/div/div/p")
				if err != nil {
					fmt.Printf("计算题err:%v\n", err)
					break
				}
				anserItem := &AnswerInfo{Ptag: &ElementInfo{Element: ptag}}
				item.AnswerArray = append(item.AnswerArray, anserItem)
				ret = append(ret, item)
				continue
			}

			// 题目选项
			ol, _ := p.FindElement(selenium.ByXPATH, "./div/div/ol")
			lis, _ := ol.FindElements(selenium.ByXPATH, "./li")
			for _, li := range lis {

				answerIterm := AnswerInfo{}
				if tag == 2 {
					radio, err := li.FindElement(selenium.ByXPATH, "./label/span/input")
					if err != nil {
						return nil, err
					}
					answerIterm.Radio = &ElementInfo{Element: radio}
					answer, err := li.FindElement(selenium.ByXPATH, "./label/div/span")
					if err != nil {
						return nil, err
					}
					txt, _ := answer.Text()
					answerIterm.Text = txt
				} else if tag == 1 || tag == 3 {
					radio, err := li.FindElement(selenium.ByXPATH, "./label/span/input")
					if err != nil {
						return nil, err
					}
					answerIterm.Radio = &ElementInfo{Element: radio}
					answer, err := li.FindElement(selenium.ByXPATH, "./label/div/span/p")
					if err != nil {
						return nil, err
					}
					txt, _ := answer.Text()
					answerIterm.Text = txt

					if tag == 3 {
						txt, _ := radio.GetAttribute("class")
						if strings.Contains(txt, "ng-not-empty") {
							//radio.Click()
							tryClick(wd, radio)
						}
					}

					//ppp, _ := radio.FindElement(selenium.ByXPATH, "./following-sibling::span")
					//txt, _ = ppp.Text()
					//fmt.Printf("kkkkkkkkkkkkkkkkkkkaa:%s,%s\n", txt, answerIterm.Text)

				}
				item.AnswerArray = append(item.AnswerArray, &answerIterm)

			}
			ret = append(ret, item)
		}

	}

	return ret, nil
}

func examHandleQuestion2(wd selenium.WebDriver, specialCourse bool) ([]QuestionInfo, error) {
	if specialCourse {
		return examHandleSpecialQuestion(wd)
	}
	fmt.Printf("xxxxxx1\n")
	err := wd.WaitWithTimeout(Displayed(selenium.ByXPATH, "//li[contains(@class, 'subject ng-scope short_answer')]"), time.Duration(config.Conf.Timeout)*time.Second)
	if err == nil {
		return examHandleSimpleAnswer(wd)
	}
	err = wd.WaitWithTimeout(Displayed(selenium.ByXPATH, "//li[contains(@class, 'subject ng-scope ')]"), time.Duration(config.Conf.Timeout)*time.Second)
	if err != nil {
		return nil, errors.New("未找到题")
	}
	fmt.Printf("xxxx2\n")
	questionClasses, _ := wd.FindElements(selenium.ByXPATH, "//li[contains(@class, 'subject ng-scope ')]")
	ret := []QuestionInfo{}
	fmt.Printf("count:%v\n", len(questionClasses))
	for _, v := range questionClasses {
		attr, _ := v.GetAttribute("class")
		fmt.Printf("attr:%v\n", attr)
		tag := 0
		if strings.Contains(attr, "single_selection") {
			tag = 1
		} else if strings.Contains(attr, "true_or_false") {
			tag = 2
		} else if strings.Contains(attr, "multiple_selection") {
			tag = 3
		} else if strings.Contains(attr, "short_answer") {
			tag = 4
		}
		if tag == 0 {
			continue
		}
		item := QuestionInfo{Tag: tag}
		// 题目
		p := v
		x, err := p.FindElement(selenium.ByXPATH, "./div/div/div/span/p[@class='ng-scope']")
		if err != nil {
			x, err = p.FindElement(selenium.ByXPATH, "./div/div/div/span/p[@class='MsoNormal ng-scope']")
			if err != nil {
				break
			}

		}
		txt, _ := x.Text()
		// 题目描述
		txt = strings.TrimSpace(txt)

		item.Text = trimQuestionPrefix(txt)
		fmt.Printf("题目描述:%v\n", txt)
		if tag == 4 {
			ptag, err := p.FindElement(selenium.ByXPATH, "./div/div/div/div/div/div/div/p")
			if err != nil {
				fmt.Printf("计算题err:%v\n", err)
				break
			}
			anserItem := &AnswerInfo{Ptag: &ElementInfo{Element: ptag}}
			item.AnswerArray = append(item.AnswerArray, anserItem)
			ret = append(ret, item)
			continue
		}

		// 题目选项
		ol, _ := p.FindElement(selenium.ByXPATH, "./div/div/ol")
		lis, _ := ol.FindElements(selenium.ByXPATH, "./li")
		for _, li := range lis {

			answerIterm := AnswerInfo{}
			if tag == 2 {
				radio, err := li.FindElement(selenium.ByXPATH, "./label/span/input")
				if err != nil {
					return nil, err
				}
				answerIterm.Radio = &ElementInfo{Element: radio}
				answer, err := li.FindElement(selenium.ByXPATH, "./label/div/span")
				if err != nil {
					return nil, err
				}
				txt, _ := answer.Text()
				answerIterm.Text = txt
				fmt.Printf("选项:%v\n", answerIterm.Text)
			} else if tag == 1 || tag == 3 {
				radio, err := li.FindElement(selenium.ByXPATH, "./label/span/input")
				if err != nil {
					return nil, err
				}
				answerIterm.Radio = &ElementInfo{Element: radio}
				answer, err := li.FindElement(selenium.ByXPATH, "./label/div/span/p")
				if err != nil {
					return nil, err
				}
				txt, _ := answer.Text()
				answerIterm.Text = txt

				if tag == 3 {
					txt, _ := radio.GetAttribute("class")
					if strings.Contains(txt, "ng-not-empty") {
						//radio.Click()
						tryClick(wd, radio)
					}
				}
				fmt.Printf("选项:%v\n", answerIterm.Text)

				//ppp, _ := radio.FindElement(selenium.ByXPATH, "./following-sibling::span")
				//txt, _ = ppp.Text()
				//fmt.Printf("kkkkkkkkkkkkkkkkkkkaa:%s,%s\n", txt, answerIterm.Text)

			}
			item.AnswerArray = append(item.AnswerArray, &answerIterm)

		}
		ret = append(ret, item)
	}

	return ret, nil
}

func examHandleMatch(wd selenium.WebDriver, questions []QuestionInfo, m map[string][]string) error {
	err := chooseAnswer(wd, questions, m)
	if err != nil {
		if false {
			fmt.Printf("err:%v\n", err)
			c := ""
			fmt.Printf("等待输入\n")
			fmt.Scanln(&c)
			m, _ = LoadXlsx(fmt.Sprintf("%s.xlsx", "思想道德修养与法律基础"))
			return examHandleMatch(wd, questions, m)
		}
		return err

	}
	return nil
}

func tryEqual(a string, b string) bool {
	if a == b {
		return true
	}
	if !strings.Contains(a, b) {
		return false
	}
	index := strings.Index(a, b)
	for i := 0; i < index; i++ {
		if (a[i] <= 'z' && a[i] >= 'a') || (a[i] >= '0' && a[i] <= '1') || (a[i] <= 'Z' && a[i] >= 'A') {
			return false
		}
	}
	for i := index + len(b); i < len(a); i++ {
		if (a[i] <= 'z' && a[i] >= 'a') || (a[i] >= '0' && a[i] <= '1') || (a[i] <= 'Z' && a[i] >= 'A') {
			return false
		}
	}
	return true
}

func examHandleSubmit(wd selenium.WebDriver) error {
	// 交卷
	button1, err := wd.FindElement(selenium.ByXPATH, "//a[@class='button button-green ng-scope' and text()='交卷']")
	if err != nil {
		return err
	}
	//button1.Click()
	tryClick(wd, button1)
	time.Sleep(2 * time.Second)

	// 弹窗中的确定
	active, _ := wd.ActiveElement()
	button2s, err := active.FindElements(selenium.ByXPATH, "//button[text()='确定']")
	if err != nil {
		return err
	}
	for _, button2 := range button2s {
		txt, _ := button2.Text()
		if txt == "确定" {
			//button2.Click()
			tryClick(wd, button2)
			time.Sleep(2 * time.Second)
			return nil
		}
	}
	return errors.New("交卷未找到确定按钮")
}

func examHandle(wd selenium.WebDriver, courseId, moduleId, id string, qustionM map[string][]string, specialCourse bool) error {
	cookie, _ := getCookies(wd)
	finsh, submited, noScore := checkExamFinish(id, cookie)
	if noScore {
		fmt.Printf("不计分，该试题不做\n")
		return nil
	}
	if finsh {
		fmt.Printf("试题达到最大提交次数\n")
		return nil
	}

	if submited {
		isFinsh := checkExamScore(id, cookie)
		if isFinsh {
			fmt.Printf("已完成该试题,并满足分数\n")
			return nil
		} else {
			fmt.Printf("已完成该试题,不满足分数,继续答题\n")
		}
	}

	// 跳转页面
	if err := examHandleJump(wd, courseId, moduleId, id); err != nil {
		return err
	}

	// 点击答题按钮
	if err := examHandleStart(wd); err != nil {

		return err
	}

	// 收集题目和答案选项
	questions, err := examHandleQuestion2(wd, specialCourse)
	if err != nil {
		fmt.Printf("examhandleQuestion:%v\n")
		if strings.Contains(err.Error(), "未找到题") {
			url, _ := wd.CurrentURL()
			wd.Get(url)
			fmt.Printf("再次尝试：%s\n", url)
			questions, err = examHandleQuestion(wd, specialCourse)
			if err != nil {
				return err
			}
		}
	}
	if true {
		//time.Sleep(4000 * time.Second)
	}

	fmt.Println("--------------------------------------------------------题目和答案:", questions)
	// 匹配题库并选择答案
	fmt.Printf("*****************开始匹配答案\n")
	if err := examHandleMatch(wd, questions, qustionM); err != nil {
		return err
	}
	fmt.Printf("examHandleMatch:%v\n", err)
	if false {
		//time.Sleep(4000*time.Second)
		fmt.Println("请输入：")
		sal := ""
		fmt.Scanln(&sal)
		//return nil
	}

	// 提交试卷

	fmt.Printf("开始提交\n")
	if config.Conf.SleepTime > 0 {
		fmt.Printf("等待%d秒提交\n", config.Conf.SleepTime)
		time.Sleep(time.Duration(config.Conf.SleepTime) * time.Second)
	}
	err = examHandleSubmit(wd)
	fmt.Printf("examHandleSubmit:%v\n", err)
	if false {
		//time.Sleep(4000*time.Second)
		fmt.Println("请输入2：")
		sal := ""
		fmt.Scanln(&sal)
	}
	return err
}

func checkExamScore(id string, cookie string) (finish bool) {
	url := fmt.Sprintf("https://lms.ouchn.cn/api/exams/%s/submissions", id)
	request, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return false
	}

	request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	request.Header.Set("Cookie", cookie)
	request.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.81 Safari/537.36")
	//request.Header.Set("Host", "chengdu.ouchn.cn")

	client := http.Client{}
	resp, err := client.Do(request)
	if err != nil {
		return false
	}
	defer resp.Body.Close()

	respBytes, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return false
	}
	examScore := gjson.GetBytes(respBytes, "exam_score").Int()
	fmt.Println("分数：", examScore, "   最低要求分数：", config.Conf.MinScore)
	if int(examScore) >= config.Conf.MinScore {
		return true
	}

	return false

}

func checkExamFinish(id string, cookie string) (finish bool, submited bool, noScore bool) {
	url := fmt.Sprintf("https://lms.ouchn.cn/api/exams/%s", id)
	request, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return false, false, false
	}

	request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	request.Header.Set("Cookie", cookie)
	request.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.81 Safari/537.36")
	//request.Header.Set("Host", "chengdu.ouchn.cn")

	client := http.Client{}
	resp, err := client.Do(request)
	if err != nil {
		return false, false, false
	}
	defer resp.Body.Close()

	respBytes, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return false, false, false
	}
	scorePercentage := gjson.GetBytes(respBytes, "score_percentage").String()
	if scorePercentage == "0" || scorePercentage == "0.0" || scorePercentage == "0.00" {
		return true, false, true
	}

	submitTimes := gjson.GetBytes(respBytes, "submit_times").Int()
	submittedTimes := gjson.GetBytes(respBytes, "submitted_times").Int()
	if submittedTimes > 0 {
		submited = true
	}
	if submitTimes == submittedTimes && submitTimes > 0 {
		return true, submited, false
	}

	return false, submited, false

}

func isSpecialCourse(title string) bool {
	if title == "斜弱视技术" || title == "常见眼病诊断与处理" || title == "角膜接触镜并发症处理" {
		return true
	}
	for _, v := range config.Conf.SpecialCourses {
		if v == title {
			return true
		}
	}
	return false
}

func finishUploadId(uploadId int64, moduleId string, cookie string) error {
	rBody := make(map[string]int64)
	rBody["upload_id"] = uploadId
	rByte, _ := json.Marshal(rBody)
	url := fmt.Sprintf("https://lms.ouchn.cn/api/course/activities-read/%s", moduleId)
	request, err := http.NewRequest("POST", url, bytes.NewBuffer(rByte))
	if err != nil {
		return err
	}

	request.Header.Set("Content-Type", "application/json")
	request.Header.Set("Cookie", cookie)
	request.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.81 Safari/537.36")
	//request.Header.Set("Host", "chengdu.ouchn.cn")

	client := http.Client{}
	resp, err := client.Do(request)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	respBytes, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	if true {
		fmt.Println("do material resp:", string(respBytes))
	}

	return nil
}

func finishMaterial(uploadIds []int64, moduleId string, cookie string) {
	for _, v := range uploadIds {
		finishUploadId(v, moduleId, cookie)
		time.Sleep(time.Duration(config.Conf.VideoInterval) * time.Second)
	}
}

func doMaterial(moduleId string, cookie string) {
	uploadIds, _ := getUploadIds(moduleId, cookie)
	if len(uploadIds) > 0 {
		finishMaterial(uploadIds, moduleId, cookie)
	}
}

func CourseHandle(wd selenium.WebDriver, username string) error {

	title, err := wd.Title()
	if title == "" {
		return nil
	}
	array := strings.Split(title, "-")
	title = array[0]
	title = strings.TrimSpace(title)

	cookie, err := getCookies(wd)
	if err != nil {
		return err
	}

	fmt.Printf("***************正在处理%s课程%s\n", username, title)
	specialCourse := isSpecialCourse(title)
	fmt.Printf("is special:%v\n", specialCourse)
	questionM, _ := LoadXlsx(fmt.Sprintf("%s.xlsx", title))

	// 获取课程id
	time.Sleep(2 * time.Second)
	src, _ := wd.CurrentURL()
	courseId := getCourseId(src)
	if courseId == "" {
		return errors.New("课程id获取失败")
	}
	fmt.Printf("课程id:%s\n", courseId)

	// 获取课程所有栏目
	modules, err := getCourseModules(courseId, cookie, specialCourse)
	if err != nil {
		return errors.New(fmt.Sprintf("获取module信息失败：%s", err.Error()))
	}
	fmt.Printf("modules:%v\n", modules)
	examCount := 0
	for _, module := range modules {
		fmt.Printf("***课程:%s 栏目:%s\n", title, module.Name)
		/*if specialCourse && (config.Conf.Target == 1 || config.Conf.Target == 3) && (!strings.Contains(module.Name, "形考任务") &&
			!strings.Contains(module.Name, "形成性考核") &&
			!strings.Contains(module.Name, "形考作业") &&
			!strings.Contains(module.Name, "课程考核") &&
			!strings.Contains(module.Name, "大作业") &&
			!strings.Contains(module.Name, "考试考核")) {
			fmt.Println("module name:", module.Name)
			continue
		}*/
		if strings.Contains(module.Name, "专题一") ||
			strings.Contains(module.Name, "专题二") ||
			strings.Contains(module.Name, "专题三") ||
			strings.Contains(module.Name, "专题四") ||
			strings.Contains(module.Name, "专题五") ||
			strings.Contains(module.Name, "总论 ") {
			//continue
		}

		if false {
			if !strings.Contains(module.Name, "专题三") {
				continue
			}
		}

		// 获取某栏目下的试题和视频数据

		moduleInfo, err := GetModuleInfo(courseId, module.ModuleId, cookie)
		if err != nil {
			return errors.New(fmt.Sprintf("获取module（%s）详细信息失败：%s", module.Name, err.Error()))
		}

		//fmt.Println("2222222222222:", moduleInfo)

		// 处理网页数据
		if false {
			for _, info := range moduleInfo.TxtInfos {
				fmt.Printf("*****正在处理网页数据：%s\n", info.Name)
				url := MakeTxtUrl(courseId, module.ModuleId, info.Id)
				wd.Get(url)
				count := 0
				for count < 10 {
					curl, _ := wd.CurrentURL()
					if strings.Contains(curl, info.Id) {
						time.Sleep(5 * time.Second)
						break
					}
					count++
					time.Sleep(1 * time.Second)
				}
			}
		}

		if (config.Conf.Target == 1 || config.Conf.Target == 2) && !strings.Contains(title, "国家开放大学学习指南") {
			// 处理视频数据
			for _, info := range moduleInfo.VedioInfos {
				if config.Conf.HandlePage {
					if info.Type == 1 {
						fmt.Printf("*****正在处理网页数据：%s\n", info.Name)
						url := MakeTxtUrl(courseId, module.ModuleId, info.Id)
						wd.Get(url)
						count := 0
						for count < 10 {
							curl, _ := wd.CurrentURL()
							if strings.Contains(curl, info.Id) {
								time.Sleep(5 * time.Second)
								break
							}
							count++
							time.Sleep(1 * time.Second)
						}
					}
				}
				if info.Type == 2 {
					fmt.Printf("*****正在处理视频数据：%s\n", info.Name)

					if info.Stype == "material" {
						doMaterial(info.Id, cookie)
						continue
					}

					url := MakeTxtUrl(courseId, module.ModuleId, info.Id)
					wd.Get(url)
					cookie, _ := getCookies(wd)

					// 特殊视频
					if info.Stype == "web_link" {
						array := strings.Split(info.Name, "：")
						if len(array) > 1 {
							array[0] = array[1]
						}

						str := fmt.Sprintf("//iframe[contains(@ng-src, '%s')]", array[0])
						wd.WaitWithTimeout(Displayed(selenium.ByXPATH, str), time.Duration(config.Conf.Timeout)*time.Second)
						continue
					}

					err = wd.WaitWithTimeout(Displayed(selenium.ByXPATH, "//button[@class='mvp-toggle-play mvp-first-btn-margin']"), time.Duration(config.Conf.Timeout)*time.Second)
					if err != nil {
						wd.Get(url)
						err = wd.WaitWithTimeout(Displayed(selenium.ByXPATH, "//button[@class='mvp-toggle-play mvp-first-btn-margin']"), time.Duration(config.Conf.Timeout)*time.Second)
						if err != nil {
							fmt.Printf("获取播放按钮失败\n")
						}
						continue
						//return err
					}

					playButton, _ := wd.FindElement(selenium.ByXPATH, "//button[@class='mvp-toggle-play mvp-first-btn-margin']")
					er := playButton.Click()
					//er := tryClick(wd, playButton)
					if er != nil {
						fmt.Printf("播放点击失败:%v\n", er)
						return er
					}

					//fmt.Printf("cookie:%s\n", cookie)
					time.Sleep(time.Duration(config.Conf.VideoInterval) * time.Second)

					//er = tryClick(wd, playButton)
					//if er != nil {
					//	fmt.Printf("停止播放点击失败:%v\n", er)
					//}
					//wd.Get(fmt.Sprintf("https://lms.ouchn.cn/course/%s/ng#/my-stat", courseId))

					//time.Sleep(2*time.Second)
					err := VedioCompleteHandle(cookie, info.Id)
					if err != nil {
						fmt.Printf("    视频%s处理失败（%s）\n", info.Name, err.Error())
						return err
					}
					//time.Sleep(10000*time.Second)
				}
			}
		}

		if config.Conf.Target == 1 || config.Conf.Target == 3 {
			// 处理试题数据
			for _, info := range moduleInfo.ExamInfos {
				fmt.Printf("*****正在处理试题数据：%s\n", info.Name)
				if len(questionM) == 0 && !config.Conf.QuestionRandom {
					fmt.Printf("无法处理试题，课程%s未提供答案\n", title)
					break
				}
				//if !strings.Contains(info.Name, "考试任务二") {
				//	continue
				//}
				examCount++
				fmt.Printf("count:%d\n", examCount)
				// 测试用的
				if examCount < 0 {
					continue
				}

				err := examHandle(wd, courseId, module.ModuleId, info.Id, questionM, specialCourse)
				if err != nil {
					fmt.Printf("    试题%s处理失败（%s）\n", info.Name, err.Error())
					//time.Sleep(1000 * time.Second)
					if strings.Contains(err.Error(), "选项为空") ||
						strings.Contains(err.Error(), "答案为空") {
						continue
					}

					return err
				}
				time.Sleep(1 * time.Second)
				//time.Sleep(1000*time.Second)

			}
			//time.Sleep(1000*time.Second)
		}
		// 再次处理网页数据
		if true {
			for i := 0; i < config.Conf.VisitCount; i++ {
				for _, info := range moduleInfo.TxtInfos {
					fmt.Printf("*****正在点击网页数据：%s\n", info.Name)
					url := MakeTxtUrl(courseId, module.ModuleId, info.Id)
					wd.Get(url)
					count := 0
					for count < 10 {
						curl, _ := wd.CurrentURL()
						if strings.Contains(curl, info.Id) {
							time.Sleep(2 * time.Second)
							break
						}
						count++
						time.Sleep(1 * time.Second)
					}

				}
			}

		}

	}
	if true {
		//time.Sleep(1000*time.Second)
	}
	return nil
}