route-parser.js

import { config } from '../config.js';
import fetch from 'node-fetch';
import * as cheerio from 'cheerio';
import { t } from '../i18n/index.js';
import { getStravaAccessToken } from './strava-token-store.js';

export class RouteParser {
  static translate(language, key, params = {}) {
    return t(language || config.i18n.defaultLanguage, key, params, {
      fallbackLanguage: config.i18n.fallbackLanguage,
      withMissingMarker: config.isDev
    });
  }

  /**
   * Check if the URL is from a supported provider that we can parse
   * @param {string} url 
   * @returns {boolean}
   */
  static isKnownProvider(url) {
    return Object.values(config.routeProviders).some(provider =>
      provider.patterns.some(pattern => pattern.test(url))
    );
  }

  /**
   * Check if the string is a valid URL
   * @param {string} url 
   * @returns {boolean}
   */
  static isValidRouteUrl(url) {
    try {
      new URL(url);
      return true;
    } catch {
      return false;
    }
  }

  /**
   * Get route provider for the URL
   * @param {string} url 
   * @returns {string|null}
   */
  static getRouteProvider(url) {
    for (const [name, provider] of Object.entries(config.routeProviders)) {
      if (provider.patterns.some(pattern => pattern.test(url))) {
        return name;
      }
    }
    return null;
  }

  /**
   * Find the first supported route URL inside an arbitrary text blob.
   * @param {string} text
   * @returns {string|null}
   */
  static extractFirstKnownRouteUrl(text) {
    const urls = this.extractKnownRouteUrls(text);
    return urls[0] || null;
  }

