penguin/golifehk

datasources/kmb/QueryResult.go

raw · 3900 bytes

package kmb

import (
	"fmt"
	"sort"
	"strings"
	"time"

	query "github.com/tgckpg/golifehk/query"
	utils "github.com/tgckpg/golifehk/utils"
)

type QueryResult struct {
	Schedules *map[*RouteStop]*[]*Schedule
	Lang      string
	Error     error
	Query     *query.QueryObject

	isConsumed bool
}

func writeRouteHead(sb *strings.Builder, r *RouteStop) {
	utils.WriteMDv2Text(sb, r.RouteId)
	if r.Direction == "O" {
		sb.WriteString("↑")
	} else if r.Direction == "I" {
		sb.WriteString("↓")
	}
	if r.ServiceType != "1" {
		utils.WriteMDv2Text(sb, utils.ToPower(r.ServiceType))
	}
}

func writeShortRoute(lang *string, sb *strings.Builder, r *RouteStop) {

	if r.PrevStop() != nil {
		utils.WriteMDv2Text(sb, (*(r.PrevStop().BusStop).Name)[*lang])
		sb.WriteString(" \\> ")
	}

	sb.WriteString("*")
	utils.WriteMDv2Text(sb, (*(r.BusStop).Name)[*lang])
	sb.WriteString("*")

	if r.NextStop() != nil {
		sb.WriteString(" \\> ")
		utils.WriteMDv2Text(sb, (*(r.NextStop().BusStop).Name)[*lang])
	}

	sb.WriteString("\n")
}

func (this QueryResult) DataType() string                    { return "MarkdownV2" }
func (this QueryResult) Consumed() bool                      { return this.isConsumed }
func (this QueryResult) GetTableData() [][]map[string]string { return nil }

func (this *QueryResult) Message() (string, error) {

	if this.Error != nil {
		return "", this.Error
	}

	sb := strings.Builder{}

	if 0 < len(*this.Query.Results) {

		// Print Stop Names, then print the list of routes
		if this.Query.Key == "" {
			busStops := map[string]*BusStop{}
			for _, item := range *this.Query.Results {
				var r *RouteStop
				r = any(item).(*RouteStop)

				b := r.BusStop
				if b.Routes == nil {
					continue
				}

				busStops[b.BusStopId] = b
			}

			for _, b := range busStops {
				utils.WriteMDv2Text(&sb, (*b.Name)[this.Lang])
				sb.WriteString("\n  ")
				for _, route := range *b.Routes {
					writeRouteHead(&sb, route)
					sb.WriteString(" ")
				}
				sb.WriteString("\n")
			}

			// We got a route key
		} else {

			// We also got other search keys with 1 < Results
			// Get the ETA for this stop
			if 1 < len(*this.Query.SearchTerms) {

				now := time.Now()
				for _, item := range *this.Query.Results {
					var r *RouteStop
					r = any(item).(*RouteStop)
					writeRouteHead(&sb, r)
					sb.WriteString("\n")
					writeShortRoute(&this.Lang, &sb, r)

					for _, schedule := range *(*this.Schedules)[r] {

						if !schedule.ETA.IsZero() {

							_m := schedule.ETA.Sub(now).Minutes()

							sb.WriteString("  \\* ")
							txt := "%.0f min(s)"

							if this.Lang == "zh-Hant" {
								txt = "%.0f 分鐘"
							}

							utils.WriteMDv2Text(&sb, fmt.Sprintf(txt, _m))

							if _m < 0 {
								sb.WriteString(" 走左了？")
							}
						}

						if schedule.Remarks_en != "" {
							sb.WriteString("  \\*\\* ")
							switch this.Lang {
							case "en":
								utils.WriteMDv2Text(&sb, schedule.Remarks_en)
							case "zh-Hant":
								utils.WriteMDv2Text(&sb, schedule.Remarks_tc)
							}
						}

						sb.WriteString("\n")
					}

					sb.WriteString("\n")
				}

				// We got only the route key, proceed to list the route stops
			} else {
				// Result contains all route stops, we only need the starting one
				routes := []*RouteStop{}

				for _, item := range *this.Query.Results {
					var r *RouteStop
					r = any(item).(*RouteStop)
					if r.PrevStop() == nil {
						routes = append(routes, r)
					}
				}

				sort.Sort(ByRoute(routes))

				for _, r := range routes {
					writeRouteHead(&sb, r)
					sb.WriteString("\n")
					for {
						b := *r.BusStop
						utils.WriteMDv2Text(&sb, (*b.Name)[this.Lang])
						r = r.NextStop()
						if r == nil {
							break
						}

						sb.WriteString(" \\> ")
					}
					sb.WriteString("\n")
				}

			}
		}
	} else {
		return "", fmt.Errorf("No Results")
	}

	return sb.String(), nil
}