package domainser

import (
	"context"
	"fmt"
	"math/rand"
	"net/http"
	"net/url"
	"stat/common/log"
	"stat/common/utils"
	"stat/models/domainmod"
	"stat/statg"
	"strings"
	"sync"
	"time"

	"go.mongodb.org/mongo-driver/bson"

	"github.com/ddliu/go-httpclient"
)

const (
	ApiKey           = "a45d5d2c6c231f28f9bcccf4092eb246"
	ApiDomain        = "https://api.boce.com"
	ApiCheckDuration = time.Second * 10
	ApiCheckTimeout  = time.Minute * 2
	ApiCheckTryCount = 6
)

type NodeCache struct {
	List NodeList
	Last time.Time
	Lock sync.Mutex
}

type MutexResult struct {
	List domainmod.CheckResultList
	Lock sync.Mutex
}

var (
	Cache = &NodeCache{
		List: make(NodeList, 0),
		Last: time.Time{},
		Lock: sync.Mutex{},
	}
)

func (c *NodeCache) NodeList() (NodeList, error) {
	ret := make(NodeList, 0)

	c.Lock.Lock()
	if len(c.List) > 0 && c.Last.After(time.Now().Add(-24*time.Hour)) {
		for _, node := range c.List {
			ret = append(ret, node)
		}
		c.Lock.Unlock()
		return ret, nil
	}
	c.Lock.Unlock()

	list, err := GetNodeList()
	if err != nil {
		return ret, err
	}

	if len(list) > 0 {
		c.Lock.Lock()
		c.List = list
		c.Last = time.Now()
		for _, node := range c.List {
			ret = append(ret, node)
		}
		c.Lock.Unlock()
		return ret, nil
	} else {
		return nil, fmt.Errorf("node list is empty")
	}
}

func GetNodeList() (NodeList, error) {
	addr := fmt.Sprintf("https://task.boce.com/v3/node/list?key=%s", ApiKey)
	res := &CommonResp{}
	tryCount := 0
	for {
		err := Get(addr, res, url.Values{})
		if err != nil {
			tryCount++
			if tryCount > ApiCheckTryCount {
				return nil, err
			}
			time.Sleep(ApiCheckDuration)
			continue
		}
		break
	}
	if res.ErrorCode != 0 {
		return nil, fmt.Errorf("获取检测节点列表失败:%s", GetApiErrorMessage(res.ErrorCode))
	}
	return *res.Data.List, nil
}

func (s *MutexResult) OnFinish(result *domainmod.CheckResult) {
	s.Lock.Lock()
	defer s.Lock.Unlock()

	s.List = append(s.List, result)
}

func (s *MutexResult) RealErrors() []error {
	ret := make([]error, 0)
	for _, item := range s.List {
		if item.CheckSucc && item.Error != nil {
			ret = append(ret, item.Error)
		}
	}
	return ret
}

func (s *MutexResult) AllSuccess() bool {
	for _, item := range s.List {
		if item.CheckSucc && item.Error != nil {
			return false
		}
	}
	return true
}

func (s *MutexResult) JumpErrors() []error {
	ret := make([]error, 0)
	for _, item := range s.List {
		if !item.CheckSucc && item.Error != nil {
			ret = append(ret, item.Error)
		}
	}
	return ret
}

func (s *MutexResult) Reports() string {
	var ret string
	for _, item := range s.List {
		if item.Error != nil {
			ret += "\n" + item.Error.Error() + "\n"
		}
		if len(item.NodeErrors) > 0 {
			ret += strings.Join(item.NodeErrors, "\n\n")
		}
	}
	return ret
}

func (s *MutexResult) CheckStatus() (passCount int, jumpCount int, errorCount int) {
	for _, item := range s.List {
		if item.CheckSucc {
			if item.Error != nil {
				errorCount++
			} else {
				passCount++
			}
		} else {
			jumpCount++
		}
	}
	return
}

var ApiErrorMessage = map[int]string{
	0: "成功",
	1: "鉴权失败",
	2: "参数错误",
	3: "波点不足或波点未配置",
	4: "生成任务id失败或任务id失效",
}

