fix: Add fallback version parsing for regional Play Store pages (fixes #521) (#522)

* fix: issue521
* fix: all test
* test: add
* chore: remove debugging log
* Update lib/src/play_store_search_api.dart

Author: youngkiu

lib/src/play_store_search_api.dart

@@ -279,14 +279,112 @@ extension PlayStoreResults on PlayStoreSearchAPI {
       final storeVersion = versionElement.substring(
           storeVersionStartIndex, storeVersionEndIndex);
 
-      // storeVersion might be: 'Varies with device', which is not a valid version.
-      version = Version.parse(storeVersion).toString();
+      if (debugLogging) {
+        print('upgrader: PlayStoreResults.redesignedVersion: extracted storeVersion="$storeVersion"');
+      }
+
+      // storeVersion might be empty, null, or 'Varies with device', which is not a valid version.
+      // Validate before parsing
+      if (storeVersion.isEmpty) {
+        return null;
+      }
+
+      // Try to parse the version string
+      try {
+        version = Version.parse(storeVersion).toString();
+        if (debugLogging) {
+          print('upgrader: PlayStoreResults.redesignedVersion: successfully parsed version="$version"');
+        }
+      } on FormatException catch (e) {
+        if (debugLogging) {
+          print('upgrader: PlayStoreResults.redesignedVersion: invalid version format "$storeVersion": $e');
+        }
+        // If version parsing failed, try alternative pattern (for regional pages)
+        version = _parseVersionAlternative(response, debugLogging);
+      }
     } catch (e) {
       if (debugLogging) {
         print('upgrader: PlayStoreResults.redesignedVersion exception: $e');
       }
+      // If the main parsing failed, try alternative pattern (for regional pages)
+      version = _parseVersionAlternative(response, debugLogging);
     }
 
     return version;
   }
+
+  /// Alternative version parsing for regional Play Store pages (e.g., Korean, Bengali)
+  ///
+  /// When the main parsing method fails on regional pages, this method tries multiple
+  /// fallback patterns to extract version information from the Play Store JSON data.
+  ///
+  /// Patterns tried:
+  /// 1. JSON key pattern: "XXX":[[["version" where XXX is a numeric key (common: 140-145)
+  String? _parseVersionAlternative(Document response, bool debugLogging) {
+    try {
+      final scripts = response.getElementsByTagName("script");
+
+      // Pattern 1: Try common JSON data keys where version info appears (140-145)
+      // These keys represent version data in Play Store's internal structure
+      /*
+       * The keys 140-145 were determined by inspecting the Play Store's page source and
+       * network responses. In the Play Store's internal JSON data structure, the version
+       * information for an app is often found under numeric keys in this range.
+       * These keys are not documented by Google and may change if the Play Store's
+       * internal structure changes. If version extraction fails in the future,
+       * maintainers should re-examine the Play Store's page source or network traffic
+       * to identify the new keys where version information is stored, and update this
+       * list accordingly.
+       */
+      for (var key in [140, 141, 142, 143, 144, 145]) {
+        final pattern = '"$key":[[["';
+        const patternEndOfString = '"';
+
+        final versionElements = scripts.where(
+            (element) => element.text.contains(pattern));
+
+        if (versionElements.isNotEmpty) {
+          final versionElement = versionElements.first.text;
+          final versionStartIndex =
+              versionElement.indexOf(pattern) + pattern.length;
+
+          if (versionStartIndex >= pattern.length) {
+            final versionEndIndex = versionStartIndex +
+                versionElement
+                    .substring(versionStartIndex)
+                    .indexOf(patternEndOfString);
+
+            if (versionEndIndex > versionStartIndex) {
+              final storeVersion =
+                  versionElement.substring(versionStartIndex, versionEndIndex);
+
+              if (storeVersion.isNotEmpty) {
+                // Try to parse the version string
+                try {
+                  final parsed = Version.parse(storeVersion);
+                  if (debugLogging) {
+                    print('upgrader: PlayStoreResults._parseVersionAlternative: found version="$storeVersion" with key=$key');
+                  }
+                  return parsed.toString();
+                } on FormatException {
+                  // This key didn't have a valid version, try next key
+                  continue;
+                }
+              }
+            }
+          }
+        }
+      }
+
+      if (debugLogging) {
+        print('upgrader: PlayStoreResults._parseVersionAlternative: no valid version found in common patterns');
+      }
+      return null;
+    } catch (e) {
+      if (debugLogging) {
+        print('upgrader: PlayStoreResults._parseVersionAlternative exception: $e');
+      }
+      return null;
+    }
+  }
 }

