package main

import (
	"github.com/jbowtie/gokogiri"
	"github.com/pebbe/util"

	"bytes"
	"encoding/xml"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"os"
	"strings"
	"time"
)

type Rss struct {
	XMLName xml.Name `xml:"feed"`
	Items   []ItemT  `xml:"entry"`
}

type ItemT struct {
	Title      TitleT   `xml:"title"`
	Published  string   `xml:"published"`
	Updated    string   `xml:"updated"`
	Nstag      []string `xml:"nstag"`
	Nslabeltag []string `xml:"nslabeltag"`
	UnixTime   int64    `xml:"unixTime"`
	ID         string   `xml:"id"`
	Link       []LinkT  `xml:"link"`
	Data       []byte   `xml:",innerxml"`
}

type TitleT struct {
	Type string `xml:"type,attr"`
	Text string `xml:",chardata"`
}

type LinkT struct {
	Type string `xml:"type,attr"`
	Href string `xml:"href,attr"`
}

var (
	x = util.CheckErr
	w = util.WarnErr
	//	agent = "AhrefsBot/7.0"
	agent = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36"
)

func exists(filename string) bool {
	_, err := os.Stat(filename)
	return err == nil
}

func fileDate(filename string) string {
	b, err := os.ReadFile(filename)
	if err != nil {
		return ""
	}
	s := string(b)
	i1 := strings.Index(s, "<unixTime>") + 10
	i2 := strings.Index(s, "</unixTime>")
	return s[i1:i2]
}

func main() {
	resp, err := http.Get("https://www.vrt.be/vrtnws/nl.rss.headlines.xml")
	x(err)
	body, err := io.ReadAll(resp.Body)
	x(err)
	x(resp.Body.Close())

	var rss Rss
	x(xml.Unmarshal(body, &rss))

	if len(rss.Items) == 0 {
		x(fmt.Errorf("len(rss.Items) == 0"))
	}

	for _, item := range rss.Items {
		t, err := time.Parse(time.RFC3339Nano, item.Published)
		if err != nil {
			t, err = time.Parse(time.RFC1123, item.Published)
		}
		x(err)
		t2, err := time.Parse(time.RFC3339Nano, item.Updated)
		if err != nil {
			t2, _ = time.Parse(time.RFC1123, item.Updated)
		}
		if t2.After(t) {
			t = t2
		}
		year, week := t.ISOWeek()
		dirname := fmt.Sprintf("/net/corpora/nlnieuws/VRT/%d/%02d", year, week)
		filename := dirname + "/" + url.PathEscape(strings.TrimPrefix(item.ID, "https://vrtnws.be/"))

		ts := fmt.Sprintf("%d", t.Unix())
		needUpdate := fileDate(filename+".xml") != ts

		x(os.MkdirAll(dirname, 0777))
		fp, err := os.Create(filename + ".xml")
		x(err)
		_, err = fp.WriteString("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<item>\n")
		x(err)
		_, err = fmt.Fprintf(fp, "<unixTime>%d</unixTime>", t.Unix())
		x(err)
		_, err = fp.Write(item.Data)
		x(err)
		_, err = fp.WriteString("</item>\n")
		x(err)
		x(fp.Close())
		x(os.Chtimes(filename+".xml", t, t))

		var link string
		for _, l := range item.Link {
			if l.Type == "text/html" {
				link = l.Href
			}
		}
		if !doArticle(filename, link, item.Title.Text, item.Nstag, item.Nslabeltag, t, needUpdate) {
			x(os.Remove(filename + ".xml"))
		}
	}
}