func GetApiErrorMessage(code int) string {
	ret := ApiErrorMessage[code]
	if ret == "" {
		return "未知错误"
	}
	return ret
}

var ApiPathMap = map[domainmod.CheckType]ApiPath{
	domainmod.CheckTypeWeb: {
		Create:     "/v3/task/create/curl",
		Query:      "/v3/task/curl/",
		Sleep:      5 * time.Minute,
		NeedCreate: true,
	},
	domainmod.CheckTypeDNS: {
		Create:     "/v3/task/create/dig",
		Query:      "/v3/task/dig/",
		Sleep:      5 * time.Minute,
		NeedCreate: true,
	},
	domainmod.CheckTypePing: {
		Create:     "/v3/task/create/ping",
		Query:      "/v3/task/ping/",
		Sleep:      5 * time.Minute,
		NeedCreate: true,
	},
	domainmod.CheckTypeHijack: {
		Create:     "/v3/task/create/hijack",
		Query:      "/v3/task/hijack/",
		Sleep:      5 * time.Minute,
		NeedCreate: true,
	},
	domainmod.CheckTypePollute: {
		Create:     "",
		Query:      "/v3/task/create/pollute",
		NeedCreate: false,
	},
	domainmod.CheckTypeQQ: {
		Create:     "",
		Query:      "/v3/task/create/qq",
		NeedCreate: false,
	},
	domainmod.CheckTypeWeChat: {
		Create:     "",
		Query:      "/v3/task/create/wechat",
		NeedCreate: false,
	},
	domainmod.CheckTypeBlack: {
		Create:     "",
		Query:      "/v3/task/create/blacklist",
		NeedCreate: false,
	},
	domainmod.CheckTypeGFW: {
		Create:     "",
		Query:      "/v3/task/create/wall",
		NeedCreate: false,
	},
}

func init() {
	httpclient.Defaults(httpclient.Map{
		"OPT_CONNECTTIMEOUT": 30 * time.Second,
		"OPT_TIMEOUT":        10 * time.Second,
		"Accept-Encoding":    "gzip,deflate",
	})
}

func GetChecker(item *domainmod.Domain, mode domainmod.CheckType, onFinish FnCheckFinish, nodes ...Node) Checker {
	nodeList := make(NodeList, 0)
	nodeList = append(nodeList, nodes...)
	switch mode {
	case domainmod.CheckTypeWeb:
		return NewWebChecker(item, mode, onFinish, nodeList)
	case domainmod.CheckTypeDNS:
		return NewWebChecker(item, mode, onFinish, nodeList)
	case domainmod.CheckTypePing:
		return NewWebChecker(item, mode, onFinish, nodeList)
	case domainmod.CheckTypeHijack:
		return NewHijackChecker(item, mode, onFinish, nodeList)
	case domainmod.CheckTypePollute:
		return NewPolluteChecker(item, mode, onFinish)
	case domainmod.CheckTypeQQ:
		return NewQQChecker(item, mode, onFinish)
	case domainmod.CheckTypeWeChat:
		return NewWeChatChecker(item, mode, onFinish)
	case domainmod.CheckTypeBlack:
		return NewBlackChecker(item, mode, onFinish)
	case domainmod.CheckTypeGFW:
		return NewGFWChecker(item, mode, onFinish)
	default:
		return nil
	}
}

type DomainChecker struct {
	Items domainmod.DomainList
}

func (c *DomainChecker) StartCheck() error {
	nodes, err := Cache.NodeList()
	if err != nil {
		return err
	}
	wg := utils.NewWaitGroup()
	for _, domain := range c.Items {
		_domain := domain
		wg.Add(func() {
			CheckDomain(_domain, nodes)
		})
	}
	wg.RunWaits()
	return nil
}