  /**
   * Find all supported route URLs inside an arbitrary text blob in discovery order.
   * @param {string} text
   * @returns {string[]}
   */
  static extractKnownRouteUrls(text) {
    if (!text) return [];

    const urlPattern = /https?:\/\/[^\s<>"]+/g;
    const urls = text.match(urlPattern) || [];
    return urls.filter(url => this.isKnownProvider(url));
  }

  /**
   * Extract route ID from URL for known providers
   * @param {string} url 
   * @returns {string|null}
   */
  static getRouteId(url) {
    if (!this.isKnownProvider(url)) return null;
    const match = url.match(/\d+$/);
    return match ? match[0] : null;
  }

  /**
   * Parse route details from URL
   * @param {string} url 
   * @returns {Promise<{distance: number, duration: number, error?: string}|null>}
   */
  static async parseRoute(url) {
    // If it's not a known provider, don't try to parse but don't return an error
    if (!this.isKnownProvider(url)) {
      console.warn(`[RouteParser] URL is not from a supported route provider: ${url}`);
      return null;
    }

    const provider = this.getRouteProvider(url);
    if (!provider) {
      console.warn(`[RouteParser] Could not determine route provider for URL: ${url}`);
      return null;
    }

    // Strava requires OAuth — use API instead of HTML scraping
    if (provider === 'strava') {
      return await this.parseStravaViaApi(url);
    }

    try {
      const response = await fetch(url);

      if (!response.ok) {
        console.warn(`[RouteParser] Failed to fetch route data: ${response.status} ${response.statusText} for URL: ${url}`);
        return null;
      }

      const html = await response.text();
      const $ = cheerio.load(html);

      let result;
      switch (provider) {
        case 'ridewithgps':
          result = this.parseRideWithGPSRoute($, url);
          break;
        case 'komoot':
          result = this.parseKomootRoute($);
          break;
        case 'garmin':
          result = this.parseGarminRoute($, url);
          break;
        default:
          console.warn(`[RouteParser] Unsupported provider: ${provider} for URL: ${url}`);
          return null;
      }

      if (!result) {
        console.warn(`[RouteParser] Could not parse route data from ${provider} for URL: ${url}`);
        return null;
      }

      return result;
    } catch (error) {
      console.warn(`[RouteParser] Error parsing route: ${error.message} for URL: ${url}`);
      return null;
    }
  }

  /**
   * Process route information
   * @param {string} url - Route URL
   * @param {{language?: string}} options - Localization options
   * @returns {{routeLink: string, distance?: number, duration?: number, error?: string}} - Route information
   */
  static async processRouteInfo(url, options = {}) {
    const language = options.language;
    if (!this.isValidRouteUrl(url)) {
      return {
        error: this.translate(language, 'utils.routeParser.invalidUrl'),
        routeLink: url
      };
    }

    if (this.isKnownProvider(url)) {
      const result = await this.parseRoute(url);

      // Create a response object with the route link
      const response = { routeLink: url };

      // Add any available data from the parser
      if (result) {
        if (result.distance) response.distance = result.distance;
        if (result.duration) response.duration = result.duration;
      }

      return response;
    }

    // For non-supported providers, just return the URL without error
    return { routeLink: url };
  }

  /**
   * Parse Strava route/activity via the Strava API v3 (requires OAuth credentials).
   * @param {string} url
   * @returns {Promise<{distance?: number, duration?: number}|null>}
   */
  static async parseStravaViaApi(url) {
    const { clientId, clientSecret } = config.strava;
    if (!clientId || !clientSecret) {
      console.warn('[RouteParser] Strava API credentials not configured. Skipping Strava URL.');
      return null;
    }
    try {
      const id = this.getRouteId(url);
      if (!id) {
        console.warn(`[RouteParser] Could not extract ID from Strava URL: ${url}`);
        return null;
      }
      const isActivity = url.includes('/activities/');
      const token = await getStravaAccessToken(clientId, clientSecret);
      const endpoint = isActivity
        ? `https://www.strava.com/api/v3/activities/${id}`
        : `https://www.strava.com/api/v3/routes/${id}`;
      const response = await fetch(endpoint, { headers: { Authorization: `Bearer ${token}` } });
      if (!response.ok) {
        console.warn(`[RouteParser] Strava API error: ${response.status} ${response.statusText} for URL: ${url}`);
        return null;
      }
      const data = await response.json();
      const distanceKm = data.distance / 1000;
      const rawDurationSeconds = isActivity ? data.moving_time : data.estimated_moving_time;
      // Fallback to 20 km/h estimate if API field is missing/zero (can happen for some routes)
      const durationMinutes = rawDurationSeconds
        ? Math.round(rawDurationSeconds / 60)
        : (distanceKm ? Math.round((distanceKm / 20) * 60) : null);
      const result = {};
      if (distanceKm) result.distance = Math.round(distanceKm);
      if (durationMinutes) result.duration = durationMinutes;
      return Object.keys(result).length > 0 ? result : null;
    } catch (error) {
      console.warn(`[RouteParser] Error calling Strava API: ${error.message} for URL: ${url}`);
      return null;
    }
  }

  /**
   * Parse RideWithGPS route details
   * @param {cheerio.Root} $ 
   * @param {string} url
   * @returns {{distance?: number, duration?: number}|null}
   */
  static parseRideWithGPSRoute($, url) {
    try {
      let distance, duration;
      const isActivity = url && url.includes('/trips/');

      // Look for the meta description tag
      const ogDescription = $('meta[property="og:description"]').attr('content');

      if (ogDescription) {
        // Extract distance in kilometers
        const distanceMatch = ogDescription.match(/(\d+(?:\.\d+)?)\s*km/);
        if (distanceMatch) {
          distance = parseFloat(distanceMatch[1]);
        }
      }

      // Fallback for distance if not found in og:description
      if (!distance) {
        const distanceText = $('.route-stats').find('.distance').text();
        const distanceMatch = distanceText.match(/(\d+(?:\.\d+)?)\s*km/);
        if (distanceMatch) {
          distance = parseFloat(distanceMatch[1]);
        } else {
          console.warn('[RouteParser] Could not extract distance from RideWithGPS route');
        }
      }

      if (isActivity) {
        // For activities/trips, duration is usually found in a table row
        const totalDurationTd = $('td.metric-label').filter(function () {
          return $(this).text().trim() === 'Total Duration:';
        });

        if (totalDurationTd.length) {
          const durationText = totalDurationTd.next('td.data').text().trim();
          const durationParts = durationText.split(':');
          if (durationParts.length >= 2) {
            const hours = parseInt(durationParts[0] || '0', 10);
            const minutes = parseInt(durationParts[1] || '0', 10);
            const seconds = parseInt(durationParts[2] || '0', 10);
            duration = hours * 60 + minutes + (seconds >= 30 ? 1 : 0);
          }
        }
      } else {
        // For routes, fallback to previous method if it still exists
        const durationText = $('.route-stats').find('.time').text();
        const durationMatch = durationText.match(/(?:(\d+)h\s*)?(?:(\d+)m)?/);
        if (durationMatch && (durationMatch[1] || durationMatch[2])) {
          const hours = parseInt(durationMatch[1] || '0', 10);
          const minutes = parseInt(durationMatch[2] || '0', 10);
          duration = hours * 60 + minutes;
        }
      }

      // Return any data we were able to parse
      const result = {};
      if (distance) result.distance = distance;
      if (duration) result.duration = duration;

      // Only return null if we couldn't parse anything
      return Object.keys(result).length > 0 ? result : null;
    } catch (error) {
      console.warn(`[RouteParser] Error parsing RideWithGPS route: ${error.message} for URL: ${url}`);
      return null;
    }
  }

  /**
   * Parse Garmin Connect activity/course details
   * @param {cheerio.Root} $
   * @param {string} url
   * @returns {{distance?: number, duration?: number}|null}
   */
  static parseGarminRoute($, url) {
    try {
      let distance, duration;

      const metaDescription = $('meta[property="og:description"]').attr('content');

      if (!metaDescription) {
        console.warn('[RouteParser] Could not find og:description tag for Garmin route');
        return null;
      }

      // Activity: "Distance 57.01 km | Time 2:02:59 | Speed 27.8 kph | Elevation 104 m"
      const distanceMatch = metaDescription.match(/Distance\s+([\d.]+)\s*km/);
      if (distanceMatch) {
        distance = parseFloat(distanceMatch[1]);
      }

      // Duration in H:MM:SS format
      const durationMatch = metaDescription.match(/Time\s+(\d+):(\d+):(\d+)/);
      if (durationMatch) {
        const hours = parseInt(durationMatch[1], 10);
        const minutes = parseInt(durationMatch[2], 10);
        const seconds = parseInt(durationMatch[3], 10);
        duration = hours * 60 + minutes + (seconds >= 30 ? 1 : 0);
      }

      const result = {};
      if (distance) result.distance = distance;
      if (duration) result.duration = duration;

      return Object.keys(result).length > 0 ? result : null;
    } catch (error) {
      console.warn(`[RouteParser] Error parsing Garmin route: ${error.message}`);
      return null;
    }
  }

  static parseKomootRoute($) {
    try {
      let distance, duration;

      // Look for the meta description tag
      const metaDescription = $('meta[property="og:description"]').attr('content');

      if (!metaDescription) {
        console.warn('[RouteParser] Could not find og:description tag for Komoot route');
        return null;
      }

      // Example content: "Valery went on an outdoor adventure with komoot! Distance: 57.0 km | Duration: 02:17 h"
      // Distance parse: 57.6 km
      const distanceMatch = metaDescription.match(/(\d+(?:\.\d+)?)\s*km/);
      if (distanceMatch) {
        distance = parseFloat(distanceMatch[1]);
      } else {
        console.warn('[RouteParser] Could not extract distance from Komoot route og:description');
      }

      // Duration parse: 02:03 h
      const durationMatch = metaDescription.match(/(?:(\d+):)?(\d+)\s*h/);
      if (durationMatch) {
        const hours = parseInt(durationMatch[1] || '0', 10);
        const minutes = parseInt(durationMatch[2] || '0', 10);
        duration = hours * 60 + minutes;
      } else {
        console.warn('[RouteParser] Could not extract duration from Komoot route og:description');
      }

      // Return any data we were able to parse
      const result = {};
      if (distance) result.distance = distance;
      if (duration) result.duration = duration;

      // Only return null if we couldn't parse anything
      return Object.keys(result).length > 0 ? result : null;
    } catch (error) {
      console.warn(`[RouteParser] Error parsing Komoot route: ${error.message}`);
      return null;
    }
  }
}