package main

import (
	"flag"
	"fmt"
	"log"
	"net/http"
	"regexp"
	"time"

	"context"

	"golang.org/x/net/html"
)

var (
    // interval 控制两次访问的间隔
    interval time.Duration
    // timeout 控制http超时时间
	timeout  time.Duration
)

func init() {
	flag.DurationVar(&interval, "interval", 0, "interval between http get")
	flag.DurationVar(&timeout, "timeout", time.Second*15, "timeout for http get")
}

func walk(root *html.Node, f func(*html.Node) bool) {
	for n := root.FirstChild; n != nil; n = n.NextSibling {
		if f(n) {
			walk(n, f)
		}
	}
}

func doWork(url string) ([]string, error) {
    // 访问URL，解析html
	req, err := http.NewRequest(http.MethodGet, url, nil)
	if err != nil {
		return nil, err
	}

	ctx := req.Context()
	ctx, cancel := context.WithTimeout(ctx, timeout)
	defer cancel()

	req = req.WithContext(ctx)
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()

	if res.StatusCode/100 != 2 {
		return nil, fmt.Errorf("unexcepted status code: %v", res.StatusCode)
	}

	node, err := html.Parse(res.Body)
	if err != nil {
		return nil, err
	}

    // 遍历结点
    // 把期待的结果存到某个地方

	var results = make(map[string]string)
	walk(node, func(node *html.Node) bool {
		if node.Type == html.ElementNode {
			for _, attr := range node.Attr {
				if attr.Key == "href" {
					if matched, err := regexp.MatchString("magnet:.*", attr.Val); err != nil {
						log.Println("error when iterating through DOM: ", err)
						return false
					} else if matched {
						var content string
						for child := node.FirstChild; child != nil; child = child.NextSibling {
							if child.Type == html.TextNode {
								content = child.Data
								break
							}
						}
						results[content] = attr.Val
						return false
					}
				}
			}
		}
		return true
    })
    // 想的话发个邮件什么的

    // 最后返回要添加回队列的URL
    // 我这段程序节选自一个网页监测的片段，因为是要监测同一个页面，所以把原来的页面URL重新放回去就好
	return []string{url}, nil
}

func putTasks(ch chan string, tasks ...string) {
	for _, task := range tasks {
		ch <- task
	}
}

func main() {
    // 初始化
	flag.Parse()

	urls := make(chan string)

    // 初始化：这里把要做的任务放进channel里面
	go putTasks(urls, flag.Args()...)

    // 大循环：
	for task := range urls {
		log.Print("visiting ", task)
		start := time.Now()

        // 干活
		results, err := doWork(task)
		if err != nil {
			log.Print("failed to process url: ", task, ": ", err)
			continue
		}
		go putTasks(urls, results...)

        // 两次间隔如果小于预期间隔，就睡会儿
		duration := time.Now().Sub(start)
		if duration < interval {
			time.Sleep(interval - duration)
		}
	}
}