szczanieckiej/traffic/gzm_ztm.go

package traffic

import (
	"apiote.xyz/p/szczanieckiej/transformers"

	"bufio"
	"encoding/csv"
	"fmt"
	"io"
	"net/http"
	"os"
	"path/filepath"
	"regexp"
	"time"

	"golang.org/x/text/language"
	"golang.org/x/text/transform"
)

type GzmZtm struct {
	client http.Client
}

func (z GzmZtm) ConvertVehicles(path string) error {
	result, err := os.Create(filepath.Join(path, "vehicles.bare"))
	if err != nil {
		return fmt.Errorf("ConvertVehicles: cannot create bare file: %w", err)
	}
	defer result.Close()
	return nil
	// https://otwartedane.metropoliagzm.pl/dataset/wyposazenie-pojazdu/resource/26c3d1b4-7aa0-4006-b436-4a3f4ab63ac1
	// https://otwartedane.metropoliagzm.pl/dataset/pojazdy/resource/d4a3e7a6-d681-486d-b4e4-53d4c32559f9
	// url := "https://ztm.poznan.pl/en/dla-deweloperow/getGtfsRtFile/?file=vehicle_dictionary.csv"
	// response, err := z.client.Get(url)
	// if err != nil {
	// 	return fmt.Errorf("ConvertVehicles: cannot GET ‘%s’: %w", url, err)
	// }

	// result, err := os.Create(filepath.Join(path, "vehicles.bare"))
	// if err != nil {
	// 	return fmt.Errorf("ConvertVehicles: cannot create bare file: %w", err)
	// }
	// defer result.Close()

	// r := csv.NewReader(response.Body)
	// r.Comma = ','
	// header, err := r.Read()
	// if err != nil {
	// 	fmt.Println("Header read error")
	// 	return err
	// }
	// fields := map[string]int{}
	// for i, headerField := range header {
	// 	fields[headerField] = i
	// }

	// for {
	// 	record, err := r.Read()
	// 	if err == io.EOF {
	// 		break
	// 	}
	// 	if err != nil {
	// 		return err
	// 	}

	// 	var capabilites uint16 = 0

	// 	if record[fields["ramp"]] == "1" {
	// 		capabilites |= 0b0001
	// 	}
	// 	if record[fields["hf_lf_le"]] == "1" {
	// 		capabilites |= 0b0010
	// 	}
	// 	if record[fields["hf_lf_le"]] == "2" {
	// 		capabilites |= 0b0001_0000_0000
	// 	}
	// 	if record[fields["air_conditioner"]] == "1" {
	// 		capabilites |= 0b0100
	// 	}
	// 	if record[fields["place_for_transp_bicycles"]] == "1" {
	// 		capabilites |= 0b1000
	// 	}
	// 	if record[fields["voice_announcement_sys"]] == "1" {
	// 		capabilites |= 0b0001_0000
	// 	}
	// 	if record[fields["ticket_machine"]] == "1" {
	// 		capabilites |= 0b0010_0000
	// 	}
	// 	if record[fields["ticket_sales_by_the_driver"]] == "1" {
	// 		capabilites |= 0b0100_0000
	// 	}
	// 	if record[fields["usb_charger"]] == "1" {
	// 		capabilites |= 0b1000_0000
	// 	}

	// 	vehicle := Vehicle{
	// 		Id:           ID(record[0]),
	// 		Capabilities: capabilites,
	// 	}

	// 	bytes, err := bare.Marshal(&vehicle)
	// 	if err != nil {
	// 		return err
	// 	}
	// 	_, err = result.Write(bytes)
	// 	if err != nil {
	// 		return err
	// 	}
	// }
	// return nil
}

