graphhopper:
  datareader.file: /data/osm/vietnam-latest.osm.pbf
  graph.location: /data/gh_cache
  graph.encoded_values: surface,road_class,max_speed,road_environment,bike_network

  # Cấu hình các hồ sơ phương tiện chuyên biệt cho thị trường Việt Nam
  profiles:
    # 1. Hồ sơ Xe Máy Giao Hàng (Motorcycle Courier)
    - name: motorcycle_courier
      custom_model:
        distance_influence: 70
        speed:
          # Ưu tiên các loại đường đô thị thông dụng
          - if: road_class == MOTORWAY
            multiply_by: 0.0 # Cấm xe máy đi vào đường cao tốc ô tô
          - if: road_class == TRUNK || road_class == PRIMARY
            limit_to: 50
          - if: road_class == SECONDARY || road_class == TERTIARY
            limit_to: 40
          - if: road_class == RESIDENTIAL
            limit_to: 30
          - if: road_class == LIVING_STREET || road_class == SERVICE
            limit_to: 20
        priority:
          - if: road_class == MOTORWAY
            multiply_by: 0.0
          - if: surface == UNPAVED || surface == DIRT
            multiply_by: 0.6 # Giảm ưu tiên đường đất xấu khi trời mưa

    # 2. Hồ sơ Xe Tải Giao Hàng Nhỏ (Delivery Van)
    - name: delivery_van
      custom_model:
        distance_influence: 90
        speed:
          - if: road_class == RESIDENTIAL && road_environment == NARROW
            limit_to: 15
        priority:
          - if: road_class == TRACK || road_class == FOOTWAY || road_class == PATH
            multiply_by: 0.0 # Tuyệt đối cấm ô tô đi vào ngõ ngách đi bộ

  # Bật thuật toán Contraction Hierarchies để truy vấn ma trận < 2ms
  profiles_ch:
    - profile: motorcycle_courier
    - profile: delivery_van

  # Bật thuật toán Landmarks để hỗ trợ Custom Model thời gian thực
  profiles_lm:
    - profile: motorcycle_courier

server:
  application_connectors:
    - type: http
      port: 8989
      bind_host: 0.0.0.0
  admin_connectors:
    - type: http
      port: 8990
      bind_host: 0.0.0.0

apiVersion: v1
kind: ConfigMap
metadata:
  name: graphhopper-config
  namespace: logistics
data:
  graphhopper.yml: |
    graphhopper:
      datareader.file: /data/osm/vietnam-latest.osm.pbf
      graph.location: /data/gh_cache
      graph.dataaccess: RAM_STORE
      profiles:
        - name: car
          custom_model:
            distance_influence: 70
        - name: motorcycle
          custom_model:
            distance_influence: 85
      profiles_ch:
        - profile: car
        - profile: motorcycle
    server:
      application_connectors:
        - type: http
          port: 8989
          bind_host: 0.0.0.0
      admin_connectors:
        - type: http
          port: 8990
          bind_host: 0.0.0.0
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: graphhopper-blue
  namespace: logistics
  labels:
    app: graphhopper
    variant: blue
spec:
  serviceName: graphhopper-headless
  replicas: 2
  selector:
    matchLabels:
      app: graphhopper
      variant: blue
  template:
    metadata:
      labels:
        app: graphhopper
        variant: blue
    spec:
      containers:
        - name: graphhopper
          image: ghcr.io/graphhopper/graphhopper:10.0
          imagePullPolicy: IfNotPresent
          env:
            - name: JAVA_OPTS
              value: >-
                -server
                -Xms1024m
                -Xmx1536m
                -XX:MaxDirectMemorySize=4096m
                -XX:+UseG1GC
                -XX:InitiatingHeapOccupancyPercent=45
                -XX:G1ReservePercent=15
                -Djava.awt.headless=true
          command: ["java"]
          args:
            - "-jar"
            - "/graphhopper/graphhopper-web.jar"
            - "server"
            - "/config/graphhopper.yml"
          ports:
            - name: http
              containerPort: 8989
            - name: admin
              containerPort: 8990
          resources:
            requests:
              cpu: "2000m"
              memory: "5120Mi"
            limits:
              cpu: "4000m"
              memory: "6144Mi"
          volumeMounts:
            - name: osm-data
              mountPath: /data
            - name: config-volume
              mountPath: /config
          # Cấu hình Health Probes chịu tải giai đoạn pre-processing
          startupProbe:
            httpGet:
              path: /health
              port: admin
            initialDelaySeconds: 30
            periodSeconds: 10
            timeoutSeconds: 5
            failureThreshold: 60 # Cho phép chờ tối đa 600 giây để nạp CH graph
          readinessProbe:
            httpGet:
              path: /health
              port: admin
            initialDelaySeconds: 10
            periodSeconds: 5
            timeoutSeconds: 3
            failureThreshold: 3
          livenessProbe:
            httpGet:
              path: /health
              port: admin
            initialDelaySeconds: 60
            periodSeconds: 15
            timeoutSeconds: 5
            failureThreshold: 3
      volumes:
        - name: config-volume
          configMap:
            name: graphhopper-config
  volumeClaimTemplates:
    - metadata:
        name: osm-data
      spec:
        accessModes: ["ReadWriteOnce"]
        storageClassName: gp3-nvme # StorageClass SSD tốc độ cao AWS gp3
        resources:
          requests:
            storage: 50Gi
