schedule_converter/parser/empty_classroom.go

package parser

import (
	"fmt"
	"log/slog"
	"net/http"
	"strings"

	"schedule_converter/client"
	"schedule_converter/config"

	"github.com/PuerkitoBio/goquery"
)

type EmptyClassroomEntry struct {
	Classroom string `json:"classroom"`
	Weekday   string `json:"weekday"`
	Periods   string `json:"periods"`
	Term      string `json:"term"`
	Weeks     string `json:"weeks"`
}

type buildingInfo struct {
	DM string `json:"dm"`
	MC string `json:"mc"`
}

type venueInfo struct {
	DM string `json:"dm"`
	MC string `json:"mc"`
}

func FetchEmptyClassrooms(httpClient *http.Client, semester, weekStart, weekEnd, campusCode string) ([]EmptyClassroomEntry, error) {
	url := config.Get().BaseURL + "/kjscx/queryKjs"
	log := slog.With("semester", semester, "week_start", weekStart, "week_end", weekEnd)
	log.Info("获取空教室数据")

	// First GET to establish session
	resp, err := httpClient.Get(url)
	if err != nil {
		return nil, fmt.Errorf("访问空教室页面失败: %w", err)
	}
	resp.Body.Close()

	// POST with query parameters
	data := fmt.Sprintf("pageXnxq=%s&pageZc1=%s&pageZc2=%s&pageXiaoqu=%s",
		semester, weekStart, weekEnd, campusCode)
	req, err := http.NewRequest("POST", url, strings.NewReader(data))
	if err != nil {
		return nil, err
	}

	req.Header = client.GetHeadersWithContentType("application/x-www-form-urlencoded")
	req.Header.Set("Referer", url)

	resp, err = httpClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("查询空教室失败: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("查询空教室失败, 状态码: %d", resp.StatusCode)
	}

	html, err := decodeResponseBody(resp)
	if err != nil {
		return nil, err
	}

	entries, err := parseEmptyClassroomHTML(html, semester, weekStart, weekEnd)
	if err != nil {
		return nil, err
	}

	log.Info("空教室数据获取完成", "count", len(entries))
	return entries, nil
}

func parseEmptyClassroomHTML(html, semester, weekStart, weekEnd string) ([]EmptyClassroomEntry, error) {
	if html == "" {
		return nil, nil
	}

	// Clean nbsp entities
	cleaned := strings.ReplaceAll(html, "&nbsp", "")
	cleaned = strings.ReplaceAll(cleaned, "&", "&")

	doc, err := goquery.NewDocumentFromReader(strings.NewReader(cleaned))
	if err != nil {
		return nil, err
	}

	dayNames := [7]string{"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"}
	periodLabels := [6]string{"1,2", "3,4", "5,6", "7,8", "9,10", "11,12"}

	var classrooms []EmptyClassroomEntry

	// Find the main data table with class="dataTable"
	doc.Find("table.dataTable").Each(func(_ int, table *goquery.Selection) {
		rows := table.Find("tr")
		if rows.Length() < 3 {
			return
		}

		// Verify this is the classroom table by checking for weekday headers
		hasWeekdayHeader := false
		rows.First().Find("th").Each(func(_ int, th *goquery.Selection) {
			text := strings.TrimSpace(th.Text())
			for _, day := range dayNames {
				if strings.Contains(text, day) {
					hasWeekdayHeader = true
					break
				}
			}
		})
		if !hasWeekdayHeader {
			return
		}

		// Build column mapping: column index -> (dayIndex, periodIndex)
		colMapping := make(map[int][2]int)

		// Start from column 1 (skip first column which is classroom name)
		colIdx := 1
		for dayIdx := 0; dayIdx < 7; dayIdx++ {
			for periodIdx := 0; periodIdx < 6; periodIdx++ {
				colMapping[colIdx] = [2]int{dayIdx, periodIdx}
				colIdx++
			}
		}

		// Process data rows (skip first 2 header rows)
		rows.Each(func(rowIdx int, row *goquery.Selection) {
			if rowIdx < 2 {
				return
			}

			cells := row.Find("td")
			if cells.Length() < 2 {
				return
			}

			// Get classroom name from first cell
			classroomName := strings.TrimSpace(cells.First().Text())
			// Filter out invalid classroom names
			if classroomName == "" || len(classroomName) < 2 {
				return
			}

			// Skip non-classroom entries like "线上网络授课"
			if strings.Contains(classroomName, "线上") || strings.Contains(classroomName, "网络") {
				return
			}

			// Collect empty slots for this classroom
			var slots []string
			weekdaySet := make(map[int]bool)
			var weekdays []string

			// Check each time slot column
			for colIdx := 1; colIdx < cells.Length(); colIdx++ {
				cell := cells.Eq(colIdx)

				// Get mapping for this column
				mapping, exists := colMapping[colIdx]
				if !exists {
					continue
				}
				dayIdx := mapping[0]
				periodIdx := mapping[1]

				// Check if cell is empty (no kjs_icon div)
				isEmpty := true
				cell.Find("div.kjs_icon").Each(func(_ int, div *goquery.Selection) {
					isEmpty = false
				})

				// Also check if cell has any content
				cellText := strings.TrimSpace(cell.Text())
				if cellText != "" {
					isEmpty = false
				}

				if isEmpty {
					dayName := dayNames[dayIdx]
					periodText := periodLabels[periodIdx]
					slot := fmt.Sprintf("%s 第%s节", dayName, periodText)
					slots = append(slots, slot)

					if !weekdaySet[dayIdx] {
						weekdaySet[dayIdx] = true
						weekdays = append(weekdays, dayName)
					}
				}
			}

			// Create entry if there are empty slots
			if len(slots) > 0 {
				weekStr := ""
				if weekStart != "" && weekEnd != "" {
					weekStr = fmt.Sprintf("%s-%s周", weekStart, weekEnd)
				}
				entry := EmptyClassroomEntry{
					Classroom: classroomName,
					Weekday:   strings.Join(weekdays, ", "),
					Periods:   strings.Join(slots, "\n"),
					Term:      semester,
					Weeks:     weekStr,
				}
				classrooms = append(classrooms, entry)
			}
		})
	})

	return classrooms, nil
}