func (z GzmZtm) GetVersions(date time.Time) ([]Version, error) {
	url := "https://otwartedane.metropoliagzm.pl/dataset/rozklady-jazdy-i-lokalizacja-przystankow-gtfs"
	response, err := z.client.Get(url)
	if err != nil {
		return []Version{}, fmt.Errorf("GetVersions: cannot GET ‘%s’: %w", url, err)
	}
	doc, err := io.ReadAll(response.Body)
	if err != nil {
		return []Version{}, fmt.Errorf("GetVersions: cannot read whole html: %w", err)
	}

	regex, err := regexp.Compile("https://otwartedane.metropoliagzm.pl/dataset/86b5ce0c-daea-4b40-bc60-af2c80477d21/resource/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/download/schedule_([0-9]{4}).([0-9]{2}).([0-9]{2})_[0-9]{13}_[0-9]{4}.ext_gtfs.zip")
	urls := regex.FindAllStringSubmatch(string(doc), -1)

	versions := []Version{}
	for _, u := range urls {
		version, err := MakeVersion(u[1]+u[2]+u[3]+"_99991231", z.GetLocation())
		if err != nil {
			return nil, err
		}
		version.Link = u[0]
		versions = append(versions, version)
	}
	return versions, nil
}

func (z GzmZtm) GetLocation() *time.Location {
	l, _ := time.LoadLocation("Europe/Warsaw")
	return l
}

func (z GzmZtm) String() string {
	return "gzm_ztm"
}

func (z GzmZtm) RealtimeFeeds() []string {
	return []string{"http://gtfsrt.metropoliagzm.pl:1111/gtfsrt/gzm/all"}
}

func (z GzmZtm) Transformer() transform.Transformer {
	return transformers.TransformerPL
}

func (z GzmZtm) Name() string {
	return "Metropolia GZM ZTM"
}

func (z GzmZtm) Attribution() map[language.Tag]string {
	return map[language.Tag]string{
		language.Und:     "GTFS files downloaded from https://otwartedane.metropoliagzm.pl/dataset/groups/rozklady-jazdy-i-lokalizacja-przystankow-gtfs and converted to TRAFFIC",
		language.English: "GTFS files downloaded from https://otwartedane.metropoliagzm.pl/dataset/groups/rozklady-jazdy-i-lokalizacja-przystankow-gtfs and converted to TRAFFIC",
		language.Polish:  "Pliki GTFS pobrane z https://otwartedane.metropoliagzm.pl/dataset/groups/rozklady-jazdy-i-lokalizacja-przystankow-gtfs i przekonwertowane do formatu TRAFFIC",
	}
}

func (z GzmZtm) Description() map[language.Tag]string {
	return map[language.Tag]string{
		language.Und:     "Timetable for Metropolis GZM public transport organised by Metropolitan Transport Authority (ZTM)",
		language.English: "Timetable for Metropolis GZM public transport organised by Metropolitan Transport Authority (ZTM)",
		language.Polish:  "Rozkład jazdy transportu publicznego w Metropolii GZM organizowanego przez Zarząd Transportu Miejskiego (ZTM)",
	}
}

func (z GzmZtm) Flags() FeedFlags {
	return FeedFlags{
		Headsign:     HeadsignTripLastStop,
		StopIdFormat: "{{stop_id}}",
		StopName:     "{{stop_name}} | {{stop_code}}",
		LineName:     "{{route_long_name}}",
	}
}