func CheckDomain(domain *domainmod.Domain, nodes NodeList) {
	ctx := context.Background()
	begin := time.Now()
	status := domainmod.CheckStatusChecking
	doc := &domainmod.DomainDoc{
		Status:    &status,
		CheckTime: &begin,
		UpdatedAt: &begin,
	}
	if err := domainmod.UpdateOneDomain(ctx, bson.M{"_id": domain.ID}, bson.M{"$set": doc}); err != nil {
		log.Warn("CheckDomain failed", log.E(err))
		return
	}
	rets := MutexResult{
		List: make(domainmod.CheckResultList, 0),
		Lock: sync.Mutex{},
	}
	wg := utils.NewWaitGroup()
	for _, check := range domain.Checks {
		_check := check
		wg.Add(func() {
			if checker := GetChecker(domain, _check, rets.OnFinish, nodes...); checker != nil {
				time.Sleep(time.Duration(rand.Intn(10)) * time.Second) // 防并发访问
				checker.Check()
			}
		})
	}
	wg.RunWaits()
	end := time.Now()
	doc = &domainmod.DomainDoc{
		CheckFinish: &end,
		UpdatedAt:   &end,
	}
	passCount, jumpCount, errCount := rets.CheckStatus()
	doc.Results = &rets.List
	if errCount > 0 {
		report := rets.Reports()
		doc.Report = &report
		status0 := domainmod.CheckStatusFailed
		//doc.Status = utils.PValue(domainmod.CheckStatusFailed)
		if passCount > 0 {
			//doc.Status = utils.PValue(domainmod.CheckStatusPartPass)
			status0 = domainmod.CheckStatusPartPass
		}
		doc.Status = &status0
	} else {
		if passCount > 0 {
			if jumpCount > 0 {
				//doc.Status = utils.PValue(domainmod.CheckStatusPartPass)
				//doc.Report = utils.PValue(rets.Reports())
				status0 := domainmod.CheckStatusPartPass
				report := rets.Reports()
				doc.Status = &status0
				doc.Report = &report
			} else {
				//doc.Status = utils.PValue(domainmod.CheckStatusSucc)
				//doc.Report = utils.PValue("完全通过")
				status0 := domainmod.CheckStatusSucc
				report := "完全通过"
				doc.Status = &status0
				doc.Report = &report
			}
		} else {
			//doc.Status = utils.PValue(domainmod.CheckStatusNone)
			//doc.Report = utils.PValue(rets.Reports())
			status0 := domainmod.CheckStatusNone
			report := rets.Reports()
			doc.Status = &status0
			doc.Report = &report
		}
	}

	if err := domainmod.UpdateOneDomain(ctx, bson.M{"_id": domain.ID}, bson.M{"$set": doc}); err != nil {
		log.Warn("CheckDomain failed", log.E(err))
		return
	}

	if errCount > 0 {
		text := fmt.Sprintf("域名检测:【%s】\n", domain.Name)
		text += fmt.Sprintf("开始时间:【%s】\n", begin.Format("2006-01-02T15:04:05"))
		text += fmt.Sprintf("结束时间:【%s】\n", end.Format("2006-01-02T15:04:05"))
		text += fmt.Sprintf("检测用时:【%s】\n", end.Sub(begin))
		text += fmt.Sprintf("检测结果:【%s】\n", *doc.Status)
		for _, result := range rets.List {
			if result.CheckSucc {
				if result.Error == nil {
					text += fmt.Sprintf("%s: %s\n", result.CheckType.Name(), "\U0001F7E2 通过")
				} else {
					if result.NodeCount == 0 {
						text += fmt.Sprintf("%s: %s\n", result.CheckType.Name(), "🔴 未通过")
					} else {
						if result.SuccRate < result.MinRate {
							if result.SuccRate < 25 {
								text += fmt.Sprintf("%s: %s\n", result.CheckType.Name(), "🔴 未通过")
							} else {
								text += fmt.Sprintf("%s: %s\n", result.CheckType.Name(), "\U0001F7E0 通过")
							}
						} else {
							text += fmt.Sprintf("%s: %s\n", result.CheckType.Name(), "\U0001F7E2 通过")
						}
					}
				}
			} else {
				text += fmt.Sprintf("%s: %s\n", result.CheckType.Name(), "🕓 超时")
			}
		}
		if domain.Redirected {
			text += fmt.Sprintf("域名跳转:【已做301跳转✅】\n")
			text += fmt.Sprintf("跳转地址:【==>%s】\n", domain.RedirectDomain)
		} else {
			text += fmt.Sprintf("域名跳转:【未做301跳转🈚】\n")
		}

		statg.Bot.SendDomainMessage(text)
	}
}

