package arrival

import (
	"cpone-dashboard/menu/auth"
	"cpone-dashboard/menu/projects"
	"encoding/json"
	"html/template"
	"net/http"
	"strconv"
)

var tmpl *template.Template
var basePath string

const defaultPageSize = 30

func SetTemplates(t *template.Template) { tmpl = t }
func SetBasePath(p string)              { basePath = p }

type pageData struct {
	Username          string
	CurrentProject    projects.ProjectItem
	Date              string
	AvailableDates    []string
	Search            string
	Department        string
	Rows              []ArrivalRow
	FilteredRows      []ArrivalRow
	Summary           ArrivalSummary
	Departments       []DepartmentStat
	DepartmentOptions []string
	OverviewJSON      template.JS
	DepartmentJSON    template.JS
	Page              int
	PageSize          int
	HasMore           bool
	VisibleCount      int
	TotalFiltered     int
	NextPage          int
}

func toJS(v interface{}) template.JS {
	b, _ := json.Marshal(v)
	return template.JS(b)
}

func parsePage(q string) int {
	p, err := strconv.Atoi(q)
	if err != nil || p < 1 {
		return 1
	}
	return p
}

func buildArrivalData(r *http.Request) (pageData, int, error) {
	username := auth.Username(r)
	mcuID := auth.SelectedProjectID(r)
	if mcuID == 0 {
		return pageData{}, http.StatusSeeOther, nil
	}
	project, ok, err := projects.GetUserProject(username, mcuID)
	if err != nil {
		return pageData{}, http.StatusInternalServerError, err
	}
	if !ok {
		return pageData{}, http.StatusSeeOther, nil
	}

	dates, err := GetArrivalDates(mcuID)
	if err != nil {
		return pageData{}, http.StatusInternalServerError, err
	}
	selectedDate := activeDateOrLatest(dates, r.URL.Query().Get("date"), project.StartDate)
	rows, err := GetArrivalRows(mcuID, selectedDate)
	if err != nil {
		return pageData{}, http.StatusInternalServerError, err
	}
	summary, deptStats := BuildArrivalStats(rows)
	filteredRows := FilterArrivalRows(rows, r.URL.Query().Get("search"), r.URL.Query().Get("dept"))
	deptOptions := UniqueDepartments(rows)

	stationMap, err := GetStationProgress(mcuID, selectedDate)
	if err != nil {
		return pageData{}, http.StatusInternalServerError, err
	}
	for i := range filteredRows {
		filteredRows[i].Stations = stationMap[filteredRows[i].PreregisterID]
	}

	outerDepts := []map[string]any{}
	for _, d := range deptStats {
		if d.Total > 0 {
			outerDepts = append(outerDepts, map[string]any{"name": d.Name, "value": d.Total})
		}
	}
	overview := map[string]any{
		"checkedIn": summary.CheckedIn,
		"pending":   summary.Pending,
		"depts":     outerDepts,
	}

	stationStats := BuildStationChart(stationMap)
	stationLabels := make([]string, len(stationStats))
	stationCounts := make([]int, len(stationStats))
	for i, s := range stationStats {
		stationLabels[i] = s.Name
		stationCounts[i] = s.Count
	}
	stationChart := map[string]any{
		"labels": stationLabels,
		"counts": stationCounts,
	}

	page := parsePage(r.URL.Query().Get("page"))
	pagedRows, hasMore := PaginateArrivalRows(filteredRows, page, defaultPageSize)
	visibleCount := page * defaultPageSize
	if visibleCount > len(filteredRows) {
		visibleCount = len(filteredRows)
	}

	return pageData{
		Username:          username,
		CurrentProject:    project,
		Date:              selectedDate,
		AvailableDates:    dates,
		Search:            r.URL.Query().Get("search"),
		Department:        r.URL.Query().Get("dept"),
		Rows:              rows,
		FilteredRows:      pagedRows,
		Summary:           summary,
		Departments:       deptStats,
		DepartmentOptions: deptOptions,
		OverviewJSON:      toJS(overview),
		DepartmentJSON:    toJS(stationChart),
		Page:              page,
		PageSize:          defaultPageSize,
		HasMore:           hasMore,
		VisibleCount:      visibleCount,
		TotalFiltered:     len(filteredRows),
		NextPage:          page + 1,
	}, http.StatusOK, nil
}

func Index(w http.ResponseWriter, r *http.Request) {
	t := tmpl
	if t == nil {
		http.Error(w, "template not ready", http.StatusInternalServerError)
		return
	}

	data, status, err := buildArrivalData(r)
	if err != nil {
		http.Error(w, "query error", status)
		return
	}
	if status == http.StatusSeeOther {
		http.Redirect(w, r, basePath+"/projects", http.StatusSeeOther)
		return
	}

	if err := t.ExecuteTemplate(w, "base", data); err != nil {
		http.Error(w, "template error", http.StatusInternalServerError)
	}
}

func List(w http.ResponseWriter, r *http.Request) {
	t := tmpl
	if t == nil {
		http.Error(w, "template not ready", http.StatusInternalServerError)
		return
	}

	data, status, err := buildArrivalData(r)
	if err != nil {
		http.Error(w, "query error", status)
		return
	}
	if status == http.StatusSeeOther {
		http.Error(w, "unauthorized", http.StatusUnauthorized)
		return
	}

	if err := t.ExecuteTemplate(w, "arrival-list-chunk", data); err != nil {
		http.Error(w, "template error", http.StatusInternalServerError)
	}
}