package main

import (
	"fmt"
	"io"
	"regexp"
	"sort"
	"strconv"
	"strings"

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

// League is one competition as listed on the front page.
type League struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
	Path string `json:"path"` // canonical path, e.g. /ScheduleAndResults/Overview/20961
}

// Season is one entry of the season <select> on a league page.
type Season struct {
	ID    int    `json:"id"`
	Label string `json:"label"` // "2026-27"
	Path  string `json:"path"`  // a path on the site for this season
}

var (
	leaguePathRE = regexp.MustCompile(`^/ScheduleAndResults/[A-Za-z]+/(\d+)$`)
	seasonPathRE = regexp.MustCompile(`/ScheduleAndResults/[A-Za-z]+/(\d+)`)
)

// tableRows returns the <tr> children of a table. The HTML5 tree builder wraps
// stray rows in an implicit <tbody>, so the rows can sit one level deeper than
// the markup suggests. Both shapes are accepted: a scraper that indexes the
// raw markup, or one that trusts a hand-rolled parser, gets this wrong.
func tableRows(tbl *html.Node) []*html.Node {
	if tr := childElements(tbl, "tr"); len(tr) > 0 {
		return tr
	}
	var out []*html.Node
	for _, body := range childElements(tbl, "tbody") {
		out = append(out, childElements(body, "tr")...)
	}
	return out
}

// ParseLeagues reads the front page's league list. It is a plain anchor crawl:
// every /ScheduleAndResults/<section>/<id> link, deduplicated by id and sorted,
// so the crawl order never depends on document order.
func ParseLeagues(r io.Reader) ([]League, error) {
	doc, err := html.Parse(r)
	if err != nil {
		return nil, fmt.Errorf("swehockey: parse page: %w", err)
	}
	byID := map[int]string{}
	for _, a := range descendants(doc, "a") {
		m := leaguePathRE.FindStringSubmatch(attr(a, "href"))
		if m == nil {
			continue
		}
		id, err := strconv.Atoi(m[1])
		if err != nil {
			continue
		}
		name := textOf(a)
		if name == "" {
			continue
		}
		if old, ok := byID[id]; ok && old != "" {
			// A league is linked once per section (Live, Overview, Schedule).
			// Keep the first name seen; the id is what matters.
			continue
		}
		byID[id] = name
	}
	if len(byID) == 0 {
		return nil, drift(0, "", "", "front page has no league links", "0 links", "/ScheduleAndResults/<section>/<id>")
	}
	out := make([]League, 0, len(byID))
	for id, name := range byID {
		out = append(out, League{ID: id, Name: name, Path: fmt.Sprintf("/ScheduleAndResults/Schedule/%d", id)})
	}
	sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })
	return out, nil
}

// ParseSeasons reads the season selector on a league page. Group headings
// ("Cups", value="-1") are skipped; the result is sorted by id.
func ParseSeasons(leagueID int, r io.Reader) ([]Season, error) {
	doc, err := html.Parse(r)
	if err != nil {
		return nil, fmt.Errorf("swehockey: parse page: %w", err)
	}
	var out []Season
	seen := map[int]bool{}
	for _, opt := range descendants(doc, "option") {
		raw := attr(opt, "value")
		m := seasonPathRE.FindStringSubmatch(raw)
		if m == nil {
			continue // group heading such as value="-1"
		}
		id, err := strconv.Atoi(m[1])
		if err != nil || seen[id] {
			continue
		}
		seen[id] = true
		out = append(out, Season{ID: id, Label: textOf(opt), Path: raw})
	}
	if len(out) == 0 {
		return nil, drift(leagueID, "", "", "no season options in the selector", "0 options", "/ScheduleAndResults/<section>/<id>")
	}
	sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })
	return out, nil
}

// SchedulePath is the canonical schedule URL of a season id. Every view
// (Overview, Live, Schedule) of one season shares the id, so the crawler
// derives the schedule URL instead of trusting whichever link it arrived on.
func SchedulePath(seasonID int) string {
	return fmt.Sprintf("/ScheduleAndResults/Schedule/%d", seasonID)
}

func joinURL(base, path string) string {
	return strings.TrimRight(base, "/") + path
}