type WebChecker struct {
	Item   *domainmod.Domain
	Mode   domainmod.CheckType
	Finish FnCheckFinish
	Nodes  NodeList
}

func NewWebChecker(item *domainmod.Domain, mode domainmod.CheckType, onFinish FnCheckFinish, nodes NodeList) *WebChecker {
	return &WebChecker{
		Item:   item,
		Mode:   mode,
		Finish: onFinish,
		Nodes:  nodes,
	}
}

func (s *WebChecker) Check() error {
	ret := &domainmod.CheckResult{
		Domain:    s.Item.Name,
		CheckType: s.Mode,
		BeginTime: time.Now(),
		MinRate:   s.Item.MinRate,
	}
	defer s.Finish(ret)
	api, ok := ApiPathMap[s.Mode]
	if !ok {
		ret.EndTime = time.Now()
		ret.Error = fmt.Errorf("域名%s的检测类型%d不支持", s.Item.Name, s.Mode)
		return ret.Error
	}
	addr, err := api.GetCreateUrl(url.Values{
		"node_ids": []string{s.Nodes.SIdList(s.Item.MaxNodes)},
		"host":     []string{s.Item.Name},
	})
	if err != nil {
		ret.EndTime = time.Now()
		ret.Error = err
		return ret.Error
	}
	tryCount := 0
	res := &CommonResp{}
	for {
		err = Get(addr, res, url.Values{})
		if err != nil {
			tryCount++
			if tryCount > ApiCheckTryCount {
				ret.EndTime = time.Now()
				ret.Error = fmt.Errorf("创建【%s】的【%s】检测任务超时:%s", s.Item.Name, s.Mode.Name(), err.Error())
				return ret.Error
			}
			time.Sleep(ApiCheckDuration)
			continue
		}
		break
	}

	if res.ErrorCode != 0 {
		ret.EndTime = time.Now()
		ret.Error = fmt.Errorf("创建【%s】的【%s】检测任务失败:%s", s.Item.Name, s.Mode.Name(), GetApiErrorMessage(res.ErrorCode))
		return ret.Error
	}
	// 获取查询ID
	if res.Data.Id == nil || *res.Data.Id == "" {
		ret.EndTime = time.Now()
		ret.Error = fmt.Errorf("创建【%s】的【%s】检测任务失败:任务ID未空", s.Item.Name, s.Mode.Name())
		return ret.Error
	}
	TaskId := *res.Data.Id
	// 去查询结果
	tryCount = 0
	addr, err = api.GetQueryUrlWithTaskId(TaskId, url.Values{})
	end := time.Now().Add(ApiCheckTimeout)
	for {
		time.Sleep(ApiCheckDuration)
		webResp := &WebResp{}
		err = Get(addr, webResp, url.Values{})
		if err != nil {
			tryCount++
			if tryCount > ApiCheckTryCount {
				ret.EndTime = time.Now()
				ret.Error = fmt.Errorf("查询【%s】的【%s】检测结果超时:%s", s.Item.Name, s.Mode.Name(), err.Error())
				return ret.Error
			}
			continue
		}
		ret.CheckSucc = webResp.Done
		if webResp.Done {
			for _, node := range webResp.List {
				if node.ErrorCode != 0 {
					ret.FailedCount++
					ret.NodeErrors = append(ret.NodeErrors, node.ErrorString())
				} else {
					ret.NodeCount++
					if node.HttpCode == http.StatusOK {
						ret.SuccCount++
					} else {
						ret.NodeErrors = append(ret.NodeErrors, node.ErrorString())
					}
				}
			}
			if ret.NodeCount > 0 {
				ret.SuccRate = float64(ret.SuccCount*100) / float64(ret.NodeCount)
				if ret.SuccRate < ret.MinRate {
					ret.Error = fmt.Errorf("节点通过率%.1f%%<%.1f%%,未通过！", ret.SuccRate, ret.MinRate)
				}
			}
			break
		} else {
			if end.Before(time.Now()) {
				ret.Error = fmt.Errorf("查询【%s】的【%s】检测超时", s.Item.Name, s.Mode.Name())
				break
			}
		}

	}
	ret.EndTime = time.Now()
	return ret.Error
}