---
apiVersion: v1
kind: Service
metadata:
  name: graphhopper-service
  namespace: logistics
spec:
  type: ClusterIP
  selector:
    app: graphhopper
    variant: blue # Service Selector định tuyến tới Active variant (Blue-Green)
  ports:
    - name: http
      port: 8989
      targetPort: 8989
    - name: admin
      port: 8990
      targetPort: 8990

// Package routing cung cấp client hiệu năng cao kết nối tới cụm GraphHopper Kubernetes.
// Hỗ trợ HTTP/2 keep-alive, connection pooling và giải mã JSON tốc độ cao.
package routing

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net"
	"net/http"
	"sync"
	"time"
)

// Coordinate biểu diễn tọa độ kinh độ và vĩ độ
type Coordinate struct {
	Lat float64 `json:"lat"`
	Lng float64 `json:"lng"`
}

// RouteRequest cấu trúc tham số gửi tới GraphHopper API
type RouteRequest struct {
	Points    [][]float64 `json:"points"` // [lng, lat]
	Profile   string      `json:"profile"`
	Elevation bool        `json:"elevation"`
	Optimize  bool        `json:"optimize"`
	PointsEncoded bool    `json:"points_encoded"`
}

// RouteResponse kết quả định tuyến trả về
type RouteResponse struct {
	Paths []struct {
		Distance float64     `json:"distance"` // mét
		Time     int64       `json:"time"`     // mili-giây
		Points   interface{} `json:"points"`
	} `json:"paths"`
	Hints map[string]interface{} `json:"hints"`
}

// Client quản lý kết nối và thực thi truy vấn định tuyến
type Client struct {
	baseURL    string
	httpClient *http.Client
	mu         sync.RWMutex
	isHealthy  bool
}

// NewClient khởi tạo routing client với cấu hình Connection Pool tối ưu
func NewClient(baseURL string) *Client {
	transport := &http.Transport{
		Proxy: http.ProxyFromEnvironment,
		DialContext: (&net.Dialer{
			Timeout:   1500 * time.Millisecond,
			KeepAlive: 60 * time.Second,
		}).DialContext,
		MaxIdleConns:        500,
		MaxIdleConnsPerHost: 100,
		IdleConnTimeout:     90 * time.Second,
		TLSHandshakeTimeout: 2 * time.Second,
		DisableCompression:  true, // Tắt nén Gzip trong mạng LAN K8s để giảm tải CPU
	}

	return &Client{
		baseURL: baseURL,
		httpClient: &http.Client{
			Transport: transport,
			Timeout:   3 * time.Second,
		},
		isHealthy: true,
	}
}

// CalculateRoute tính toán lộ trình tối ưu giữa điểm xuất phát và điểm đến
func (c *Client) CalculateRoute(ctx context.Context, start, end Coordinate, profile string) (float64, time.Duration, error) {
	reqPayload := RouteRequest{
		Points: [][]float64{
			{start.Lng, start.Lat},
			{end.Lng, end.Lat},
		},
		Profile:       profile,
		Elevation:     false,
		PointsEncoded: false,
	}

	bodyBytes, err := json.Marshal(reqPayload)
	if err != nil {
		return 0, 0, fmt.Errorf("lỗi mã hóa json: %w", err)
	}

	endpoint := fmt.Sprintf("%s/route", c.baseURL)
	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(bodyBytes))
	if err != nil {
		return 0, 0, fmt.Errorf("không thể khởi tạo request: %w", err)
	}
	httpReq.Header.Set("Content-Type", "application/json")

	// Thực hiện truy vấn với cơ chế Retry nhẹ (tối đa 2 lần)
	var resp *http.Response
	for attempt := 0; attempt < 2; attempt++ {
		resp, err = c.httpClient.Do(httpReq)
		if err == nil && resp.StatusCode == http.StatusOK {
			break
		}
		if attempt == 0 {
			time.Sleep(50 * time.Millisecond)
		}
	}

	if err != nil {
		return 0, 0, fmt.Errorf("lỗi kết nối GraphHopper K8s: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		respBody, _ := io.ReadAll(resp.Body)
		return 0, 0, fmt.Errorf("lỗi từ GraphHopper (status %d): %s", resp.StatusCode, string(respBody))
	}

	var routeResp RouteResponse
	if err := json.NewDecoder(resp.Body).Decode(&routeResp); err != nil {
		return 0, 0, fmt.Errorf("lỗi giải mã phản hồi JSON: %w", err)
	}

	if len(routeResp.Paths) == 0 {
		return 0, 0, errors.New("không tìm thấy đường đi khả dụng giữa hai tọa độ")
	}

	path := routeResp.Paths[0]
	duration := time.Duration(path.Time) * time.Millisecond

	return path.Distance, duration, nil
}