func (z GzmZtm) FeedPrepareZip(path string) error {
	// rename stops_ext to stops
	err := os.Remove(filepath.Join(path, "stops.txt"))
	if err != nil {
		return fmt.Errorf("while removing stops: %w", err)
	}
	err = os.Rename(filepath.Join(path, "stops_ext.txt"), filepath.Join(path, "stops.txt"))
	if err != nil {
		return fmt.Errorf("while renaming stops: %w", err)
	}

	// onDemand to pickup_type

	stopsFile, err := os.Open(filepath.Join(path, "stops.txt"))
	if err != nil {
		return fmt.Errorf("while opening stops file: %w", err)
	}
	defer stopsFile.Close()
	r := csv.NewReader(bufio.NewReader(stopsFile))
	header, err := r.Read()
	if err != nil {
		return fmt.Errorf("while reading stops header: %w", err)
	}
	fields := map[string]int{}
	for i, headerField := range header {
		fields[headerField] = i
	}

	stopTypes := map[string]string{}
	for {
		record, err := r.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			return fmt.Errorf("while reading a stops record: %w", err)
		}
		stopTypeID := record[fields["stop_type_id"]]
		stopID := record[fields["stop_id"]]
		stopTypes[stopID] = stopTypeID
	}

	stopTimesFile, err := os.Open(filepath.Join(path, "stop_times.txt"))
	if err != nil {
		return fmt.Errorf("while opening stop_times file: %w", err)
	}
	defer stopTimesFile.Close()
	stopTimes2File, err := os.OpenFile(filepath.Join(path, "stop_times2.txt"), os.O_RDWR|os.O_CREATE, 0644)
	if err != nil {
		return fmt.Errorf("while opening stop_times2 file: %w", err)
	}
	defer stopTimes2File.Close()
	r = csv.NewReader(stopTimesFile)
	w := csv.NewWriter(stopTimes2File)
	header, err = r.Read()
	if err != nil {
		return fmt.Errorf("while reading stop_times header: %w", err)
	}
	header = append(header, "pickup_type")
	header = append(header, "drop_off_type")
	fields = map[string]int{}
	for i, headerField := range header {
		fields[headerField] = i
	}
	err = w.Write(header)
	if err != nil {
		return fmt.Errorf("while writing header: %w", err)
	}

	for {
		record, err := r.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			return fmt.Errorf("while reading stop_times record: %w", err)
		}
		stopID := record[fields["stop_id"]]
		switch stopTypes[stopID] {
		case "2":
			record = append(record, "3")
			record = append(record, "3")
		case "3":
			record = append(record, "0")
			record = append(record, "0")
		default:
			return fmt.Errorf("unknown stop_type_id: %s for stop: %s", stopTypes[stopID], stopID)
		}
		err = w.Write(record)
		if err != nil {
			return fmt.Errorf("while writing a record: %w", err)
		}
	}
	w.Flush()
	err = w.Error()
	if err != nil {
		return fmt.Errorf("while flushing: %w", err)
	}

	err = os.Remove(filepath.Join(path, "stop_times.txt"))
	if err != nil {
		return fmt.Errorf("while removing stop_times: %w", err)
	}
	err = os.Rename(filepath.Join(path, "stop_times2.txt"), filepath.Join(path, "stop_times.txt"))
	if err != nil {
		return fmt.Errorf("while renaming stop_times: %w", err)
	}

	// route_type 800 -> 11

	routesFile, err := os.Open(filepath.Join(path, "routes.txt"))
	if err != nil {
		return fmt.Errorf("while opening routes file: %w", err)
	}
	defer routesFile.Close()
	routes2File, err := os.OpenFile(filepath.Join(path, "routes2.txt"), os.O_RDWR|os.O_CREATE, 0644)
	if err != nil {
		return fmt.Errorf("while opening routes2 file: %w", err)
	}
	defer routes2File.Close()
	r = csv.NewReader(bufio.NewReader(routesFile))
	w = csv.NewWriter(routes2File)
	header, err = r.Read()
	if err != nil {
		return fmt.Errorf("while reading routes header: %w", err)
	}
	fields = map[string]int{}
	for i, headerField := range header {
		fields[headerField] = i
	}
	err = w.Write(header)
	if err != nil {
		return fmt.Errorf("while writing routes header: %w", err)
	}

	for {
		record, err := r.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			return fmt.Errorf("while reading a route record: %w", err)
		}
		if record[fields["route_type"]] == "800" {
			record[fields["route_type"]] = "11"
		}
		err = w.Write(record)
		if err != nil {
			return fmt.Errorf("while writing a route record: %w", err)
		}
	}
	w.Flush()
	err = os.Remove(filepath.Join(path, "routes.txt"))
	if err != nil {
		return fmt.Errorf("while removing routes: %w", err)
	}
	err = os.Rename(filepath.Join(path, "routes2.txt"), filepath.Join(path, "routes.txt"))
	if err != nil {
		return fmt.Errorf("while renaming routes: %w", err)
	}
	return nil
}