func fetchBuildings(httpClient *http.Client, campusCode string) ([]buildingInfo, error) {
	url := config.Get().BaseURL + "/kjscx/queryJxlListBySjid"
	slog.Info("获取楼号列表", "campus", campusCode)

	data := fmt.Sprintf("id=%s", campusCode)
	req, err := http.NewRequest("POST", url, strings.NewReader(data))
	if err != nil {
		return nil, err
	}

	req.Header = client.GetHeadersWithContentType("application/x-www-form-urlencoded")
	req.Header.Set("Referer", config.Get().BaseURL+"/kjscx/queryKjs")

	resp, err := httpClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("获取楼号列表失败: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("获取楼号列表失败, 状态码: %d", resp.StatusCode)
	}

	var buildings []buildingInfo
	if err := decodeJSONResponse(resp, &buildings); err != nil {
		return nil, fmt.Errorf("解析楼号列表失败: %w", err)
	}

	return buildings, nil
}

func fetchVenues(httpClient *http.Client, buildingCode string) ([]venueInfo, error) {
	url := config.Get().BaseURL + "/kjscx/queryJxcdListBySjid"
	slog.Info("获取场地列表", "building", buildingCode)

	data := fmt.Sprintf("id=%s", buildingCode)
	req, err := http.NewRequest("POST", url, strings.NewReader(data))
	if err != nil {
		return nil, err
	}

	req.Header = client.GetHeadersWithContentType("application/x-www-form-urlencoded")
	req.Header.Set("Referer", config.Get().BaseURL+"/kjscx/queryKjs")

	resp, err := httpClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("获取场地列表失败: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("获取场地列表失败, 状态码: %d", resp.StatusCode)
	}

	var venues []venueInfo
	if err := decodeJSONResponse(resp, &venues); err != nil {
		return nil, fmt.Errorf("解析场地列表失败: %w", err)
	}

	return venues, nil
}

// TestParseEmptyClassroomHTML is a test helper function that exports the parser for testing
func TestParseEmptyClassroomHTML(html, semester, weekStart, weekEnd string) ([]EmptyClassroomEntry, error) {
	return parseEmptyClassroomHTML(html, semester, weekStart, weekEnd)
}