type HijackChecker struct {
	Item   *domainmod.Domain
	Mode   domainmod.CheckType
	Finish FnCheckFinish
	Nodes  NodeList
}

func NewHijackChecker(item *domainmod.Domain, mode domainmod.CheckType, onFinish FnCheckFinish, nodes NodeList) *HijackChecker {
	return &HijackChecker{
		Item:   item,
		Mode:   mode,
		Finish: onFinish,
		Nodes:  nodes,
	}
}

func (s *HijackChecker) Check() error {
	ret := &domainmod.CheckResult{
		Domain:    s.Item.Name,
		CheckType: s.Mode,
		BeginTime: time.Now(),
		MinRate:   s.Item.MinRate,
	}
	defer s.Finish(ret)
	api, ok := ApiPathMap[s.Mode]
	if !ok {
		ret.EndTime = time.Now()
		ret.Error = fmt.Errorf("域名%s的检测类型%d不支持", s.Item.Name, s.Mode)
		return ret.Error
	}
	addr, err := api.GetCreateUrl(url.Values{
		"node_ids": []string{s.Nodes.SIdList(s.Item.MaxNodes)},
		"host":     []string{s.Item.Name},
	})
	if err != nil {
		ret.EndTime = time.Now()
		ret.Error = err
		return ret.Error
	}
	tryCount := 0
	res := &CommonResp{}
	for {
		err = Get(addr, res, url.Values{})
		if err != nil {
			tryCount++
			if tryCount > ApiCheckTryCount {
				ret.EndTime = time.Now()
				ret.Error = fmt.Errorf("创建【%s】的【%s】检测任务超时:%s", s.Item.Name, s.Mode.Name(), err.Error())
				return ret.Error
			}
			time.Sleep(ApiCheckDuration)
			continue
		}
		break
	}

	if res.ErrorCode != 0 {
		ret.EndTime = time.Now()
		ret.Error = fmt.Errorf("创建【%s】的【%s】检测任务失败:%s", s.Item.Name, s.Mode.Name(), GetApiErrorMessage(res.ErrorCode))
		return ret.Error
	}
	// 获取查询ID
	if res.Data.Id == nil || *res.Data.Id == "" {
		ret.EndTime = time.Now()
		ret.Error = fmt.Errorf("创建【%s】的【%s】检测任务失败:任务ID未空", s.Item.Name, s.Mode.Name())
		return ret.Error
	}
	TaskId := *res.Data.Id
	// 去查询结果
	tryCount = 0
	addr, err = api.GetQueryUrlWithTaskId(TaskId, url.Values{})
	end := time.Now().Add(ApiCheckTimeout)
	for {
		time.Sleep(ApiCheckDuration)
		webResp := &HijackResp{}
		err = Get(addr, webResp, url.Values{})
		if err != nil {
			tryCount++
			if tryCount > ApiCheckTryCount {
				ret.EndTime = time.Now()
				ret.Error = fmt.Errorf("查询【%s】的【%s】接口错误【%d】次，超过最大重试次数:%s", s.Item.Name, s.Mode.Name(), tryCount, err.Error())
				return ret.Error
			}
			continue
		}
		ret.CheckSucc = webResp.Done
		if webResp.Done {
			for _, node := range webResp.List {
				ret.NodeCount++
				if node.Hijack {
					ret.FailedCount++
					ret.NodeErrors = append(ret.NodeErrors, node.ErrorString())
				} else {
					ret.SuccCount++
				}
			}
			if ret.NodeCount > 0 {
				ret.SuccRate = float64(ret.SuccCount*100) / float64(ret.NodeCount)
				if ret.SuccRate < ret.MinRate {
					ret.Error = fmt.Errorf("节点通过率%.1f%%<%.1f%%,未通过！", ret.SuccRate, ret.MinRate)
				}
			}
			break
		} else {
			if end.Before(time.Now()) {
				ret.Error = fmt.Errorf("查询【%s】的【%s】检测超时", s.Item.Name, s.Mode.Name())
				break
			}
		}

	}
	ret.EndTime = time.Now()
	return ret.Error
}