test/play_store_issue521_test.dart

@@ -0,0 +1,89 @@
+/*
+ * Test for version parsing issue #521
+ * https://github.com/larryaasen/upgrader/issues/521
+ */
+
+import 'dart:io';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:html/parser.dart';
+import 'package:upgrader/upgrader.dart';
+
+void main() {
+  test('testing Play Store version parsing issue #521', () async {
+    // Load the actual Play Store HTML that causes the issue
+    final testFile = File('test/test_play_store_page_issue521.txt');
+    final exists = testFile.existsSync();
+
+    if (!exists) {
+      print('Test file not found: test/test_play_store_page_issue521.txt');
+      return;
+    }
+
+    final contents = testFile.readAsStringSync();
+    final document = parse(contents);
+
+    final playStore = PlayStoreSearchAPI();
+    playStore.debugLogging = true;
+
+    // Try to parse version from regional Play Store page (Korean example)
+    final version = playStore.version(document);
+
+    print('Parsed version: $version');
+
+    // FIXED: Issue #521 has been fixed! Now it successfully parses regional pages
+    // Using alternative pattern "141":[[["1.5.1" for regional Play Store pages
+    expect(version, equals('1.5.1'),
+      reason: 'FIXED #521: Version parsing now works for regional Play Store pages using alternative pattern');
+  }, skip: false);
+
+  test('testing redesignedVersion for issue #521', () async {
+    final testFile = File('test/test_play_store_page_issue521.txt');
+    final exists = testFile.existsSync();
+
+    if (!exists) {
+      print('Test file not found: test/test_play_store_page_issue521.txt');
+      return;
+    }
+
+    final contents = testFile.readAsStringSync();
+    final document = parse(contents);
+
+    final playStore = PlayStoreSearchAPI();
+    playStore.debugLogging = true;
+
+    // Directly test the redesignedVersion method
+    final version = playStore.redesignedVersion(document);
+
+    print('Redesigned version: $version');
+
+    // FIXED: Now successfully parses regional pages using alternative pattern
+    // Falls back to "141":[[["1.5.1" pattern when main pattern fails
+    expect(version, equals('1.5.1'),
+      reason: 'FIXED #521: redesignedVersion now handles regional Play Store pages correctly');
+  }, skip: false);
+
+  test('FormatException issue #521 is now fixed', () async {
+    // This test verifies that issue #521 has been fixed:
+    // The original error was "PlayStoreResults.redesignedVersion exception: FormatException: Not a properly formatted version string"
+    // Now it should successfully parse the version using alternative pattern
+
+    final testFile = File('test/test_play_store_page_issue521.txt');
+    if (!testFile.existsSync()) {
+      print('Test file not found: test/test_play_store_page_issue521.txt');
+      return;
+    }
+
+    final contents = testFile.readAsStringSync();
+    final document = parse(contents);
+
+    final playStore = PlayStoreSearchAPI();
+    playStore.debugLogging = true;
+
+    // Now it should successfully parse the version without throwing an exception
+    final version = playStore.version(document);
+
+    // FIXED: Now returns the actual version instead of null
+    expect(version, equals('1.5.1'),
+      reason: 'FIXED #521: Version parsing now works correctly for regional Play Store pages');
+  }, skip: false);
+}