func doArticle(filename string, url string, title string, tags []string, labels []string, timestamp time.Time, needUpdate bool) bool {
	if needUpdate {
		_ = os.Remove(filename + ".err")
		_ = os.Remove(filename + ".txt")
		_ = os.Remove(filename + ".html")
		_ = os.Remove(filename + ".skip")
	} else {
		if exists(filename+".txt") || exists(filename+".skip") {
			return true
		}
	}
	time.Sleep(2 * time.Second)

	req, err := http.NewRequest("GET", url, nil)
	x(err)
	req.Header.Set("User-Agent", agent)

	client := &http.Client{}
	resp, err := client.Do(req)
	x(err)
	body, err := io.ReadAll(resp.Body)
	x(err)
	x(resp.Body.Close())

	/*
		s := string(body)
		ok := true
		i1 := strings.Index(s, `type="application/ld+json"`)
		if i1 < 0 {
			ok = false
		} else {
			i1 += strings.Index(s[i1:], `>`) + 1
			i2 := i1 + strings.Index(s[i1:], `</script>`)
			if i2 < i1 {
				ok = false
			} else {
				s = s[i1:i2]
			}
		}
		if !ok {
			_ = w(fmt.Errorf("script jsonld not found: %s", url))

			fp, err := os.Create(filename + ".err")
			x(err)
			_, err = fmt.Fprintf(fp, "script jsonld not found: %s\n", url)
			x(err)
			x(fp.Close())
			x(os.Chtimes(filename+".err", timestamp, timestamp))

			fp, err = os.Create(filename + ".html")
			x(err)
			_, err = fp.Write(body)
			x(err)
			x(fp.Close())
			x(os.Chtimes(filename+".html", timestamp, timestamp))

			return false
		}
		fp, err := os.Create(filename + ".json")
		x(err)
		_, err = fp.WriteString(s)
		x(err)
		x(fp.Close())
		x(os.Chtimes(filename+".json", timestamp, timestamp))
	*/

	var buf bytes.Buffer

	doc, err := gokogiri.ParseHtml(body)
	x(err)

	root := doc.Root()

	lnn, err := root.Search(`//head/link[@rel="canonical"]/@href`)
	x(err)
	for _, ln := range lnn {
		if strings.Contains(ln.String(), "/liveblog/") {
			fp, err := os.Create(filename + ".skip")
			x(err)
			_, err = fp.WriteString("liveblog\n")
			x(err)
			x(fp.Close())
			x(os.Chtimes(filename+".skip", timestamp, timestamp))
			return true
		}
	}

	if len(tags) == 0 {
		_, err = fmt.Fprintln(&buf, "##META text cat =")
		x(err)
	} else {
		for _, tag := range tags {
			_, err = fmt.Fprintf(&buf, "##META text cat = %s\n", tag)
			x(err)
		}
	}
	if len(labels) == 0 {
		_, err = fmt.Fprintln(&buf, "##META text label =")
		x(err)
	} else {
		for _, label := range labels {
			_, err = fmt.Fprintf(&buf, "##META text label = %s\n", label)
			x(err)
		}
	}

	_, err = buf.WriteString(clean(title))
	x(err)

	fouten := make([]string, 0)

	found := false
	pp, err := root.Search(`//div[@data-sentry-component="ArticleHeading"]//p[contains(@class,"prose-article-body-r")]`)
	x(err)
	for _, p := range pp {
		_, err = fmt.Fprint(&buf, clean(p.Content()))
		x(err)
		found = true
	}
	if !found {
		fouten = append(fouten, fmt.Sprintf("no heading: %s", url))
		_ = w(fmt.Errorf("no heading: %s", url))
	}

	found = false
	pp, err = root.Search(
		`//div[@data-sentry-component="ArticleText"]//p[contains(@class,"prose-article-body-r")]` +
			` | ` +
			`//div[@data-sentry-component="ArticleTitle"]//h2`)
	x(err)
	for _, p := range pp {
		_, err = fmt.Fprint(&buf, clean(p.Content()))
		x(err)
		found = true
	}
	if !found {
		fouten = append(fouten, fmt.Sprintf("no text: %s", url))
		_ = w(fmt.Errorf("no text: %s", url))
	}

	if len(fouten) > 0 {
		fp, err := os.Create(filename + ".err")
		x(err)
		for _, fout := range fouten {
			_, err = fp.WriteString(fout)
			x(err)
		}
		x(err)
		x(fp.Close())
		x(os.Chtimes(filename+".err", timestamp, timestamp))

		fp, err = os.Create(filename + ".html")
		x(err)
		_, err = fp.Write(body)
		x(err)
		x(fp.Close())
		x(os.Chtimes(filename+".html", timestamp, timestamp))

		return false
	}

	fp, err := os.Create(filename + ".txt")
	x(err)
	_, err = fp.Write(buf.Bytes())
	x(err)
	x(fp.Close())
	x(os.Chtimes(filename+".txt", timestamp, timestamp))

	return true
}

func clean(s string) string {
	s = strings.Join(strings.Fields(s), " ")
	n := len(s)
	if n == 0 {
		return ""
	}
	if n > 0 {
		if strings.ContainsAny(s[n-1:], ".!?") {
			return s + "\n"
		}
	}
	if n > 1 {
		s2 := s[n-2:]
		if s2 == `."` || s2 == `!"` || s2 == `?"` || s2 == `.'` || s2 == `!'` || s2 == `?'` {
			return s + "\n"
		}
	}
	return s + ".\n"
}