type FuncCheckResult func(ret *domainmod.CheckResult, data map[string]int)

func QueryCheck(item *domainmod.Domain, mode domainmod.CheckType, onFinish FnCheckFinish, onCheck FuncCheckResult) error {
	ret := &domainmod.CheckResult{
		Domain:    item.Name,
		CheckType: mode,
		BeginTime: time.Now(),
		MinRate:   item.MinRate,
	}
	defer onFinish(ret)
	api, ok := ApiPathMap[mode]
	if !ok {
		ret.EndTime = time.Now()
		ret.Error = fmt.Errorf("查询接口地址【%s】的【%s】出错", item.Name, mode.Name())
		return ret.Error
	}
	addr, err := api.GetQueryUrl(url.Values{"host": []string{item.Name}})
	polluteResp := &PolluteResp{}
	tryCount := 0
	for {
		tryCount++
		err = Get(addr, polluteResp, url.Values{})
		if err != nil {
			if tryCount > ApiCheckTryCount {
				ret.EndTime = time.Now()
				ret.Error = fmt.Errorf("查询【%s】的【%s】接口错误【%d】次，超过最大重试次数:%s", item.Name, mode.Name(), tryCount, err.Error())
				return ret.Error
			}
			time.Sleep(ApiCheckDuration)
			continue
		}
		break
	}

	if polluteResp.ErrorCode != 0 {
		ret.EndTime = time.Now()
		ret.Error = fmt.Errorf("查询【%s】的【%s】返回值不是成功:%s", item.Name, mode.Name(), GetApiErrorMessage(polluteResp.ErrorCode))
		return ret.Error
	}
	ret.CheckSucc = true
	onCheck(ret, polluteResp.Data)
	ret.EndTime = time.Now()
	return ret.Error
}

type PolluteChecker struct {
	Item   *domainmod.Domain
	Mode   domainmod.CheckType
	Finish FnCheckFinish
}

func NewPolluteChecker(item *domainmod.Domain, mode domainmod.CheckType, onFinish FnCheckFinish) *PolluteChecker {
	return &PolluteChecker{
		Item:   item,
		Mode:   mode,
		Finish: onFinish,
	}
}

func (s *PolluteChecker) Check() error {
	return QueryCheck(s.Item, s.Mode, s.Finish, func(ret *domainmod.CheckResult, data map[string]int) {
		if code, ok := data[s.Item.Name]; ok { //(-1 未注册,0 正常, 1 污染)
			if ok {
				if code == 0 {
					ret.SuccRate = 100.0
				} else {
					if code == 1 {
						ret.Error = fmt.Errorf("域名被污染")
					} else if code == -1 {
						ret.Error = fmt.Errorf("域名未注册")
					} else {
						ret.Error = fmt.Errorf("未知错误码%d", code)
					}
				}
			} else {
				ret.Error = fmt.Errorf("返回值中未检测到域名")
			}
		}
	})
}

type QQChecker struct {
	Item   *domainmod.Domain
	Mode   domainmod.CheckType
	Finish FnCheckFinish
}

func NewQQChecker(item *domainmod.Domain, mode domainmod.CheckType, onFinish FnCheckFinish) *QQChecker {
	return &QQChecker{
		Item:   item,
		Mode:   mode,
		Finish: onFinish,
	}
}

func (s *QQChecker) Check() error {
	return QueryCheck(s.Item, s.Mode, s.Finish, func(ret *domainmod.CheckResult, data map[string]int) {
		if code, ok := data[s.Item.Name]; ok { //1正常, 2拦截, 3-检测失败
			if ok {
				if code == 1 {
					ret.CheckSucc = true
					ret.SuccRate = 100.0
				} else {
					if code == 2 {
						ret.CheckSucc = true
						ret.Error = fmt.Errorf("已被拦截")
					} else if code == 3 {
						ret.Error = fmt.Errorf("检测失败")
					} else {
						ret.Error = fmt.Errorf("检测值【%d】不知道意义", code)
					}
				}
			} else {
				ret.Error = fmt.Errorf("返回值中未检测到域名")
			}
		}
	})
}

type WeChatChecker struct {
	Item   *domainmod.Domain
	Mode   domainmod.CheckType
	Finish FnCheckFinish
}

func NewWeChatChecker(item *domainmod.Domain, mode domainmod.CheckType, onFinish FnCheckFinish) *WeChatChecker {
	return &WeChatChecker{
		Item:   item,
		Mode:   mode,
		Finish: onFinish,
	}
}

func (s *WeChatChecker) Check() error {
	return QueryCheck(s.Item, s.Mode, s.Finish, func(ret *domainmod.CheckResult, data map[string]int) {
		if code, ok := data[s.Item.Name]; ok { //1正常, 2拦截(域名被封), 3-检测失败,4-拦截(非微信官方链接，需跳转访问)
			if ok {
				if code == 1 || code == 4 {
					ret.CheckSucc = true
					ret.SuccRate = 100.0
				} else {
					if code == 2 {
						ret.CheckSucc = true
						ret.Error = fmt.Errorf("已被拦截")
					} else if code == 3 {
						ret.Error = fmt.Errorf("检测失败")
					} else {
						ret.Error = fmt.Errorf("检测值【%d】不知道意义", code)
					}
				}
			} else {
				ret.Error = fmt.Errorf("返回值中未检测到域名")
			}
		}
	})
}

type BlackChecker struct {
	Item   *domainmod.Domain
	Mode   domainmod.CheckType
	Finish FnCheckFinish
}

func NewBlackChecker(item *domainmod.Domain, mode domainmod.CheckType, onFinish FnCheckFinish) *BlackChecker {
	return &BlackChecker{
		Item:   item,
		Mode:   mode,
		Finish: onFinish,
	}
}

func (s *BlackChecker) Check() error {
	return QueryCheck(s.Item, s.Mode, s.Finish, func(ret *domainmod.CheckResult, data map[string]int) {
		if code, ok := data[s.Item.Name]; ok { //1-正常, 2-在黑名单
			if ok {
				if code == 1 {
					ret.CheckSucc = true
					ret.SuccRate = 100.0
				} else {
					if code == 2 {
						ret.CheckSucc = true
						ret.Error = fmt.Errorf("在黑名单")
					} else {
						ret.Error = fmt.Errorf("检测值【%d】不知道意义", code)
					}
				}
			} else {
				ret.Error = fmt.Errorf("返回值中未检测到域名")
			}
		}
	})
}

type GFWChecker struct {
	Item   *domainmod.Domain
	Mode   domainmod.CheckType
	Finish FnCheckFinish
}

func NewGFWChecker(item *domainmod.Domain, mode domainmod.CheckType, onFinish FnCheckFinish) *GFWChecker {
	return &GFWChecker{
		Item:   item,
		Mode:   mode,
		Finish: onFinish,
	}
}

func (s *GFWChecker) Check() error {
	return QueryCheck(s.Item, s.Mode, s.Finish, func(ret *domainmod.CheckResult, data map[string]int) {
		if code, ok := data[s.Item.Name]; ok { //0 正常, 1 被墙, 2 疑似被墙, 3 无资源请重试,4 域名格式错误
			if ok {
				if code == 0 { // 正常
					ret.CheckSucc = true
					ret.SuccRate = 100.0
				} else {
					if code == 1 {
						ret.CheckSucc = true
						ret.Error = fmt.Errorf("域名被墙")
					} else if code == 2 {
						ret.CheckSucc = true
						ret.Error = fmt.Errorf("疑似被墙")
					} else if code == 3 {
						ret.Error = fmt.Errorf("无资源请重试")
					} else if code == 4 {
						ret.Error = fmt.Errorf("域名格式错误")
					} else {
						ret.Error = fmt.Errorf("检测值【%d】不知道意义", code)
					}
				}
			} else {
				ret.Error = fmt.Errorf("返回值中未检测到域名")
			}
		}
	})
}