WME Workflow Engine

Xây dựng và chạy các chuỗi tác vụ tự động hóa (workflows) tùy chỉnh trong WME. Tự động điều hướng từ file Excel/CSV/GG Sheets và thực thi các hành động được điều chỉnh sẵn bằng WME SDK.

Aby zainstalować ten skrypt, wymagana jest instalacje jednego z następujących rozszerzeń: Tampermonkey, Greasemonkey lub Violentmonkey.

You will need to install an extension such as Tampermonkey to install this script.

Aby zainstalować ten skrypt, wymagana jest instalacje jednego z następujących rozszerzeń: Tampermonkey, Violentmonkey.

Aby zainstalować ten skrypt, wymagana będzie instalacja rozszerzenia Tampermonkey lub Userscripts.

You will need to install an extension such as Tampermonkey to install this script.

Aby zainstalować ten skrypt, musisz zainstalować rozszerzenie menedżera skryptów użytkownika.

(Mam już menedżera skryptów użytkownika, pozwól mi to zainstalować!)

You will need to install an extension such as Stylus to install this style.

You will need to install an extension such as Stylus to install this style.

You will need to install an extension such as Stylus to install this style.

Będziesz musiał zainstalować rozszerzenie menedżera stylów użytkownika, aby zainstalować ten styl.

Będziesz musiał zainstalować rozszerzenie menedżera stylów użytkownika, aby zainstalować ten styl.

Musisz zainstalować rozszerzenie menedżera stylów użytkownika, aby zainstalować ten styl.

(Mam już menedżera stylów użytkownika, pozwól mi to zainstalować!)

// ==UserScript==
// @name         WME Workflow Engine
// @namespace    https://greasyfork.org/
// @version      2.1.8
// @description  Xây dựng và chạy các chuỗi tác vụ tự động hóa (workflows) tùy chỉnh trong WME. Tự động điều hướng từ file Excel/CSV/GG Sheets và thực thi các hành động được điều chỉnh sẵn bằng WME SDK.
// @author       Minh Tan
// @match        https://www.waze.com/editor*
// @match        https://www.waze.com/*/editor*
// @match        https://beta.waze.com/editor*
// @match        https://beta.waze.com/*/editor*
// @exclude      https://www.waze.com/*user/editor*
// @connect      script.google.com
// @connect      googleusercontent.com
// @connect      *
// @grant        GM_xmlhttpRequest
// @grant        GM_setValue
// @grant        GM_getValue
// @require         https://greasyfork.org/scripts/560385/code/WazeToastr.js
// @require      https://greasyfork.org/scripts/24851-wazewrap/code/WazeWrap.js
// @require      https://cdnjs.cloudflare.com/ajax/libs/xlsx/0.18.5/xlsx.full.min.js
// @icon         data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="50mm"
   height="50mm"
   viewBox="0 0 50 50"
   version="1.1"
   id="svg1"
   inkscape:version="1.4.2 (f4327f4, 2025-05-13)"
   sodipodi:docname="wme-wf-e.svg"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns:xlink="http://www.w3.org/1999/xlink"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg">
  <sodipodi:namedview
     id="namedview1"
     pagecolor="#ffffff"
     bordercolor="#000000"
     borderopacity="0.25"
     inkscape:showpageshadow="2"
     inkscape:pageopacity="0.0"
     inkscape:pagecheckerboard="0"
     inkscape:deskcolor="#d1d1d1"
     inkscape:document-units="mm"
     inkscape:zoom="3.0467172"
     inkscape:cx="86.486531"
     inkscape:cy="136.3763"
     inkscape:window-width="2560"
     inkscape:window-height="1057"
     inkscape:window-x="-8"
     inkscape:window-y="-8"
     inkscape:window-maximized="1"
     inkscape:current-layer="layer1" />
  <defs
     id="defs1">
    <pattern
       inkscape:collect="always"
       xlink:href="#ap108"
       preserveAspectRatio="none"
       id="pattern18"
       patternTransform="matrix(0.05,0,0,0.05,1180.0034,543.26185)"
       x="97"
       y="0" />
    <pattern
       patternUnits="userSpaceOnUse"
       preserveAspectRatio="xMidYMid"
       width="377.87535"
       height="195.94893"
       patternTransform="translate(1180.0034,543.26185) scale(0.2)"
       style="fill:#f60000"
       id="ap108"
       inkscape:collect="always"
       inkscape:isstock="true"
       inkscape:label="ap108">
      <path
         id="path19386"
         style="opacity:1;fill-opacity:1;stroke:none;stroke-width:9.00491;stroke-linecap:round;stroke-dasharray:none;stroke-opacity:1;paint-order:markers fill stroke"
         d="m 0,0 v 2.2140472 c 4.4590488,0 7.9915843,3.5324221 7.9915843,7.9914708 0,2.334803 -0.9761386,4.406249 -2.5390111,5.854526 C 3.6481134,15.954595 1.8305764,15.900548 0,15.900548 v 8.514746 C 36.117581,24.419074 66.833877,47.291376 78.527206,79.30938 54.306557,83.503332 33.283767,97.075238 19.309682,116.13857 13.081134,114.80678 6.6222614,114.1008 0,114.1008 v 8.51463 c 36.056731,0 66.729902,22.75393 78.466545,54.70681 -3.477317,0.60461 -6.887698,1.39937 -10.221997,2.37937 C 57.609298,152.38658 31.038161,132.98071 0,132.98071 v 8.53126 c 27.393184,0 50.75588,16.9598 60.197934,40.96536 -3.244725,1.28874 -6.402104,2.75282 -9.456529,4.3841 C 42.931351,166.43516 23.134299,151.88289 0,151.88277 v 8.53126 c 20.113058,1.2e-4 37.142249,12.8868 43.306129,30.87549 -2.201953,1.45354 -4.315956,3.02982 -6.383244,4.65941 H 52.10177 c 12.450369,-7.22729 26.915339,-11.37861 42.369865,-11.37861 15.446585,0 29.897275,4.15702 42.342345,11.37861 h 15.22844 c -11.86855,-9.36877 -26.05051,-15.9292 -41.56018,-18.62669 11.7495,-31.91486 42.40982,-54.70125 78.45544,-54.70125 36.03877,0 66.69516,22.77985 78.45002,54.68474 -15.54841,2.68758 -29.76752,9.25428 -41.66487,18.6432 h 15.234 c 12.44454,-7.22249 26.89508,-11.37861 42.34231,-11.37861 15.45755,0 29.92252,4.14897 42.37534,11.37861 h 15.16789 c -2.03823,-1.60774 -4.11961,-3.16249 -6.28966,-4.59886 6.14672,-18.01973 23.18759,-30.93592 43.32264,-30.93604 v -8.53126 c -23.15323,1.2e-4 -42.96673,14.57533 -50.7634,35.02821 -3.05427,-1.63574 -6.20587,-3.10772 -9.45101,-4.4005 9.43332,-24.02389 32.80834,-40.99851 60.21441,-40.99851 v -8.53126 c -31.04848,0 -57.62748,19.41887 -68.25547,46.74841 -3.33211,-0.98321 -6.74094,-1.7822 -10.21659,-2.39036 11.73229,-31.96154 42.40932,-54.72333 78.47206,-54.72333 v -8.51463 c -6.65541,0 -13.1458,0.7149 -19.40322,2.0598 -13.95001,-19.048474 -34.93864,-32.618036 -59.12391,-36.834704 11.69299,-32.019704 42.4091,-54.90599 78.52709,-54.910602 v -8.514746 c -1.82985,2.27e-4 -3.64871,0.05405 -5.45246,0.159496 -1.56283,-1.448277 -2.53901,-3.519723 -2.53901,-5.854526 0,-4.4590487 3.53246,-7.9914708 7.99147,-7.9914708 V 0 h -12.92625 c -2.23211,2.8162394 -3.57996,6.3609071 -3.57996,10.205518 0,2.460888 0.55128,4.806576 1.53108,6.912 -1.53305,0.250961 -3.05348,0.538885 -4.56022,0.86468 C 356.075,14.904869 353.62624,11.971389 351.00934,9.1977071 351.12915,5.9428157 351.84586,2.8539591 353.01411,0 h -8.9994 c -0.20258,0.66856063 -0.4097,1.3369323 -0.57278,2.0212535 C 342.61841,1.3227591 341.75622,0.66984567 340.90843,0 h -15.16784 c 9.09403,5.2938331 17.12031,12.219099 23.64952,20.400038 -3.84964,1.251968 -7.593,2.745335 -11.20241,4.472239 C 324.99258,9.8618079 305.76639,0.29627717 284.31802,0 h -2.03229 C 260.86598,0.2944252 241.65906,9.8317228 228.46012,24.806173 224.84893,23.085694 221.10297,21.595729 217.2522,20.350488 223.77449,12.189657 231.78663,5.2834016 240.86321,0 h -15.19544 c -6.55661,5.1851339 -12.42346,11.208076 -17.38742,17.943723 -6.23879,-1.336479 -12.70873,-2.043326 -19.34267,-2.043326 -6.66902,0 -13.17253,0.715049 -19.44171,2.065285 C 164.52986,11.221191 158.65984,5.1908031 152.09752,0 h -15.18995 c 9.08643,5.288315 17.10621,12.201298 23.63308,20.372523 -3.84983,1.24902 -7.59254,2.748132 -11.20245,4.472126 C 136.14361,9.8486929 116.92724,0.29586142 95.49052,0 H 93.45275 C 72.019654,0.29593701 52.80378,9.8474079 39.60514,24.839244 35.994369,23.115969 32.25891,21.620787 28.408139,20.372523 34.934249,12.2016 42.955654,5.2884283 52.041222,0 H 36.862375 C 36.04543,0.64595906 35.211553,1.2721134 34.416907,1.944189 34.258167,1.2850016 34.055584,0.64437165 33.860674,0 h -9.004876 c 1.155515,2.8222866 1.873437,5.8721386 2.004737,9.0874961 -2.651452,2.8004409 -5.132409,5.7612849 -7.424239,8.8727429 -1.47549,-0.31748 -2.965984,-0.597052 -4.466608,-0.842721 0.981166,-2.106595 1.536643,-4.449298 1.536643,-6.912 C 16.506331,6.3609071 15.158438,2.8162394 12.926362,0 Z m 94.471635,8.591811 c 18.609415,0 35.351545,7.853443 47.111845,20.427628 -3.54119,2.129348 -6.92814,4.489815 -10.13945,7.060687 -9.47822,-9.471912 -22.54949,-15.349606 -36.972395,-15.349606 -14.415799,0 -27.485594,5.869493 -36.966917,15.333089 C 54.292762,33.493153 50.907402,31.136844 47.365342,29.008479 59.12931,16.440113 75.867288,8.591811 94.471635,8.591811 Z m 188.827505,0 c 18.62619,0 35.38295,7.86652 47.14488,20.460661 -3.54131,2.132221 -6.92871,4.492082 -10.13945,7.066243 -9.48106,-9.492926 -22.56435,-15.388195 -37.00543,-15.388195 -14.39766,0 -27.45003,5.857323 -36.92841,15.300056 -3.21501,-2.569398 -6.60551,-4.92805 -10.15041,-7.055168 11.7625,-12.549997 28.48993,-20.383597 47.07882,-20.383597 z m -94.36146,15.823332 c 36.12147,0 66.84306,22.833865 78.53264,54.877569 -3.47712,0.597694 -6.89306,1.384138 -10.22755,2.357178 -10.59621,-27.393903 -37.2102,-46.869468 -68.30509,-46.869468 -31.10506,0 -57.72703,19.48868 -68.31602,46.896983 -3.33396,-0.976781 -6.74502,-1.76674 -10.22215,-2.368177 11.68516,-32.052208 42.4108,-54.894085 78.53817,-54.894085 z m -94.466045,4.92926 c 11.893605,0 22.655015,4.724825 30.528565,12.397606 -2.64412,2.551371 -5.13214,5.263257 -7.45727,8.112643 -5.93152,-5.895609 -14.08169,-9.561146 -23.071295,-9.561146 -8.980422,0 -17.126174,3.659565 -23.060221,9.544592 -2.325127,-2.850293 -4.818331,-5.55549 -7.462828,-8.107163 7.876346,-7.665978 18.635149,-12.386532 30.523049,-12.386532 z m 188.827505,0 c 11.91605,0 22.69515,4.743156 30.57252,12.441638 -2.64272,2.553902 -5.13407,5.260271 -7.4572,8.112605 -5.93522,-5.921273 -14.10334,-9.60514 -23.11532,-9.60514 -8.95729,0 -17.08056,3.642103 -23.01071,9.500598 -2.32796,-2.848214 -4.82132,-5.557304 -7.46827,-8.1072 7.87249,-7.641562 18.61258,-12.342501 30.47898,-12.342501 z m -94.36146,13.967169 c 27.4439,0 50.84511,17.021291 60.25296,41.097637 -3.24756,1.282659 -6.40433,2.741821 -9.46201,4.367471 -7.77887,-20.487949 -27.61232,-35.094198 -50.79095,-35.094274 -23.19497,7.6e-5 -43.04024,14.627225 -50.80744,35.138419 -3.05677,-1.629581 -6.2149,-3.092069 -9.46208,-4.378582 9.39908,-24.094564 32.81284,-41.130671 60.26952,-41.130671 z m -94.466045,5.601222 c 7.121655,0 13.487245,3.054765 17.899695,7.919962 -2.18049,3.25285 -4.16176,6.650683 -5.92075,10.178003 -2.23956,-4.366526 -6.776463,-7.396649 -11.978945,-7.396649 -5.196322,0 -9.737235,3.022035 -11.984504,7.380133 -1.757481,-3.527849 -3.73047,-6.925569 -5.90967,-10.178041 4.416265,-4.855786 10.780498,-7.903408 17.894174,-7.903408 z m 188.827505,0 c 7.14984,0 13.53494,3.081713 17.9492,7.980472 -2.18294,3.264605 -4.16228,6.67544 -5.92067,10.216592 -2.22138,-4.419704 -6.78682,-7.495748 -12.02853,-7.495748 -5.15622,0 -9.66444,2.977172 -11.92944,7.280996 -1.75718,-3.511635 -3.7344,-6.895068 -5.90963,-10.133972 4.41411,-4.822375 10.75344,-7.84834 17.83907,-7.84834 z m -94.36146,13.300875 c 20.15191,1.14e-4 37.20548,12.93687 43.3392,30.980145 -3.09922,2.037657 -6.07261,4.254199 -8.9003,6.636624 -3.70209,-15.589607 -17.74352,-27.251528 -34.4389,-27.251528 -16.72298,0 -30.78728,11.699944 -34.46091,27.328592 -2.82825,-2.389493 -5.79934,-4.614614 -8.90029,-6.658582 6.11739,-18.072567 23.18869,-31.035137 43.3612,-31.035251 z m -94.466045,6.019729 c 2.730859,0 4.852195,2.137852 4.852195,4.868712 0,2.604662 -1.929713,4.651843 -4.47772,4.835679 -0.125102,-5.29e-4 -0.249071,-0.0038 -0.374551,-0.0038 -0.125102,0 -0.249449,0.0038 -0.374551,0.0038 -2.549254,-0.184063 -4.494199,-2.231017 -4.494199,-4.835679 0,-2.73086 2.137852,-4.868712 4.868712,-4.868712 z m 188.827505,0 c 2.73082,0 4.85215,2.137852 4.85215,4.868712 0,2.604662 -1.92975,4.651843 -4.47764,4.835679 -0.1251,-5.29e-4 -0.24907,-0.0038 -0.37455,-0.0038 -0.12548,0 -0.24945,0.0038 -0.37455,0.0038 -2.54733,-0.185575 -4.4942,-2.232378 -4.4942,-4.835679 0,-2.73086 2.13785,-4.868712 4.86871,-4.868712 z m -94.36146,12.882218 c 14.55261,0 26.33011,11.435981 26.86601,25.852684 -2.7394,2.88306 -5.29875,5.93983 -7.65555,9.1536 -1.46441,-0.31105 -2.94455,-0.58575 -4.43361,-0.8262 1.10189,-2.20842 1.72944,-4.68892 1.72944,-7.30851 0,-9.0669 -7.43936,-16.506296 -16.50629,-16.506296 -9.06694,0 -16.50622,7.439396 -16.50622,16.506296 0,2.61736 0.61837,5.1016 1.71836,7.30851 -1.52013,0.24567 -3.02733,0.52906 -4.52168,0.84824 -2.33064,-3.18093 -4.85635,-6.20807 -7.56192,-9.06554 0.47958,-14.46875 12.28165,-25.962784 26.87146,-25.962784 z m -94.466045,5.452573 c 26.848745,0 50.723565,12.494778 66.201185,31.971551 -3.85391,1.24226 -7.59927,2.72659 -11.21348,4.44461 -13.40708,-15.31411 -33.07363,-25.009963 -54.987743,-25.009963 -21.915855,0 -41.587049,9.698953 -54.99874,25.015413 -3.609903,-1.7175 -7.347818,-3.20727 -11.196851,-4.45006 C 43.752,99.063836 67.623572,86.568189 94.471635,86.568189 Z m 188.827505,0 c 26.85944,0 50.74605,12.503546 66.22318,31.993471 -3.8499,1.24687 -7.58676,2.74496 -11.19693,4.46672 -13.40791,-15.33887 -33.09176,-25.053993 -55.02625,-25.053993 -21.89496,0 -41.54945,9.680393 -54.96019,24.971373 -3.61474,-1.71386 -7.35954,-3.19521 -11.21344,-4.43365 15.47663,-19.459915 39.33834,-31.943921 66.17363,-31.943921 z m -94.36146,13.427452 c 4.45901,0 7.99154,3.532539 7.99154,7.991549 0,2.56032 -1.1712,4.80521 -3.0071,6.25659 -1.65143,-0.0884 -3.31129,-0.13228 -4.98444,-0.13228 -1.67169,0 -3.3343,0.0495 -4.98437,0.13757 -1.83738,-1.45138 -3.00711,-3.70061 -3.00711,-6.26211 0,-4.45901 3.53246,-7.991546 7.99148,-7.991546 z m -94.466045,6.598149 c 18.669805,0 35.461535,7.90299 47.227575,20.54872 -3.54478,2.12262 -6.93524,4.47939 -10.15052,7.04429 -9.4865,-9.53345 -22.60101,-15.45438 -37.077055,-15.45438 -14.478652,0 -27.596939,5.92339 -37.088089,15.45982 -3.213996,-2.56501 -6.601852,-4.92083 -10.144932,-7.04421 11.770469,-12.64804 28.561361,-20.55424 47.233021,-20.55424 z m 188.827505,0 c 18.69222,0 35.50352,7.92038 47.27153,20.59283 -3.54297,2.12731 -6.93173,4.48611 -10.14493,7.05517 -9.49058,-9.56413 -22.62406,-15.50937 -37.1266,-15.50937 -14.44797,0 -27.54119,5.89837 -37.02754,15.39927 -3.21816,-2.56256 -6.61399,-4.91335 -10.16149,-7.03321 11.76824,-12.6198 28.54114,-20.50469 47.18903,-20.50469 z M 94.471635,127.34627 c 11.942815,0 22.745615,4.76224 30.627705,12.4913 -2.64949,2.54819 -5.1436,5.25422 -7.47379,8.10164 -5.93836,-5.94395 -14.12239,-9.64384 -23.153915,-9.64384 -9.033525,0 -17.222249,3.70307 -23.164914,9.64929 -2.330683,-2.84746 -4.824075,-5.55285 -7.473789,-8.10165 7.886476,-7.73193 18.693203,-12.49674 30.638703,-12.49674 z m 188.827505,0 c 11.97373,0 22.80098,4.7873 30.68825,12.55185 -2.64752,2.55106 -5.13993,5.2577 -7.46831,8.1072 -5.94353,-5.98277 -14.15486,-9.70995 -23.21994,-9.70995 -8.99774,0 -17.15641,3.67279 -23.09329,9.57766 -2.33122,-2.84296 -4.82964,-5.54653 -7.47931,-8.09057 7.88096,-7.69598 18.65847,-12.43619 30.5726,-12.43619 z M 94.471635,146.91481 c 7.159595,0 13.556295,3.0864 17.971195,7.99699 -2.18963,3.25754 -4.18178,6.65975 -5.9481,10.19452 -2.2227,-4.41619 -6.783952,-7.49031 -12.023095,-7.49031 -5.239937,0 -9.812448,3.07306 -12.03961,7.49031 -1.766853,-3.53178 -3.7584,-6.93324 -5.948145,-10.189 4.419477,-4.91464 10.824832,-8.00251 17.987755,-8.00251 z m 188.827505,0 c 7.19905,0 13.62565,3.12178 18.04286,8.07957 -2.19462,3.27005 -4.19086,6.68546 -5.95926,10.23311 -2.19942,-4.48139 -6.79654,-7.61148 -12.0836,-7.61148 -5.19202,0 -9.72979,3.01701 -11.97903,7.36914 -1.76481,-3.51825 -3.74702,-6.90766 -5.93166,-10.15053 4.41683,-4.86561 10.78851,-7.91981 17.91069,-7.91981 z m -188.827505,19.3206 c 2.730859,0 4.852195,2.13786 4.852195,4.86872 0,2.60466 -1.929713,4.65169 -4.47772,4.83564 -0.125102,-5.3e-4 -0.249071,-0.004 -0.374551,-0.004 -0.125102,0 -0.249449,0.004 -0.374551,0.004 -2.549254,-0.18407 -4.494199,-2.23098 -4.494199,-4.83564 0,-2.73086 2.137852,-4.86872 4.868712,-4.86872 z m 188.827505,0 c 2.73082,0 4.85215,2.13786 4.85215,4.86872 0,2.60466 -1.92975,4.65169 -4.47764,4.83564 -0.1251,-5.3e-4 -0.24907,-0.004 -0.37455,-0.004 -0.12548,0 -0.24945,0.004 -0.37455,0.004 -2.54733,-0.18558 -4.4942,-2.23238 -4.4942,-4.83564 0,-2.73086 2.13785,-4.86872 4.86871,-4.86872 z M 0,170.77916 v 8.53671 c 11.257739,0 20.828598,6.85958 24.8448,16.6329 h 8.999357 C 29.431181,181.41929 15.93978,170.77916 0,170.77916 Z m 377.87531,0 c -15.93978,0 -29.43639,10.64001 -33.84963,25.16961 h 9.00495 c 4.01563,-9.77484 13.58577,-16.6329 24.84468,-16.6329 z M 0,189.68111 v 6.26766 H 12.904328 C 9.871748,192.14105 5.208189,189.68111 0,189.68111 Z m 377.87531,0 c -5.20811,0 -9.87163,2.45994 -12.90421,6.26766 h 12.90421 z" />
    </pattern>
    <clipPath
       clipPathUnits="userSpaceOnUse"
       id="clipPath54">
      <path
         id="path54"
         style="stroke-width:0.0999999;stroke-linecap:square;paint-order:markers fill stroke;stop-color:#000000"
         d="m 1691.1994,-792.32001 h 1634.8919 v 92.82806 H 1691.1994 Z" />
    </clipPath>
  </defs>
  <g
     inkscape:label="Layer 1"
     inkscape:groupmode="layer"
     id="layer1">
    <path
       d="M 25.000024,4.9e-5 A 24.999951,24.999951 0 0 1 4.9e-5,25.000024 24.999951,24.999951 0 0 1 25.000024,50 24.999951,24.999951 0 0 1 50,25.000024 24.999951,24.999951 0 0 1 25.000024,4.9e-5 Z"
       style="fill:url(#pattern18);stroke-width:5.29165;stroke-linecap:round;stroke-linejoin:round;paint-order:stroke fill markers;stroke:none;fill-opacity:1"
       id="path3" />
  </g>
</svg>

// ==/UserScript==
/* global require */
/* global $, jQuery */
/* global Node$1 */
/* global W, WazeWrap, XLSX, WazeToastr */
(function () {
    'use strict';
    let permalinks = [];
    let currentIndex = -1;
    let allWorkflows = {};
    let isLooping = false; // Biến này chỉ ra rằng vòng lặp đang hoạt động hoặc được yêu cầu dừng
    let workbookData = null; // Lưu workbook để ghi đè
    let currentFileName = ''; // Tên file hiện tại
    let statusColumnIndex = -1; // Vị trí cột Status
    let hasUnsavedChanges = false;
    let previousIndex = -1;
    let currentRowData = [];   // Lưu dữ liệu thô của hàng hiện tại trong Excel
    let eventCleanupRegistry = [];
    let wmeSDK = null;
    let batchRunCounter = 0;
    const STORAGE_KEY_SETTINGS = 'wme_wfe_settings';
    const SETTINGS_IDS = [
        'url_column', 'gas_url', 'sheet_name_input', 'url_col_name',
        'coordinate_zoom', 'save_status_enabled', 'save_permalink_after_create',
        'poi_category_select', 'workflow_select', 'workflow_variable_input',
        'skip_done_check', 'batch_save_enabled', 'batch_save_limit', 'stop_at_row', 'delay_between_runs'
    ];
    const STATUS_COL_NAME = 'Status';
    let isGasMode = false;
    let gasHeaders = null;
    let selectedSubCategory = 'CAR_WASH';
    const PROVIDERS = {
        //['', 'MIPECORP', 'PV Oil', 'Petrolimex', 'SaigonPetro', 'Satra', 'Thalexim']
        petrolimex: {
            brand: 'Petrolimex',
            url: 'petrolimex.com.vn',
            phone: '1900 2828'
        },
        saigonpetro: {
            brand: 'SaigonPetro',
            url: 'saigonpetro.com.vn',
        },
        pvoil: {
            brand: 'PV Oil',
            url: 'pvoil.com.vn'
        },
        mipecorp: {
            brand: 'MIPECORP',
            url: 'mipecorp.com.vn'
        },
        evone: {
            brand: 'ev-one.vn'
        }
    }
    const networkMapping = {
        "vinfast": "Vinfast (V-Green)",
        "rabbitevc": "Rabbit EVC",
        "evone": "EVOne",
        "charge+": "Charge+",
        "default": "Other"
    };
    const SDK_REGISTRY = {
        "update_charge_station": {
            name: "Thêm trạm sạc",
            description: "Thêm trạm sạc vào WME",
            params: [
                {
                    key: "name",
                    label: "Cột chứa tên các cửa hàng nhượng quyền",
                    placeholder: "{{A}} (Optional)"
                },
                {
                    key: "provider",
                    label: "Cột chứa tên nhà cung cấp dịch vụ trạm sạc",
                    placeholder: "{{K}} (Optional)"
                },
                {
                    key: "openHours",
                    label: "Cột giờ mở cửa (vd: 07:00 SA - 05:00 CH)",
                    placeholder: "{{E}} (Optional)"
                },
                {
                    key: "phone",
                    label: "Cột chứa số điện thoại",
                    placeholder: "{{M}} (Optioinal)"
                },
                {
                    key: "url",
                    label: "Cột chứa địa chỉ trang web",
                },
                {
                    key: "address",
                    label: "Cột địa chỉ",
                    placeholder: "{{C}} (Optional)"
                },
                {
                    key: "numberCharge",
                    label: "Cột chứa số lượng cổng sạc",
                    placeholder: "{{O}} (Optional)"
                },
                {
                    key: "power",
                    label: "Cột công suất của trạm sạc (sep=',')",
                    placeholder: "{{L}} (Optional)"
                }
            ]
        },
        "update_gas_station": {
            name: "Cập nhật Thông tin trạm xăng",
            description: "Dựa vào {{tên cột}} để lấy tên cửa hàng trong bảng tính",
            params: [
                {
                    key: 'name',
                    label: 'Tên cột chứa tên cửa hàng',
                    placeholder: "{{A}}"
                },
                {
                    key: "provider",
                    label: "Tên nhà cung cấp viết liền, không viết hoa (petrolimex,saigonpetro,...)"
                },
                {
                    key: "openHours",
                    label: "Cột giờ mở cửa (vd: 07:00 SA - 05:00 CH)",
                    placeholder: "{{F}} (Optional)"
                },
                {
                    key: "phone",
                    label: "Cột số điện thoại (vd: 09000..00)",
                    placeholder: "{{C}} (Optional)"
                }
            ]
        },
        "update_lock_rank": {
            name: "Khóa đối tượng (Lock Level)",
            description: "Đặt cấp độ khóa cho đối tượng.",
            params: [
                { key: "rank", label: "Cấp độ (1-5)", type: "number", min: 1, max: 5, placeholder: "3" }
            ]
        },
        "update_segment_city": {
            name: "Cập nhật tên tỉnh,tp/xã phường mới cho đường",
            description: "Đổi tên tỉnh,tp/xã phường mới cho các Segment đang chọn. Dùng {{value}} để lấy từ ô nhập liệu.",
            params: [
                { key: "cityName", label: "Tên TP mới", placeholder: "{{value}}" }
            ]
        },
        "enable_uturn": {
            name: "Bật quay đầu",
            description: "Bật tính năng quay đầu cho đường đang chọn. Không cần tham số.",
            params: [
                { key: "empty", label: "không cần tham số", type: "{{value}}" }
            ]
        },
        "simplify_segment": {
            name: "Tối giản các segment",
            description: "Tối giản các segment đang chọn (giải quyết distortion)",
            params: [
                { key: "empty", label: "không cần tham số", type: "{{value}}" }
            ]
        },
        "cut_segment": {
            name: "Cắt các segment",
            description: "Cắt các segment đang chọn (giải quyết Loops)",
            params: [
                { key: "empty", label: "không cần tham số", type: "{{value}}" }
            ]
        },
        "venue_scale": {
            name: "Thay đổi kích thước của venue",
            description: "Thay đổi kích thước của venue đang chọn (giải quyết place too small). Dùng {{value}} để lấy từ ô nhập liệu.",
            params: [
                { key: "scale", label: "Kích thước", type: "number", placeholder: "550 m^2" }
            ]
        }
    };
    const defaultWorkflows = {
        "update_charge_station": {
            name: "Cập nhật dữ liệu trạm sạc",
            tasks: [
                {
                    taskId: "update_charge_station",
                    enabled: true,
                    params: {
                        name: "{{name}}",
                        provider: "{{provider}}",
                        openHours: "{{open hours}}",
                        address: "{{address}}",
                        power: "{{power}}",
                        url: "{{Url}}",
                        phone: "{{Phone}}",
                        numberCharge: "{{NumberCharge}}"
                    }
                },
            ]
        },
        "wf_cut_segment": {
            name: "Cắt các segment",
            tasks: [
                {
                    taskId: "cut_segment",
                    enabled: true,
                    params: {
                        empty: "{{value}}"
                    }
                }
            ]
        },
        "wf_simplify_segment": {
            name: "Tối giản các segment (giải quyết distortion)",
            tasks: [
                {
                    taskId: "simplify_segment",
                    enabled: true,
                    params: {
                        empty: "{{value}}"
                    }
                }
            ]
        },
        "wf_scale_venue": {
            name: "Thay đổi kích thước place để hiện trên map (giải quyết too small)",
            tasks: [
                {
                    taskId: "venue_scale",
                    enabled: true,
                    params: {
                        scale: "550"
                    }
                },
                {
                    taskId: "update_lock_rank",
                    enabled: true,
                    params: {
                        rank: "3"
                    }
                }

            ]
        },
        "wf_update_gas_saition": {
            name: "Cập nhật dữ liệu trạm xăng",
            tasks: [
                {
                    taskId: "update_gas_station",
                    enabled: true,
                    params: {
                        name: "{{A}}",
                        provider: "Petrolimex",
                        openHours: "{{F}}",
                        phone: "{{C}}"
                    }
                }
            ]
        },
        "wf_enable_uturn": {
            name: "Bật quay đầu ",
            tasks: [
                {
                    taskId: "enable_uturn",
                    enabled: true,
                    params: {
                        empty: "{{value}}"
                    }
                }
            ]
        },
        "wf_update_segment_city": {
            name: "Đổi tên tỉnh,tp/xã phường mới cho Segments",
            tasks: [
                {
                    taskId: "update_segment_city",
                    enabled: true,
                    params: { cityName: "{{value}}" }
                }
            ]
        }
    };
    let CATEGORIES = [
        { key: 'CAR_SERVICES', subs: ['CAR_WASH', 'CHARGING_STATION', 'GARAGE_AUTOMOTIVE_SHOP', 'GAS_STATION'] },
        { key: 'CRISIS_LOCATIONS', subs: ['DONATION_CENTERS', 'SHELTER_LOCATIONS'] },
        {
            key: 'CULTURE_AND_ENTERTAINEMENT',
            subs: ['ART_GALLERY', 'CASINO', 'CLUB', 'TOURIST_ATTRACTION_HISTORIC_SITE', 'MOVIE_THEATER', 'MUSEUM', 'MUSIC_VENUE', 'PERFORMING_ARTS_VENUE', 'GAME_CLUB', 'STADIUM_ARENA', 'THEME_PARK', 'ZOO_AQUARIUM', 'RACING_TRACK', 'THEATER'],
        },
        { key: 'FOOD_AND_DRINK', subs: ['RESTAURANT', 'BAKERY', 'DESSERT', 'CAFE', 'FAST_FOOD', 'FOOD_COURT', 'BAR', 'ICE_CREAM'] },
        { key: 'LODGING', subs: ['HOTEL', 'HOSTEL', 'CAMPING_TRAILER_PARK', 'COTTAGE_CABIN', 'BED_AND_BREAKFAST'] },
        { key: 'NATURAL_FEATURES', subs: ['ISLAND', 'SEA_LAKE_POOL', 'RIVER_STREAM', 'FOREST_GROVE', 'FARM', 'CANAL', 'SWAMP_MARSH', 'DAM'] },
        { key: 'OTHER', subs: ['CONSTRUCTION_SITE'] },
        { key: 'OUTDOORS', subs: ['PARK', 'PLAYGROUND', 'BEACH', 'SPORTS_COURT', 'GOLF_COURSE', 'PLAZA', 'PROMENADE', 'POOL', 'SCENIC_LOOKOUT_VIEWPOINT', 'SKI_AREA'] },
        { key: 'PARKING_LOT', subs: ['PARKING_LOT'] },
        {
            key: 'PROFESSIONAL_AND_PUBLIC',
            subs: [
                'COLLEGE_UNIVERSITY',
                'SCHOOL',
                'CONVENTIONS_EVENT_CENTER',
                'GOVERNMENT',
                'LIBRARY',
                'CITY_HALL',
                'ORGANIZATION_OR_ASSOCIATION',
                'PRISON_CORRECTIONAL_FACILITY',
                'COURTHOUSE',
                'CEMETERY',
                'FIRE_DEPARTMENT',
                'POLICE_STATION',
                'MILITARY',
                'HOSPITAL_URGENT_CARE',
                'DOCTOR_CLINIC',
                'OFFICES',
                'POST_OFFICE',
                'RELIGIOUS_CENTER',
                'KINDERGARDEN',
                'FACTORY_INDUSTRIAL',
                'EMBASSY_CONSULATE',
                'INFORMATION_POINT',
                'EMERGENCY_SHELTER',
                'TRASH_AND_RECYCLING_FACILITIES',
            ],
        },
        {
            key: 'SHOPPING_AND_SERVICES',
            subs: [
                'ARTS_AND_CRAFTS',
                'BANK_FINANCIAL',
                'SPORTING_GOODS',
                'BOOKSTORE',
                'PHOTOGRAPHY',
                'CAR_DEALERSHIP',
                'FASHION_AND_CLOTHING',
                'CONVENIENCE_STORE',
                'PERSONAL_CARE',
                'DEPARTMENT_STORE',
                'PHARMACY',
                'ELECTRONICS',
                'FLOWERS',
                'FURNITURE_HOME_STORE',
                'GIFTS',
                'GYM_FITNESS',
                'SWIMMING_POOL',
                'HARDWARE_STORE',
                'MARKET',
                'SUPERMARKET_GROCERY',
                'JEWELRY',
                'LAUNDRY_DRY_CLEAN',
                'SHOPPING_CENTER',
                'MUSIC_STORE',
                'PET_STORE_VETERINARIAN_SERVICES',
                'TOY_STORE',
                'TRAVEL_AGENCY',
                'ATM',
                'CURRENCY_EXCHANGE',
                'CAR_RENTAL',
                'TELECOM',
            ],
        },
        {
            key: 'TRANSPORTATION',
            subs: ['AIRPORT', 'BUS_STATION', 'FERRY_PIER', 'SEAPORT_MARINA_HARBOR', 'SUBWAY_STATION', 'TRAIN_STATION', 'BRIDGE', 'TUNNEL', 'TAXI_STATION', 'JUNCTION_INTERCHANGE', 'REST_AREAS', 'CARPOOL_SPOT'],
        },
    ];
    const STORAGE_KEY = 'wme_custom_workflows';
    function bootstrap() {
        if (typeof WazeWrap !== 'undefined' && WazeWrap.Init) {
            WazeWrap.Init(() => {
                const sdk = typeof unsafeWindow !== 'undefined' && unsafeWindow.getWmeSdk ? unsafeWindow.getWmeSdk({ scriptId: 'wme-wfe', scriptName: 'WME Workflow Engine' }) : getWmeSdk({ scriptId: 'wme-wfe', scriptName: 'WME Workflow Engine' });
                init(sdk);
            });
        } else {
            if (typeof unsafeWindow !== 'undefined' && unsafeWindow.SDK_INITIALIZED) {
                unsafeWindow.SDK_INITIALIZED.then(() => {
                    const sdk = unsafeWindow.getWmeSdk({ scriptId: 'wme-wfe', scriptName: 'WME Workflow Engine' });
                    init(sdk);
                });
            } else if (typeof window.SDK_INITIALIZED !== 'undefined') {
                window.SDK_INITIALIZED.then(() => {
                    const sdk = window.getWmeSdk({ scriptId: 'wme-wfe', scriptName: 'WME Workflow Engine' });
                    init(sdk);
                })
            } else {
                log('WME SDK is not available. Script will not run.', 'error');
            }
        }
    }
    async function init(sdk) {
        console.log("WME Workflow Engine: Initialized");
        wmeSDK = sdk
        loadWorkflows();
        await createUI();
        bindSidebarEvents();
        loadAllSettings();
        updateUIState();
        registerHotkeys();
        window.addEventListener('beforeunload', (e) => {
            cleanupAllEvents();
            placeholderCache.clear();
            if (hasUnsavedChanges) {
                const message = 'Bạn có thay đổi status chưa được lưu! Nhấn "Cập nhật Status" trước khi thoát.';
                e.preventDefault();
                return message;
            }
        });
    }
    function registerEventCleanup(element, event, handler) {
        element.addEventListener(event, handler);
        eventCleanupRegistry.push({ element, event, handler });
    }
    function cleanupAllEvents() {
        eventCleanupRegistry.forEach(({ element, event, handler }) => {
            element.removeEventListener(event, handler);
        });
        eventCleanupRegistry = [];
    }
    function resetData() {
        if (window._wmeWorkflowInterval) {
            clearInterval(window._wmeWorkflowInterval);
            window._wmeWorkflowInterval = null;
        }
        if (window._wmeWorkflowTimeout) {
            clearTimeout(window._wmeWorkflowTimeout);
            window._wmeWorkflowTimeout = null;
        }
        // cleanupAllEvents(); // REASON FOR BUG: This was removing sidebar button listeners after loading a file
        if (workbookData) {
            workbookData = null;
        }
        permalinks.length = 0;
        currentRowData = null;
        batchRunCounter = 0;
        const logBox = document.getElementById('log_info');
        if (logBox) {
            logBox.innerHTML = '';
        }
    }
    /**
    * Tạo POI mới trên bản đồ Waze
    * @param {number} lat - Vĩ độ
    * @param {number} lon - Kinh độ
    * @param {string} type - 'point' hoặc 'area'
    */
    async function createWazePOI(lat, lon, type, method = 'auto') {
        try {
            let geometry;
            if (method === 'auto') {
                if (!lat || !lon) return;
                if (type === 'point') {
                    geometry = { type: "Point", coordinates: [lon, lat] };
                } else {
                    const offset = 0.00015;
                    geometry = {
                        type: "Polygon",
                        coordinates: [[[lon - offset, lat - offset], [lon + offset, lat - offset], [lon + offset, lat + offset], [lon - offset, lat + offset], [lon - offset, lat - offset]]]
                    };
                }
            } else {
                geometry = await (type === 'point' ? wmeSDK.Map.drawPoint() : wmeSDK.Map.drawPolygon());
            }
            const newId = wmeSDK.DataModel.Venues.addVenue({
                category: selectedSubCategory,
                geometry: geometry
            });
            setTimeout(() => {
                wmeSDK.Editing.setSelection({ selection: { ids: [newId.toString()], objectType: 'venue' } });
            }, 100)
        } catch (err) {
            log(`Lỗi tạo POI: ${err.message}`, 'error');
        }
    }
    let placeholderCache = new Map();
    function replacePlaceholders(text) {
        if (!text || typeof text !== 'string') return text;
        const cacheKey = `${text}_${currentIndex}`;
        if (placeholderCache.has(cacheKey)) {
            return placeholderCache.get(cacheKey);
        }
        if (!currentRowData || typeof currentRowData !== 'object') {
            return text.replace(/{{[A-Z]+}}/g, match => match)
                .replace(/{{[^}]+}}/g, match => match);
        }
        let result = text.replace(/{{([^}]+)}}/g, (match, key) => {
            const trimmedKey = key.trim();
            if (currentRowData[trimmedKey] !== undefined) {
                return currentRowData[trimmedKey];
            }
            return match;
        });
        const manualValue = document.getElementById('workflow_variable_input').value;
        result = result.replace('{{value}}', manualValue);
        placeholderCache.set(cacheKey, result);
        if (placeholderCache.size > 100) {
            const firstKey = placeholderCache.keys().next().value;
            placeholderCache.delete(firstKey);
        }
        return result;
    }
    function getColumnLetter(colIndex) {
        let temp, letter = '';
        while (colIndex >= 0) {
            temp = colIndex % 26;
            letter = String.fromCharCode(temp + 65) + letter;
            colIndex = Math.floor(colIndex / 26) - 1;
        }
        return letter;
    }
    function getColumnIndexFromLetter(colLetter) {
        let colIndex = 0;
        for (let i = 0; i < colLetter.length; i++) {
            colIndex = colIndex * 26 + (colLetter.charCodeAt(i) - 64);
        }
        return colIndex - 1;
    }
    /**
    * Tìm một phần tử, hỗ trợ tìm kiếm bên trong Shadow DOM.
    * @param {string} selector - CSS selector cho phần tử chính.
    * @param {string} [shadowSelector] - CSS selector cho phần tử bên trong shadow DOM.
    * @returns {Promise<Element|null>}
    */
    async function findElement(selector, shadowSelector = '') {
        try {
            const baseElement = await waitForElement(selector);
            if (!shadowSelector) {
                return baseElement;
            }
            if (baseElement && baseElement.shadowRoot) {
                await delay(50);
                const shadowElement = baseElement.shadowRoot.querySelector(shadowSelector);
                if (!shadowElement) {
                    log(`Lỗi: Không tìm thấy phần tử con với selector "${shadowSelector}" trong shadow DOM của "${selector}".`, 'error');
                }
                return shadowElement;
            }
            log(`Lỗi: Không tìm thấy shadow root trên phần tử "${selector}".`, 'error');
            return null;
        } catch (error) {
            log(`Lỗi khi tìm phần tử "${selector}": ${error.message}`, 'error');
            throw error;
        }
    }
    async function updateField(baseSelector, shadowSelector, newValue) {
        try {
            const host = document.querySelector(baseSelector);
            if (!host?.shadowRoot) return false;
            const input = shadowSelector.includes('textarea')
                ? host.shadowRoot.querySelector('textarea')
                : host.shadowRoot.querySelector(shadowSelector);
            if (!input) return false;
            if (input.value === newValue) return true;
            input.value = newValue;
            const eventData = { bubbles: true, composed: true };
            input.dispatchEvent(new Event("input", eventData));
            input.dispatchEvent(new Event("change", eventData));
            return true;
        } catch (e) {
            return false;
        }
    }
    function findCityIdByName(cityName) {
        if (!cityName) return null;
        const targetName = cityName.toString().trim();
        const cities = W.model.cities.objects;
        for (const id in cities) {
            if (cities.hasOwnProperty(id)) {
                const city = cities[id];
                if (city.attributes && city.attributes.name === targetName) {
                    return city.attributes.id;
                }
            }
        }
        return null;
    }
    function getOrCreateStreet(streetName, cityId) {
        return wmeSDK.DataModel.Streets.getStreet({ streetName, cityId })
            ?? wmeSDK.DataModel.Streets.addStreet({ streetName, cityId });
    }
    function convertTo24Hour(timeStr) {
        if (!timeStr) return null;
        timeStr = timeStr.trim().toUpperCase();

        // Case 24h format: HH:MM
        if (/^\d{1,2}:\d{2}$/.test(timeStr)) {
            const [h, m] = timeStr.split(':').map(Number);
            if (h >= 0 && h <= 23 && m >= 0 && m <= 59) {
                return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`;
            }
            return null;
        }

        // Case Vietnamese 12h format: HH:MM SA|CH
        const parts = timeStr.split(/\s+/);
        if (parts.length !== 2) return null;

        let [hourMin, meridiem] = parts;
        let [hourStr, minuteStr] = hourMin.split(':');

        const hour = parseInt(hourStr, 10);
        const minute = parseInt(minuteStr, 10);
        if (isNaN(hour) || isNaN(minute)) return null;

        let hour24 = hour;
        if (meridiem === 'SA') {
            if (hour === 12) hour24 = 0;
        } else if (meridiem === 'CH') {
            if (hour !== 12) hour24 += 12;
        } else {
            return null;
        }

        return `${String(hour24).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
    }

    function parseVietnameseOpenHours(openHoursString) {
        if (!openHoursString) return null;

        openHoursString = openHoursString.toString().trim().toUpperCase();

        if (openHoursString === '24/24' || openHoursString === '24/7') {
            return [{
                days: [0, 1, 2, 3, 4, 5, 6],
                fromHour: "00:00",
                toHour: "00:00"
            }];
        }
        const match = openHoursString.match(
            /(\d{1,2}:\d{2}(?:\s+(?:SA|CH))?)\s*-\s*(\d{1,2}:\d{2}(?:\s+(?:SA|CH))?)/
        );

        if (!match) {
            log(`Không thể parse giờ mở cửa: "${openHoursString}".`, 'warn');
            return null;
        }

        const from24h = convertTo24Hour(match[1]);
        const to24h = convertTo24Hour(match[2]);

        if (!from24h || !to24h) {
            log(`Lỗi chuyển đổi giờ từ "${openHoursString}" sang 24h.`, 'error');
            return null;
        }

        return [{
            days: [0, 1, 2, 3, 4, 5, 6],
            fromHour: from24h,
            toHour: to24h
        }];
    }

    const taskHandlers = {
        update_charge_station: async (parsedParams, selectedFeature) => {
            const featureModel = selectedFeature?.WW?.getObjectModel ? selectedFeature.WW.getObjectModel() : null;
            if (!featureModel) {
                return false;
            }
            const venueId = featureModel.attributes.id;
            const providerRaw = (parsedParams.provider || "").toString();
            const provider = providerRaw.toLowerCase();
            const nameAttribute = parsedParams.name || "";
            const finalName = `Trạm sạc ${providerRaw} - ${nameAttribute}`.replace(/Cửa hàng xăng dầu/gi, "CHXD").replace(/đỗ xe/gi, "giữ xe");
            const currentAttrs = featureModel.attributes.categoryAttributes || {};
            const newAttrs = JSON.parse(JSON.stringify(currentAttrs));
            const powerList = String(parsedParams.power || "").split(",").map(p => parseFloat(p.trim())).filter(p => !isNaN(p));
            const countList = String(parsedParams.numberCharge || "").split(",").map(c => parseInt(c.trim()) || 1);
            const portMap = new Map();
            powerList.forEach((pVal, index) => {
                const typeID = pVal >= 30 ? 'CCS_TYPE2' : 'TYPE2';
                const key = `${typeID}_${pVal}`;
                const currentCount = countList[index] || 1;
                if (portMap.has(key)) {
                    portMap.get(key).count += currentCount;
                } else {
                    portMap.set(key, {
                        portId: `${typeID}.${pVal}`,
                        connectorTypes: [typeID],
                        maxChargeSpeedKw: Math.round(pVal),
                        count: currentCount
                    });
                }
            });
            newAttrs.CHARGING_STATION = {
                chargingPorts: Array.from(portMap.values()),
                accessType: "PUBLIC",
                paymentMethods: ["CREDIT", "APP", "DEBIT", "ONLINE_PAYMENT"],
                costType: "FEE",
                network: networkMapping[provider] || networkMapping.default,
                locationInVenue: parsedParams.address || ""
            };
            const updatePayload = {
                venueId,
                name: finalName,
                phone: parsedParams.phone,
                url: parsedParams.url,
                categoryAttributes: newAttrs,
            };
            if (parsedParams.openHours) {
                const hours = parseVietnameseOpenHours(parsedParams.openHours);
                if (hours) updatePayload.openingHours = hours;
            }
            wmeSDK.DataModel.Venues.updateVenue(updatePayload);
            await delay(200);
            wmeSDK.DataModel.Venues.updateVenue(updatePayload);
        },
        cut_segment: async (parsedParams, selectedFeature) => {
            await delay(200)
            $("#WMETB_Split_Road").click()
        },
        simplify_segment: async (parsedParams, selectedFeature) => {
            await delay(500)
            $(".waze-btn.waze-btn-small.waze-btn-white.e85.e85-A").click();
            // simplify using turf
            const simplifiedGeometry = turf.simplify(selectedFeature.geometry, { tolerance: 0.00005 });
            wmeSDK.DataModel.Segments.updateSegment({
                segmentId: selectedFeature.id,
                geometry: simplifiedGeometry
            });
        },
        venue_scale: async (parsedParams, selectedFeature) => {
            const x = parseFloat(parsedParams.scale) || 550;
            try {
                const currentArea = turf.area(selectedFeature.geometry);
                let scale = Math.sqrt((x + 5) / currentArea);

                if (scale < 1 || currentArea > 600) return 0;

                let geometry = turf.transformScale(selectedFeature.geometry, scale);
                wmeSDK.DataModel.Venues.updateVenue({
                    venueId: selectedFeature.id,
                    geometry
                });

            } catch (e) {
                log('skipped', e);
            }
        },
        update_lock_rank: async (parsedParams, selectedFeature) => {
            const featureModel = selectedFeature?.WW?.getObjectModel ? selectedFeature.WW.getObjectModel() : null;
            if (!featureModel) {
                return false;
            }
            const rank = parseInt(parsedParams.rank) || 1;
            const modelRank = Math.max(0, Math.min(5, rank - 1));
            const WazeActionUpdateObject = require("Waze/Action/UpdateObject");
            if (featureModel.attributes.lockRank !== modelRank) {
                W.model.actionManager.add(new WazeActionUpdateObject(featureModel, { lockRank: modelRank }));
            }
            return true;
        },
        enable_uturn: async (parsedParams, selectedFeature) => {
            let WazeActionSetTurn
            $(document).on('bootstrap.wme', () => {
                // Require Waze components with a check for .default (ES6 modules)
                const SetTurnModule = require('Waze/Model/Graph/Actions/SetTurn');
                WazeActionSetTurn = SetTurnModule.default || SetTurnModule;
            });
            const selection = wmeSDK.Editing.getSelection();
            function uturn(id) {
                function switchSegmentUturnHybrid(direction = 'A') {
                    // --- 1. Legacy W Model Method ---
                    if (typeof W !== 'undefined' && W.model && W.model.getTurnGraph && W.model.actionManager) {
                        try {
                            // Fix: Ensure constructor is loaded correctly
                            if (typeof WazeActionSetTurn !== 'function') {
                                const SetTurnModule = require('Waze/Model/Graph/Actions/SetTurn');
                                WazeActionSetTurn = SetTurnModule.default || SetTurnModule;
                            }

                            const seg = W.model.segments.getObjectById(id);
                            if (!seg || seg.isOneWay()) return log(`${GM_info.script.name}: skipped`, 'error');

                            const node = direction === 'A' ? seg.getFromNode() : seg.getToNode();

                            // Check current state
                            if (seg.isTurnAllowed(seg, node)) {
                                log(`${GM_info.script.name}: U-turn at ${direction} already allowed.`, 'info');
                                return log(`${GM_info.script.name}: already allowed`, 'info');
                            }

                            const turn = W.model.getTurnGraph().getTurnThroughNode(node, seg, seg);
                            if (!turn) return log(`${GM_info.script.name}: failed`, 'error');

                            W.model.actionManager.add(
                                new WazeActionSetTurn(
                                    W.model.getTurnGraph(),
                                    turn.withTurnData(turn.getTurnData().withState(1)) // 1 is ALLOW
                                )
                            );
                        } catch (e) {
                            log(`${GM_info.script.name}: Legacy U-turn error: ${e}`, 'error');
                        }
                    }

                    // --- 2. SDK Method Fallback ---
                    if (typeof wmeSDK !== 'undefined' && wmeSDK.DataModel && wmeSDK.DataModel.Turns) {
                        try {
                            const seg = wmeSDK.DataModel.Segments.getById({ segmentId: id });
                            if (!seg || !seg.isTwoWay) return log(`${GM_info.script.name}: skipped`, 'error');

                            const nodeId = direction === 'A' ? seg.fromNodeId : seg.toNodeId;
                            if (!wmeSDK.DataModel.Turns.canEditTurnsThroughNode({ nodeId })) return log(`${GM_info.script.name}: failed`, 'error');

                            if (wmeSDK.DataModel.Turns.isTurnAllowed({ fromSegmentId: seg.id, nodeId, toSegmentId: seg.id })) {
                                return log(`${GM_info.script.name}: already allowed`, 'info');
                            }

                            let turns = wmeSDK.DataModel.Turns.getTurnsThroughNode({ nodeId });
                            turns = turns.filter(turn => turn.isUTurn && turn.fromSegmentId === seg.id && turn.toSegmentId === seg.id);
                            if (turns.length === 0) return log(`${GM_info.script.name}: failed`, 'error');

                            for (let i = 0; i < turns.length; i++) {
                                wmeSDK.DataModel.Turns.updateTurn({ turnId: turns[i].id, isAllowed: true });
                            }
                        } catch (e) {
                            log(`${GM_info.script.name}: SDK U-turn error: ${e}`, 'error');
                        }
                    }
                    return log(`${GM_info.script.name}: failed`, 'error');
                }
                switchSegmentUturnHybrid('A');
                switchSegmentUturnHybrid('B');
            }
            selection.ids.forEach(id => {
                uturn(id)
            });
        },
        update_segment_city: async (parsedParams) => {
            const cityID = findCityIdByName(parsedParams.cityName);
            const city = W.model.cities.objects[cityID].attributes;
            const segmentsSelected = wmeSDK.Editing.getSelection();
            segmentsSelected?.ids.forEach(segmentId => {
                const newCityProperties = {
                    cityName: city.name,
                    countryId: cityID,
                };
                let newCityId = wmeSDK.DataModel.Cities.getById({ cityId: cityID })?.id;
                if (newCityId == null) {
                    newCityId = wmeSDK.DataModel.Cities.addCity(newCityProperties).id;
                }
                const currentStreetName = wmeSDK.DataModel.Segments.getAddress({ segmentId }).street.name;
                const newPrimaryStreetId = getOrCreateStreet(currentStreetName, newCityId).id;
                wmeSDK.DataModel.Segments.updateAddress({ segmentId, primaryStreetId: newPrimaryStreetId });
            });
            return true;
        },
        update_gas_station: async (parsedParams, selectedFeature) => {
            const featureModel = selectedFeature?.WW?.getObjectModel ? selectedFeature.WW.getObjectModel() : null;
            if (!featureModel) {
                return false;
            }
            const venueSelected = wmeSDK.Editing.getSelection();
            const venueId = venueSelected.ids[0];
            const providerKey = (parsedParams.provider || '').trim().toLowerCase();
            const providerConfig = PROVIDERS[providerKey];
            if (!providerConfig) {
                log(`Provider "${parsedParams.provider}" chưa được hỗ trợ.`, 'warn');
            }
            let name = parsedParams.name.replace(/Cửa hàng xăng dầu/gi, "CHXD");
            if (new RegExp(parsedParams.provider, "i").test(name)) {
                name = name.replace(new RegExp(parsedParams.provider, "gi"), "").replace(/-/i, "").trim();
            }
            const updatePayload = {
                venueId,
                brand: providerConfig?.brand || parsedParams.provider.toString(),
                name: `${providerConfig?.brand || parsedParams.provider} - ${name}`,
                phone: providerConfig?.phone || '',
                categories: [selectedSubCategory],
                url: providerConfig?.url || '',
            };
            if (parsedParams.phone?.toString().trim()) {
                updatePayload.phone = parsedParams.phone.toString().trim();
            }
            if (parsedParams.openHours) {
                const hours = parseVietnameseOpenHours(parsedParams.openHours);
                if (hours) {
                    updatePayload.openingHours = hours;
                } else {
                    log(`SDK: Bỏ qua giờ mở cửa do parse lỗi.`, 'warn');
                }
            }
            wmeSDK.DataModel.Venues.updateVenue(updatePayload);
            return true;
        }
    };
    async function executeSdkTask(task, selectedFeature) {
        const parsedParams = Object.fromEntries(
            Object.entries(task.params).map(([key, val]) => [key, replacePlaceholders(val)])
        );
        const handler = taskHandlers[task.taskId];
        if (!handler) {
            log(`❌ Task "${task.taskId}" không được hỗ trợ.`, 'error');
            return false;
        }
        const result = await handler(parsedParams, selectedFeature);
        await delay(300);
        return result;
    }
    async function runSelectedWorkflow(isCalledByLoop = false) {
        const workflowId = document.getElementById('workflow_select').value;
        const item = permalinks[currentIndex];
        if (item) {
            const createMode = document.querySelector('input[name="poi_creation_mode"]:checked')?.value || 'none';
            const method = document.querySelector('input[name="poi_method"]:checked')?.value || 'auto';
            const coords = extractCoords(item);
            if (createMode !== 'none' && coords && !item.url.includes('venues=')) {
                await createWazePOI(coords.lat, coords.lon, createMode, method);
                await delay(300);
            } else if (item.url.includes('segments=') || item.url.includes('venues=')) {
                await parseWazeUrlAndNavigate(item.url);
                await delay(300);
            }
        }
        if (!workflowId || !allWorkflows[workflowId]) {
            log("Hệ thống: Không có workflow nào được chọn để thực thi sau khi tạo/chọn object.", "info");
            return;
        }
        const workflow = allWorkflows[workflowId];
        let selection = WazeWrap.getSelectedFeatures();

        // Retry tìm selection nếu đang chạy loop (vì WME có thể chậm)
        if (selection.length === 0 && isCalledByLoop) {
            for (let r = 0; r < 3; r++) {
                await delay(delay_between_runs);
                selection = WazeWrap.getSelectedFeatures();
                if (selection.length > 0) break;
            }
        }

        if (selection.length === 0) {
            log("❌ Chưa chọn đối tượng nào trên bản đồ để chạy Workflow Tasks!", "error");
            if (isCalledByLoop) throw new Error("Không có selection.");
            return;
        }
        const target = selection[0];
        try {
            const tasksToRun = (workflow.tasks || []).filter(t => t.enabled);
            if (tasksToRun.length === 0) {
                log("Workflow không có hành động nào được bật.", "warn");
                return;
            }
            for (const task of tasksToRun) {
                if (isCalledByLoop && !isLooping) throw new Error("Stopped by user");
                await executeSdkTask(task, target);
            }
        } catch (error) {
            log(`Lỗi Workflow: ${error.message}`, 'error');
            console.error(error);
            throw error;
        }
        if (!isCalledByLoop) {
            await handleBatchSave();
        }
    }
    async function toggleWorkflowLoop() {
        if (isLooping) {
            isLooping = false;
            log("Đã yêu cầu dừng vòng lặp. Sẽ dừng sau khi hoàn thành hoặc giữa bước hiện tại.", 'warn');
        } else {
            if (permalinks.length === 0) {
                log("Vui lòng tải một file Excel/CSV trước khi bắt đầu vòng lặp.", 'warn');
                return;
            }
            isLooping = true;
            updateUIState();
            log("--- Bắt đầu vòng lặp tự động ---", 'special');
            await executeLoop();
        }
    }
    async function executeLoop() {
        if (currentIndex < 0 && permalinks.length > 0) {
            currentIndex = 0;
        }
        while (isLooping && currentIndex < permalinks.length) {
            updateUIState();
            updateStatus('Đang tạo');
            try {
                const runDelay = parseInt(document.getElementById('delay_between_runs')?.value) || 1000;
                await processCurrentLink();
                if (!isLooping) { break; }
                await delay(runDelay); // Sử dụng giá trị từ cài đặt
                if (!isLooping) { break; }
                await runSelectedWorkflow(true);
                await handleBatchSave();

                const shouldSavePermalink = document.getElementById('save_permalink_after_create')?.checked;
                if (shouldSavePermalink) {
                    const newPermalink = wmeSDK.Map.getPermalink();
                    if (newPermalink) {
                        updatePermalinkInWorkbook(currentIndex, newPermalink);
                    } else {
                        log(`⚠️ (Loop) Không lấy được Permalink (Đối tượng chưa được lưu hoặc chưa có ID).`, 'warn');
                    }
                }
                updateStatus('Đã tạo');

                // Check stop at row condition
                const stopRow = parseInt(document.getElementById('stop_at_row')?.value) || 0;
                if (stopRow > 0 && (currentIndex + 1) === stopRow) {
                    log(`--- Đã đạt đến hàng dừng: ${stopRow} ---`, 'info');
                    isLooping = false;
                    break;
                }
            } catch (error) {
                if (isLooping) {
                    log(`Mục ${currentIndex + 1} thất bại: ${error.message}`, 'error');
                    updateStatus(`Lỗi: ${error.message}`);
                } else {
                    log(`Vòng lặp đã dừng tại mục ${currentIndex + 1} do yêu cầu dừng.`, 'warn');
                    break;
                }
            }
            if (!isLooping) break;
            if (currentIndex < permalinks.length - 1) {
                previousIndex = currentIndex;
                currentIndex++;
                if (!isLooping) { break; }
                await delay(300);
            } else {
                log("Đã đến mục cuối cùng của danh sách.", 'info');
                isLooping = false;
            }
        }
        isLooping = false;
        if (currentIndex >= permalinks.length && permalinks.length > 0) {
            log("--- ✅ Hoàn thành vòng lặp tự động! ---", 'special');
        } else if (permalinks.length === 0) {
            log("Không có permalink nào để lặp.", 'warn');
        } else {
            log("--- Vòng lặp tự động đã dừng. ---", 'warn');
        }
        updateUIState();
    }
    function handleFile(e) {
        isGasMode = false;
        gasHeaders = null;
        resetData()
        permalinks = [];
        currentIndex = -1;
        previousIndex = -1;
        hasUnsavedChanges = false;
        const file = e.target.files[0];
        if (!file) {
            updateUIState();
            return;
        }
        currentFileName = file.name;
        const urlColumnInput = document.getElementById('url_column').value.toUpperCase();
        const urlColumnIndex = getColumnIndexFromLetter(urlColumnInput);
        if (urlColumnIndex < 0 || urlColumnIndex > 255) {
            log(`Lỗi: Cột "${urlColumnInput}" không hợp lệ. Vui lòng nhập A-IV.`, 'error');
            updateUIState();
            return;
        }
        const reader = new FileReader();
        reader.onload = (e) => {
            try {
                const data = new Uint8Array(e.target.result);
                const workbook = XLSX.read(data, { type: 'array', cellDates: false, cellStyles: false });
                workbookData = workbook;
                const firstSheetName = workbook.SheetNames[0];
                const worksheet = workbook.Sheets[firstSheetName];
                const json = XLSX.utils.sheet_to_json(worksheet, { header: 1, defval: '', raw: false });
                if (json.length === 0) {
                    log('File không có dữ liệu.', 'error');
                    updateUIState();
                    return;
                }
                const headerRow = json[0];
                statusColumnIndex = headerRow.findIndex(h => h && h.toString().trim().toLowerCase() === STATUS_COL_NAME.toLowerCase());
                let hasExistingStatus = statusColumnIndex !== -1;
                if (!hasExistingStatus) {
                    statusColumnIndex = headerRow.length;
                    headerRow.push(STATUS_COL_NAME);
                }
                const headersMap = headerRow.map(h => h.toString().trim() || null);
                const permalinkData = [];
                let foundWorkingIndex = -1;
                for (let i = 1; i < json.length; i++) {
                    const rawRow = json[i];
                    while (rawRow.length < statusColumnIndex + 1) {
                        rawRow.push('');
                    }
                    const cellValue = rawRow[urlColumnIndex];
                    if (cellValue && typeof cellValue === 'string') {
                        const trimmedValue = cellValue.trim();
                        const isURL = /^https?:\/\//i.test(trimmedValue);
                        const isCoordinate = /^\s*\(?\s*-?\d+\.?\d*\s*,\s*-?\d+\.?\d*\s*\)?\s*$/.test(trimmedValue);
                        if (isURL || isCoordinate) {
                            const rowObject = {};
                            for (let idx = 0; idx < rawRow.length; idx++) {
                                const headerName = headersMap[idx];
                                const val = rawRow[idx];
                                if (headerName) {
                                    rowObject[headerName] = val;
                                }
                                rowObject[getColumnLetter(idx)] = val;
                            }
                            const status = rawRow[statusColumnIndex].toString().trim();
                            permalinkData.push({
                                url: trimmedValue,
                                rowIndex: i,
                                status: status,
                                rowData: rowObject,
                                localFileIndexes: {
                                    urlCol: urlColumnIndex,
                                    statusCol: statusColumnIndex,
                                    sheetName: firstSheetName
                                }
                            });
                            const statusLower = status.toLowerCase();
                            if (foundWorkingIndex === -1 && statusLower === 'đang tạo') {
                                foundWorkingIndex = permalinkData.length - 1;
                            }
                            if (foundWorkingIndex === -1 && statusLower !== 'đã tạo') {
                                foundWorkingIndex = permalinkData.length - 1;
                            }
                        }
                    }
                }
                permalinks = permalinkData;
                const newWorksheet = XLSX.utils.aoa_to_sheet(json);
                workbookData.Sheets[firstSheetName] = newWorksheet;
                if (permalinks.length > 0) {
                    currentIndex = foundWorkingIndex !== -1 ? foundWorkingIndex : 0;
                    updateStatus('Đang tạo');
                    permalinks[currentIndex].status = 'Đang tạo';
                    processCurrentLink();
                } else {
                    log(`Không tìm thấy URL hoặc tọa độ hợp lệ trong cột ${urlColumnInput}.`, 'warn');
                }
                updateUIState();
            } catch (err) {
                log(`Lỗi khi đọc file: ${err.message}`, 'error');
                console.error(err);
                updateUIState();
            }
        };
        reader.readAsArrayBuffer(file);
    }
    function saveWorkflows() {
        try {
            localStorage.setItem(STORAGE_KEY, JSON.stringify(allWorkflows));
            log("Đã lưu các workflows.", 'success');
        } catch (e) {
            log("Lỗi khi lưu workflows vào localStorage.", 'error');
        }
    }
    function loadWorkflows() {
        try {
            const saved = localStorage.getItem(STORAGE_KEY);
            if (saved) {
                allWorkflows = JSON.parse(saved);
            } else {
                allWorkflows = { ...defaultWorkflows };
                log("Đã tải các workflows mặc định. Các thay đổi sẽ được lưu lại.");
            }
        } catch (e) {
            log("Lỗi khi tải workflows từ localStorage, sử dụng các preset mặc định.", 'error');
            allWorkflows = { ...defaultWorkflows };
        }
    }
    function delay(ms) { return new Promise(resolve => setTimeout(resolve, ms)); }
    /**
    * Cập nhật status cho URL hiện tại
    */
    function updateStatus(status) {
        const shouldSave = isStatusSavingEnabled();
        if (isGasMode) {
            if (permalinks[currentIndex]) {
                const item = permalinks[currentIndex];
                if (shouldSave) {
                    updateGasStatusByRowIndex(item.rowIndex, status);
                }
                item.status = status;
                updateSaveButtonState();
            }
        } else {
            if (currentIndex >= 0 && permalinks[currentIndex]) {
                const item = permalinks[currentIndex];
                if (shouldSave) {
                    _updateLocalStatusCell(item.rowIndex, item.localFileIndexes.statusCol, status, item.localFileIndexes.sheetName);
                }
                item.status = status;
                hasUnsavedChanges = true;
                updateSaveButtonState();
            }
        }
    }
    /**
     * Tách hàm cập nhật trạng thái ô cụ thể trong workbookData (Local File only)
     * @param {number} rowIndex - Row index (0-based)
     * @param {number} colIndex - Column index (0-based)
     * @param {string} value - New status value
     * @param {string} sheetName - Target sheet name
     */
    function _updateLocalStatusCell(rowIndex, colIndex, value, sheetName) {
        if (!workbookData) return;
        try {
            const worksheet = workbookData.Sheets[sheetName];
            const cellAddress = XLSX.utils.encode_cell({ r: rowIndex, c: colIndex });
            worksheet[cellAddress] = { t: 's', v: value };
            updateSaveButtonState();
        } catch (err) {
            log(`Lỗi khi cập nhật cell [${rowIndex}, ${colIndex}] trong file local.`, 'error');
            console.error(err);
        }
    }
    /**
    * Lưu workbook ra file và trigger download
    */
    function saveWorkbookToFile() {
        if (isGasMode) {
            log("Chế độ Google Sheets: Status được lưu tự động lên sheet.", 'info');
            hasUnsavedChanges = false;
            updateSaveButtonState();
            return;
        }
        if (!workbookData) {
            log('Không có dữ liệu để lưu. Vui lòng tải file trước.', 'warn');
            return;
        }
        try {
            log('Đang chuẩn bị dữ liệu Excel...', 'info');
            const wbout = XLSX.write(workbookData, { bookType: 'xlsx', type: 'array' });
            const blob = new Blob([wbout], { type: 'application/octet-stream' });
            const url = URL.createObjectURL(blob);
            const a = document.createElement('a');
            a.href = url;

            // Đảm bảo file lưu ra luôn có đuôi .xlsx để Excel không báo lỗi
            let fileName = currentFileName || 'workflow_results.xlsx';
            if (!fileName.toLowerCase().endsWith('.xlsx')) {
                fileName = fileName.replace(/\.[^/.]+$/, "") + ".xlsx";
            }

            a.download = fileName;
            document.body.appendChild(a); // Append to body for better Firefox compatibility
            a.click();

            setTimeout(() => {
                document.body.removeChild(a);
                URL.revokeObjectURL(url);
            }, 1000); // Delay revocation to ensure download starts

            hasUnsavedChanges = false;
            updateSaveButtonState();
            log(`✅ Đã lưu file: ${fileName}`, 'success');
        } catch (err) {
            log(`❌ Lỗi khi lưu file: ${err.message}`, 'error');
            console.error(err);
        }
    }
    /**
    * Cập nhật trạng thái nút Save Status
    */
    function updateSaveButtonState() {
        const saveBtn = document.getElementById('save_status_btn');
        if (saveBtn) {
            saveBtn.disabled = !hasUnsavedChanges;
            if (hasUnsavedChanges) {
                saveBtn.classList.add('primary');
                saveBtn.style.animation = 'pulse 1.5s infinite';
            } else {
                saveBtn.classList.remove('primary');
                saveBtn.style.animation = '';
            }
        }
    }
    function waitForElement(selector, timeout = 7000) {
        return new Promise((resolve, reject) => {
            const intervalTime = 100;
            let elapsedTime = 0;
            const interval = setInterval(() => {
                const element = document.querySelector(selector);
                if (element && element.offsetParent !== null) {
                    clearInterval(interval);
                    resolve(element);
                }
                elapsedTime += intervalTime;
                if (elapsedTime >= timeout) {
                    clearInterval(interval);
                    reject(new Error(`Element "${selector}" not found or not visible after ${timeout}ms`));
                }
            }, intervalTime);
        });
    }
    let logQueue = [];
    let logTimer = null;
    function log(message, type = 'normal') {
        const colorMap = {
            error: '#c0392b', success: '#27ae60', warn: '#e67e22',
            info: '#2980b9', special: '#8e44ad', normal: 'inherit'
        };
        logQueue.push({
            message,
            color: colorMap[type],
            time: new Date().toLocaleTimeString()
        });
        if (logTimer) clearTimeout(logTimer);
        logTimer = setTimeout(() => {
            const logBox = document.getElementById('log_info');
            if (!logBox) return;
            const fragment = document.createDocumentFragment();
            const div = document.createElement('div');
            logQueue.forEach(({ message, color, time }) => {
                div.innerHTML = `<div style="color:${color}; border-bottom: 1px solid #f0f0f0;">[${time}] ${message}</div>`;
                fragment.insertBefore(div.firstChild, fragment.firstChild);
            });
            logBox.insertBefore(fragment, logBox.firstChild);
            while (logBox.children.length > 20) {
                logBox.removeChild(logBox.lastChild);
            }
            logQueue.length = 0;
        }, 50);
    }
    const createElem = (type = "", attrs = {}, eventListeners = []) => {
        const el = document.createElement(type || 'div');
        Object.keys(attrs).forEach(attr => {
            if (attrs[attr] === undefined || attrs[attr] === null) return;
            if (['disabled', 'checked', 'selected', 'textContent', 'innerHTML'].includes(attr)) el[attr] = attrs[attr];
            else el.setAttribute(attr, attrs[attr]);
        });
        eventListeners.forEach(obj => {
            Object.entries(obj).forEach(([evt, cb]) => el.addEventListener(evt, cb));
        });
        return el;
    };
    const createConfigRow = (label, type, id, value, options = []) => {
        const container = createElem("div", { style: "margin-bottom: 2px; display: flex; align-items: center; justify-content: flex-start; gap: 5px;" });
        let input;
        const style = "width: 50%; padding: 1px 2px; border: 1px solid #808080; border-radius: 0; background: #fff; font-size: 11px;";
        if (type === "select") {
            input = createElem("select", { id, style });
            options.forEach(opt => input.appendChild(createElem("option", { value: opt.value, textContent: opt.text, selected: opt.value === value })));
        } else {
            input = createElem("input", {
                id, type: type === "checkbox" ? "checkbox" : (type === "number" ? "number" : "text"),
                style: type === "checkbox" ? "margin: 0;" : style,
                value: value || ""
            });
            if (type === "checkbox") input.checked = !!value;
        }
        container.append(createElem("span", { textContent: label, style: "font-size: 11px; width: 45%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;" }), input);
        return container;
    };
    async function createUI() {
        injectGlobalStyles();
        const docFrags = document.createDocumentFragment();
        return wmeSDK.Sidebar.registerScriptTab().then(({ tabLabel, tabPane }) => {
            tabLabel.innerHTML = `<img src="${GM_info.script.icon}" width="16" height="16" style="margin-top: -2px;">`;
            tabLabel.title = "WME Workflow Engine";
            docFrags.append(
                createElem("div", { style: "font-weight: bold; padding: 5px 0; border-bottom: 1px solid #ccc; margin-bottom: 5px;", textContent: "WME Workflow Engine v" + (GM_info.script.version || "1.0") })
            );
            const ul = createElem("ul", { class: "nav nav-tabs", style: "margin-bottom: 10px; border-bottom: 1px solid #ddd; display: flex;" });
            const tabs = [
                { id: "wfe-data", text: "Dữ liệu", active: true },
                { id: "wfe-configs", text: "Tác vụ" },
                { id: "wfe-settings", text: "Cài đặt" }
            ];
            tabs.forEach(t => {
                const li = createElem("li", { class: t.active ? "active" : "", style: "flex: 1; text-align: center;" });
                li.append(createElem("a", { "data-toggle": "tab", href: `#panel-${t.id}`, textContent: t.text }));
                ul.append(li);
            });
            docFrags.append(ul);
            const contentRoot = createElem("div", { class: "tab-content", style: "max-height: 85vh; overflow-y: auto; overflow-x: hidden; padding: 2px;" });
            const p1 = createElem("div", { id: "panel-wfe-data", class: "tab-pane active" });
            const sourceToggle = createElem("div", { style: "margin-bottom:10px; font-size:11px" });
            sourceToggle.innerHTML = `
            <label><input type="radio" name="data_source_mode" value="local" checked> Local</label>
            <label style="margin-left:10px"><input type="radio" name="data_source_mode" value="gas"> Google Sheet</label>
        `;
            p1.append(sourceToggle);
            const gasBox = createElem("div", { id: "gas_config", style: "display:none" });
            gasBox.append(
                createConfigRow("Web App URL:", "text", "gas_url", ""),
                createConfigRow("Tên Sheet:", "text", "sheet_name_input", "Sheet1"),
                createConfigRow("Header URL:", "text", "url_col_name", "Link WME"),
                createElem("button", { id: "load_sheet_btn", class: "action-btn primary", textContent: "Tải dữ liệu từ Google Sheets", style: "width:100%; margin-top:5px" })
            );
            const localBox = createElem("div", { id: "local_file_config" });
            localBox.append(
                createElem("input", { type: "file", id: "excel_file", class: "wwe-input", style: "margin-bottom:5px; width: 100%;" }),
                createConfigRow("Cột URL (A-Z):", "text", "url_column", "F")
            );
            p1.append(localBox, gasBox);
            p1.append(createElem("button", { id: "save_status_btn", class: "action-btn success", textContent: "💾 Lưu Status", style: "width:100%; margin-top:10px", disabled: true }));
            p1.append(createElem("hr"), createElem("div", { id: "log_info", class: "log-container" }));
            const p2 = createElem("div", { id: "panel-wfe-configs", class: "tab-pane" });
            const btnGrp = createElem("div", { style: "display: flex; gap: 5px; margin: 10px 0;" });
            btnGrp.append(
                createElem("button", { id: "edit_workflow_btn", class: "action-btn", textContent: "Sửa", style: "flex:1" }),
                createElem("button", { id: "new_workflow_btn", class: "action-btn", textContent: "Tạo", style: "flex:1" }),
                createElem("button", { id: "delete_workflow_btn", class: "action-btn danger", textContent: "Xóa", style: "width:34px" })
            );
            p2.append(
                createConfigRow("Chọn tác vụ:", "select", "workflow_select", ""),
                createConfigRow("Giá trị ({{value}}):", "text", "workflow_variable_input", ""),
                createElem("div", { class: "wwe-btn-group", style: "margin-top:10px" }),
                btnGrp
            );
            const p3 = createElem("div", { id: "panel-wfe-settings", class: "tab-pane" });
            p3.append(
                createConfigRow("Zoom level:", "number", "coordinate_zoom", 20),
                createConfigRow("Auto Lưu Status", "checkbox", "save_status_enabled", true),
                createConfigRow("Auto Lưu Permalink", "checkbox", "save_permalink_after_create", true),
                createElem("p", { textContent: "Tự động Lưu (Batch Save):", style: "font-weight:bold; font-size:11px" }),
                createConfigRow("Bật Batch Save", "checkbox", "batch_save_enabled", false),
                createConfigRow("Số lần run / Save:", "number", "batch_save_limit", 10),
                createConfigRow("Delay giữa các lần run:", "number", "delay_between_runs", 1000),
                createConfigRow("Dừng tại hàng (row):", "number", "stop_at_row", 0),
                createElem("hr"),
                createElem("p", { textContent: "Công cụ POI:", style: "font-weight:bold; font-size:11px" }),
                createConfigRow("Loại POI:", "select", "poi_category_select", "CAR_WASH", CATEGORIES.flatMap(c => c.subs.map(s => ({ value: s, text: s })))),
                createElem("div", { style: "font-size:11px; margin-top:5px" }).appendChild(
                    createElem("span", {
                        innerHTML: `
                    Tạo: <input type="radio" name="poi_creation_mode" value="none" checked> Ko |
                    <input type="radio" name="poi_creation_mode" value="point"> Điểm |
                    <input type="radio" name="poi_creation_mode" value="area"> Vùng
                ` })
                ).parentNode,
                createElem("div", { style: "font-size:11px; margin-top:5px" }).appendChild(
                    createElem("span", {
                        innerHTML: `
                    Cách tạo: <input type="radio" name="poi_method" value="auto" checked> Tự động |
                    <input type="radio" name="poi_method" value="manual"> Thủ công (SDK)
                ` })
                ).parentNode
            );
            contentRoot.append(p1, p2, p3);
            docFrags.append(contentRoot);
            tabPane.appendChild(docFrags);
            tabPane.id = "sidepanel-wme-workflow";
            const parent = tabPane.parentElement;
            if (parent) {
                Object.assign(parent.style, { width: "100%", padding: "0 5px", overflow: "hidden", boxSizing: "border-box" });
            }
            createFloatingHUD();
            createWorkflowEditorModal();
            populateWorkflowSelector();
        });
    }
    function createFloatingHUD() {
        const hud = document.createElement('div');
        hud.id = 'wme-wfe-hud';
        hud.style.cssText = `
        position: fixed; top: 10%; left: 80%;
        background: rgba(255, 255, 255, 0.9);
        z-index: 1001; overflow: hidden;
        opacity: 0.8;
    `;
        hud.innerHTML = `
        <div id="wfe-hud-header" style="background: #c0c0c0; border: 2px outset #ffffff; border-bottom: none; padding: 2px 4px; cursor: move; display: flex; align-items: center; justify-content: flex-start; gap: 4px;">
            <span style="font-weight:bold; font-size: 10px; color: #000;">Workflow Engine</span>
        </div>
        <div style="padding: 4px; background: #c0c0c0; border: 2px outset #ffffff;">
            <!-- Navigation -->
            <div style="display: flex; justify-content: flex-start; align-items: center; gap: 4px;">
                <button id="prev_btn" class="nav-btn" title="Lùi" disabled>◀</button>
                <input type="number" id="nav_index_input" min="1" style="text-align: center; border: 1px inset #808080; background: #fff; font-size: 10px; font-weight: bold; margin: 0;" disabled>
                <div id="nav_total_count" style="font-size: 9px; color: #000;">/ 0</div>
                <button id="next_btn" class="nav-btn" title="Tiếp" disabled>▶</button>
            </div>
            <!-- Actions -->
            <button id="reselect_btn" class="hud-btn secondary" title="Reload" disabled>Reload</button>
            <button id="run_workflow_btn" class="hud-btn primary" title="Run">Run</button>
            <button id="loop_workflow_btn" class="hud-btn warning" title="Loop" disabled>Loop</button>
        </div>
    `;
        document.body.appendChild(hud);
        makeDraggable(hud, document.getElementById('wfe-hud-header'));
        bindHudEvents();
    }
    function injectGlobalStyles() {
        if (document.getElementById('wme-wfe-styles')) return;
        const style = document.createElement('style');
        style.id = 'wme-wfe-styles';
        style.innerHTML = `
        #workflow-editor-modal {
            display: none; position: fixed; z-index: 20000;
            left: 0; top: 0; width: 100vw; height: 100vh;
            background: rgba(0,0,0,0.5); overflow: hidden;
        }
        #workflow-editor-content {
            position: absolute; left: 50%; top: 50%;
            transform: translate(-50%, -50%);
            width: 600px; max-height: 90vh;
            background: #c0c0c0; border: 2px outset #ffffff;
            display: flex; flex-direction: column;
            box-shadow: 2px 2px 5px rgba(0,0,0,0.5);
        }
        /* General */
        .wwe-input { border-radius: 0; border: 1px inset #808080; background: #fff; width: 100%; padding: 2px; box-sizing: border-box; font-size: 11px; }
        .wwe-form-group { margin-bottom: 4px; }
        .wwe-form-group label { font-weight: bold; font-size: 11px; display: block; margin-bottom: 1px; }
        .w-100 { width: 100%; }
        .mt-2 { margin-top: 4px; }
        /* Buttons Class98 */
        .action-btn, .hud-btn, .nav-btn {
            cursor: pointer; border: 2px outset #ffffff; border-radius: 0;
            background: #c0c0c0; transition: none; font-family: 'Tahoma', sans-serif;
            font-size: 11px; padding: 2px 4px; color: #000;
        }
        .action-btn:active, .hud-btn:active, .nav-btn:active {
            border: 2px inset #ffffff;
        }
        .action-btn:disabled, .hud-btn:disabled, .nav-btn:disabled { opacity: 0.6; cursor: default; }
        .primary { font-weight: bold; }
        .success { font-weight: bold; }
        .danger { color: #800000; }
        .warning { color: #000; }
        .secondary { color: #000; }
        #loop_workflow_btn.looping { background-color: #ff5722 !important; color: #fff; animation: pulse 1s infinite; }
        /* Accordion */
        .accordion-header {
            width: 100%; text-align: left; padding: 2px 5px; background: #c0c0c0; border: 1px outset #fff;
            font-weight: bold; font-size: 11px; cursor: pointer;
            display: flex; justify-content: flex-start; align-items: center; gap: 5px;
        }
        .accordion-header::before { content: '[+]'; font-family: monospace; }
        .accordion-header.active::before { content: '[-]'; }
        .accordion-content { max-height: 0; overflow: hidden; transition: none; padding: 0 5px; background: #c0c0c0; }
        /* Utils */
        .log-container { height: 80px; overflow-y: auto; font-size: 10px; background: #fff; border: 1px inset #808080; padding: 2px; }
        .wwe-btn-group { display: flex; gap: 2px; margin-top: 2px; }
        @keyframes pulse { 0% { opacity: 1; } 50% { opacity: 0.5; } 100% { opacity: 1; } }
        // /* Nav Tabs Class98 */
        // .nav-tabs { border-bottom: 1px solid #808080 !important; }
        // .nav-tabs > li > a { border-radius: 0 !important; margin-right: 2px; padding: 2px 8px !important; background: #d0d0d0; border: 1px solid #808080; color: #000; }
        // .nav-tabs > li.active > a { background: #c0c0c0 !important; border-bottom-color: transparent !important; font-weight: bold; }
    `;
        document.head.appendChild(style);
    }
    function bindSidebarEvents() {
        const contentPanel = document.getElementById('wwe-sidebar-content');
        if (contentPanel) {
            contentPanel.addEventListener('click', (e) => {
                if (e.target.classList.contains('accordion-header')) {
                    const content = e.target.nextElementSibling;
                    e.target.classList.toggle('active');
                    content.style.maxHeight = content.style.maxHeight ? null : (content.scrollHeight + 10 + "px");
                }
            });
        }
        const toggleSource = (e) => {
            if (e.target.name !== 'data_source_mode') return;
            const isLocal = e.target.value === 'local';
            isGasMode = !isLocal; // Cập nhật biến trạng thái quan trọng này
            document.getElementById('local_file_config').style.display = isLocal ? 'block' : 'none';
            document.getElementById('gas_config').style.display = isLocal ? 'none' : 'block';
            document.getElementById('save_status_btn').textContent = isLocal ? '💾 Lưu Status' : '☁️ Auto Sync';
            log(`Chế độ: ${isLocal ? 'File Local' : 'Google Sheets'}`, 'info');
            updateUIState();
        };
        document.querySelectorAll('input[name="data_source_mode"]').forEach(el => el.addEventListener('change', toggleSource));
        document.getElementById('excel_file').addEventListener('change', handleFile, false);
        registerEventCleanup(document.getElementById('load_sheet_btn'), 'click', loadFromGoogleSheet);
        registerEventCleanup(document.getElementById('save_status_btn'), 'click', saveWorkbookToFile);
        registerEventCleanup(document.getElementById('poi_category_select'), 'change', (e) => selectedSubCategory = e.target.value);
        registerEventCleanup(document.getElementById('edit_workflow_btn'), 'click', () => {
            const id = document.getElementById('workflow_select').value;
            if (id) openWorkflowEditor(id);
        });
        registerEventCleanup(document.getElementById('new_workflow_btn'), 'click', () => openWorkflowEditor());
        registerEventCleanup(document.getElementById('delete_workflow_btn'), 'click', deleteSelectedWorkflow);
        registerEventCleanup(document.getElementById('workflow_select'), 'change', () => {
            updateUIState();
            if (currentIndex >= 0 && permalinks.length > 0) processCurrentLink();
        });
        const sidebar = document.getElementById('sidepanel-wme-workflow');
        if (sidebar) {
            sidebar.addEventListener('change', (e) => {
                if (SETTINGS_IDS.includes(e.target.id) || ['data_source_mode', 'poi_creation_mode'].includes(e.target.name)) {
                    saveAllSettings();
                }
            });
        }
        updateUIState();
    }
    function bindHudEvents() {
        const bindings = [
            { id: 'prev_btn', evt: 'click', fn: () => navigate(-1) },
            { id: 'next_btn', evt: 'click', fn: () => navigate(1) },
            { id: 'reselect_btn', evt: 'click', fn: processCurrentLink },
            { id: 'run_workflow_btn', evt: 'click', fn: () => runSelectedWorkflow(false) },
            { id: 'loop_workflow_btn', evt: 'click', fn: toggleWorkflowLoop },
            { id: 'nav_index_input', evt: 'change', fn: (e) => navigate(0, parseInt(e.target.value) - 1) }
        ];
        bindings.forEach(b => {
            const el = document.getElementById(b.id);
            if (el) el.addEventListener(b.evt, b.fn);
        });
    }
    /**
    * Makes an element draggable using its handle.
    * @param {HTMLElement} elementToMove The element that will be moved.
    * @param {HTMLElement} dragHandle The element that acts as the drag handle.
    */
    function makeDraggable(elementToMove, dragHandle) {
        let offsetX, offsetY;
        let isDragging = false;

        // Thay thế dragHandle.onmousedown bằng addEventListener
        dragHandle.addEventListener('mousedown', (e) => {
            e.preventDefault(); // Giờ đây hợp lệ vì passive: false
            isDragging = true;
            dragHandle.style.cursor = 'grabbing';

            const rect = elementToMove.getBoundingClientRect();
            offsetX = e.clientX - rect.left;
            offsetY = e.clientY - rect.top;

            const onMouseMove = (ev) => {
                if (!isDragging) return;
                elementToMove.style.left = (ev.clientX - offsetX) + 'px';
                elementToMove.style.top = (ev.clientY - offsetY) + 'px';
            };

            const onMouseUp = () => {
                isDragging = false;
                dragHandle.style.cursor = 'grab';
                document.removeEventListener('mousemove', onMouseMove);
                document.removeEventListener('mouseup', onMouseUp);
            };

            document.addEventListener('mousemove', onMouseMove);
            document.addEventListener('mouseup', onMouseUp);
        }, { passive: false });
    }
    function isStatusSavingEnabled() {
        return document.getElementById('save_status_enabled')?.checked === true;
    }
    function createWorkflowEditorModal() {
        let modal = document.getElementById('workflow-editor-modal');
        if (modal) return;
        modal = document.createElement('div');
        modal.id = 'workflow-editor-modal';
        modal.innerHTML = `
        <div id="workflow-editor-content">
            <div id="editor-header" style="background:#000080; color:#fff; padding:2px 8px; cursor:move; display:flex; justify-content:flex-start; align-items:center; gap:8px;">
                <strong id="editor-title" style="flex:1; font-size:11px;">Cấu hình Workflow</strong>
                <span id="close-modal" style="cursor:pointer; font-size:16px; font-weight:bold;">[X]</span>
            </div>
            <div id="editor-panel-content" style="padding:8px;">
                <input type="hidden" id="editing_workflow_id">
                <div class="wwe-form-group">
                    <label>Tên tác vụ:</label>
                    <input type="text" id="workflow_name_input" class="wwe-input" placeholder="Ví dụ: Update CHXD">
                </div>
                <hr style="border:inset 1px #fff; margin:8px 0;">
                <div id="sdk-tasks-container" style="max-height: 400px; overflow-y: auto;"></div>
            </div>
            <div style="padding:8px; border-top:1px inset #fff; display:flex; justify-content:flex-start; gap:8px; background: #c0c0c0;">
                <button id="cancel_workflow_btn" class="action-btn">Hủy</button>
                <button id="save_workflow_btn" class="action-btn primary">Lưu</button>
            </div>
        </div>`;
        document.body.appendChild(modal);
        document.getElementById('close-modal').onclick = closeWorkflowEditor;
        document.getElementById('cancel_workflow_btn').onclick = closeWorkflowEditor;
        document.getElementById('save_workflow_btn').onclick = saveWorkflowFromEditor;
        makeDraggable(document.getElementById('workflow-editor-content'), document.getElementById('editor-header'));
    }
    function renderSdkTasksInEditor(existingTasks = []) {
        const container = document.getElementById('sdk-tasks-container');
        container.innerHTML = '';
        Object.keys(SDK_REGISTRY).forEach(taskId => {
            const def = SDK_REGISTRY[taskId];
            const existing = existingTasks.find(t => t.taskId === taskId) || { enabled: false, params: {} };
            const wrapper = document.createElement('div');
            wrapper.style.cssText = "border: 1px solid #ddd; margin-bottom: 8px; padding: 10px; border-radius: 4px; background: #fafafa;";
            const header = document.createElement('div');
            header.innerHTML = `
                <label style="font-weight: bold; color: #333; display: flex; align-items: center; cursor: pointer;">
                    <input type="checkbox" class="task-enable-cb" data-task-id="${taskId}" ${existing.enabled ? 'checked' : ''} style="width: auto; margin-right: 8px;">
                    ${def.name}
                </label>
                <div style="font-size: 0.85em; color: #666; margin-left: 24px; margin-bottom: 5px;">${def.description}</div>
            `;
            wrapper.appendChild(header);
            if (def.params.length > 0) {
                const paramsDiv = document.createElement('div');
                paramsDiv.className = 'task-params';
                paramsDiv.style.cssText = `margin-left: 24px; display: ${existing.enabled ? 'block' : 'none'};`;
                def.params.forEach(p => {
                    const row = document.createElement('div');
                    row.style.marginBottom = '5px';
                    const val = existing.params[p.key] || '';
                    row.innerHTML = `
                        <label style="display:block; font-size: 11px; margin-bottom: 2px;">${p.label}:</label>
                        <input type="text" class="task-param-input" data-task-id="${taskId}" data-param-key="${p.key}" value="${val}" placeholder="${p.placeholder}" style="width: 100%;">
                    `;
                    paramsDiv.appendChild(row);
                });
                wrapper.appendChild(paramsDiv);
            }
            container.appendChild(wrapper);
        });
        container.querySelectorAll('.task-enable-cb').forEach(cb => {
            cb.addEventListener('change', (e) => {
                const paramsDiv = e.target.closest('div').parentElement.querySelector('.task-params');
                if (paramsDiv) paramsDiv.style.display = e.target.checked ? 'block' : 'none';
            });
        });
    }
    function registerHotkeys() {
        const shortcuts = [
            { id: "wfe-next-link", keys: "Ctrl+39", desc: "WFE: Next Link", cb: () => navigate(1) },
            { id: "wfe-previous-link", keys: "Ctrl+37", desc: "WFE: Previous Link", cb: () => navigate(-1) },
            { id: "wfe-reselect-link", keys: "Ctrl+38", desc: "WFE: Reselect Current Link", cb: () => processCurrentLink() },
            { id: "wfe-run-workflow", keys: "Ctrl+40", desc: "WFE: Run Workflow", cb: () => runSelectedWorkflow(false) },
            { id: "wfe-mark-not-exist", keys: "AS+U", desc: "WFE: Mark as Not Exist", cb: () => { updateStatus('Không tồn tại'); WazeToastr.Alerts.info('WME WFE', 'Đã đánh dấu: Không tồn tại', false, false, 2000); } }
        ];

        shortcuts.forEach(({ id, keys, desc, cb }) => {
            try {
                if (wmeSDK.Shortcuts.isShortcutRegistered({ shortcutId: id })) return;
                wmeSDK.Shortcuts.createShortcut({
                    shortcutId: id,
                    shortcutKeys: keys,
                    description: desc,
                    callback: cb
                });
            } catch (e) {
                console.error(`WME Workflow Engine: Error registering shortcut ${id}`, e);
            }
        });
    }
    function navigate(direction, targetIndex = null) {
        placeholderCache.clear();
        if (isLooping) return;
        if (permalinks.length === 0) return;

        let newIndex = (targetIndex !== null) ? targetIndex : (currentIndex + direction);

        if (newIndex >= 0 && newIndex < permalinks.length) {

            const previousIndex = currentIndex;
            const navigationDirection = newIndex - currentIndex;

            if (previousIndex >= 0 && previousIndex !== newIndex) {
                const currentItemStatus = permalinks[previousIndex].status?.toLowerCase();
                const shouldSavePermalink = document.getElementById('save_permalink_after_create')?.checked;
                if (shouldSavePermalink && navigationDirection > 0) {
                    const newPermalink = wmeSDK.Map.getPermalink();
                    if (newPermalink) {
                        updatePermalinkInWorkbook(previousIndex, newPermalink);
                    } else {
                        log(`⚠️ Không lấy được Permalink cho mục ${previousIndex + 1}.`, 'warn');
                    }
                }
                if (currentItemStatus === 'đang tạo' || currentItemStatus === '') {
                    updateStatusByIndex(previousIndex, 'Đã tạo');
                }
            }

            currentIndex = newIndex;
            if (!permalinks[currentIndex].status || permalinks[currentIndex].status.toLowerCase() !== 'đang tạo') {
                updateStatus('Đang tạo');
                permalinks[currentIndex].status = 'Đang tạo';
            }

            updateUIState();
            processCurrentLink();
        }
    }
    /**
        * Cập nhật status cho một URL cụ thể theo index
        */
    function updateStatusByIndex(index, status) {
        const shouldSave = isStatusSavingEnabled();
        if (isGasMode) {
            if (index >= 0 && permalinks[index]) {
                const item = permalinks[index];
                if (shouldSave) {
                    updateGasStatusByRowIndex(item.rowIndex, status);
                }
                item.status = status;
            }
        } else {
            if (index >= 0 && permalinks[index] && permalinks[index].localFileIndexes) {
                const item = permalinks[index];
                if (shouldSave) {
                    _updateLocalStatusCell(item.rowIndex, item.localFileIndexes.statusCol, status, item.localFileIndexes.sheetName);
                }
                item.status = status;
            }
        }
    }
    function extractCoords(item) {
        const coordMatch = item.url.match(/(-?\d+\.?\d*)\s*,\s*(-?\d+\.?\d*)/);
        if (coordMatch) return { lat: parseFloat(coordMatch[1]), lon: parseFloat(coordMatch[2]) };
        const urlMatch = item.url.match(/lat=(-?\d+\.\d+)&lon=(-?\d+\.\d+)/);
        if (urlMatch) return { lat: parseFloat(urlMatch[1]), lon: parseFloat(urlMatch[2]) };
        return null;
    }
    async function handleBatchSave() {
        const isEnabled = document.getElementById('batch_save_enabled')?.checked;
        if (!isEnabled) return;
        const limit = parseInt(document.getElementById('batch_save_limit')?.value) || 1;
        batchRunCounter++;
        if (batchRunCounter >= limit) {
            try {
                await wmeSDK.Editing.save();
                wmeSDK.Events.on({
                    eventName: "wme-save-finished",
                    eventHandler: () => { batchRunCounter = 0 }
                })
                log(`Batch Save: Đã tự động lưu ${limit} đối tượng.`, 'success');
            } catch (err) {
                log(`Lỗi khi Batch Save: ${err.message}`, 'error');
            }
        }
    }
    async function processCurrentLink() {
        if (currentIndex < 0 || currentIndex >= permalinks.length) return;
        const item = permalinks[currentIndex];
        currentRowData = item.rowData;
        const coords = extractCoords(item);
        if (coords) {
            const zoom = parseInt(document.getElementById('coordinate_zoom')?.value || 20);
            W.map.setCenter(WazeWrap.Geometry.ConvertTo900913(coords.lon, coords.lat), zoom);
        }
        await parseWazeUrlAndNavigate(item.url);
    }
    function updatePermalinkInWorkbook(index, newPermalink) {
        if (!document.getElementById('save_permalink_after_create')?.checked) return;
        const item = permalinks[index];
        if (!item) return;
        if (isGasMode) {
            updateGasStatusByRowIndex(item.rowIndex, item.status, newPermalink);
            // item.url = newPermalink;
            const urlColName = document.getElementById('url_col_name')?.value?.trim() || 'New Permalink';
            item.rowData[urlColName] = newPermalink;
        } else {
            if (!workbookData || !item.localFileIndexes) return;
            try {
                const sheet = workbookData.Sheets[item.localFileIndexes.sheetName];
                const statusColIndex = item.localFileIndexes.statusCol;
                const newColIndex = statusColIndex + 1;
                const NEW_COL_NAME = "New Permalink";
                const rowIndex = item.rowIndex;
                const headerAddress = XLSX.utils.encode_cell({ r: 0, c: newColIndex });
                if (!sheet[headerAddress] || sheet[headerAddress].v !== NEW_COL_NAME) {
                    sheet[headerAddress] = { t: 's', v: NEW_COL_NAME };
                }
                const cellAddress = XLSX.utils.encode_cell({ r: rowIndex, c: newColIndex });
                sheet[cellAddress] = { t: 's', v: newPermalink };
                const range = XLSX.utils.decode_range(sheet['!ref']);
                if (newColIndex > range.e.c) {
                    range.e.c = newColIndex;
                    sheet['!ref'] = XLSX.utils.encode_range(range);
                }
                // item.url = newPermalink;
                const urlColLetter = getColumnLetter(item.localFileIndexes.urlCol);
                item.rowData[urlColLetter] = newPermalink;
                hasUnsavedChanges = true;
                updateSaveButtonState();
            } catch (err) {
                log(`❌ Lỗi khi cập nhật file local: ${err.message}`, "error");
                console.error(err);
            }
        }
    }
    async function parseWazeUrlAndNavigate(value) {
        return new Promise(async (resolve, reject) => {
            try {
                const trimmedValue = value.trim();

                // 1. Kiểm tra tọa độ thuần (VD: "10.123, 106.456")
                const coordMatch = trimmedValue.match(/^\s*\(?\s*(-?\d+\.?\d*)\s*,\s*(-?\d+\.?\d*)\s*\)?\s*$/);
                if (coordMatch) {
                    const lat = parseFloat(coordMatch[1]);
                    const lon = parseFloat(coordMatch[2]);
                    if (isNaN(lat) || isNaN(lon)) {
                        return reject(new Error('Tọa độ không hợp lệ.'));
                    }
                    const zoomInput = document.getElementById('coordinate_zoom');
                    const defaultZoom = zoomInput ? parseInt(zoomInput.value, 10) : 20;
                    W.map.setCenter(WazeWrap.Geometry.ConvertTo900913(lon, lat), defaultZoom);
                    W.selectionManager.setSelectedModels([]);
                    return resolve();
                }

                // 2. Thử parse như WME URL (phải có param lat & lon)
                let isWmeLink = false;
                try {
                    const parsedUrl = new URL(trimmedValue);
                    const params = parsedUrl.searchParams;
                    if (params.get('lat') && params.get('lon')) {
                        isWmeLink = true;
                    }
                } catch (_) { }

                // 3. Nếu không phải WME link → follow redirect rồi gọi lại
                if (!isWmeLink && /^https?:\/\//i.test(trimmedValue)) {
                    log(`URL trung gian, đang follow redirect...`, 'info');
                    GM_xmlhttpRequest({
                        method: 'GET',
                        url: trimmedValue,
                        onload: async (res) => {
                            if (res.finalUrl && res.finalUrl !== trimmedValue) {
                                try {
                                    await parseWazeUrlAndNavigate(res.finalUrl);
                                    resolve();
                                } catch (e) { reject(e); }
                            } else {
                                log(`Không tìm thấy redirect. URL cuối: ${res.finalUrl || trimmedValue}`, 'warn');
                                resolve(); // Vẫn resolve để loop tiếp tục
                            }
                        },
                        onerror: (err) => {
                            log(`Lỗi khi follow redirect: ${trimmedValue}`, 'error');
                            reject(err);
                        }
                    });
                    return;
                } else if (!isWmeLink) {
                    return resolve(); // Không phải URL, có thể là rác
                }

                // 4. Xử lý WME link chuẩn
                const parsedUrl = new URL(trimmedValue);
                const params = parsedUrl.searchParams;
                const lon = parseFloat(params.get('lon'));
                const lat = parseFloat(params.get('lat'));
                const rawZoom = parseInt(params.get('zoomLevel') || params.get('zoom'), 10);
                const zoomInput = document.getElementById('coordinate_zoom');
                let zoom;
                if (rawZoom < 15) {
                    zoom = zoomInput ? parseInt(zoomInput.value, 10) : 20;
                } else {
                    zoom = rawZoom + 2;
                }
                W.map.setCenter(WazeWrap.Geometry.ConvertTo900913(lon, lat), zoom);
                const segmentIDs = (params.get('segments') || '').split(',').filter(id => id);
                const venueIDs = (params.get('venues') || '').split(',').filter(id => id);
                const totalIDs = segmentIDs.length + venueIDs.length;

                if (totalIDs === 0) return resolve();

                WazeWrap.Model.onModelReady(async () => {
                    const maxRetries = 15;
                    const retryDelay = 1000;

                    for (let attempt = 1; attempt <= maxRetries; attempt++) {
                        await delay(retryDelay);
                        let objectsToSelect = [];

                        if (segmentIDs.length > 0) {
                            const segments = segmentIDs.map(id => W.model.segments.getObjectById(id)).filter(Boolean);
                            objectsToSelect.push(...segments);
                        }
                        if (venueIDs.length > 0) {
                            const venues = venueIDs.map(id => W.model.venues.getObjectById(id)).filter(Boolean);
                            objectsToSelect.push(...venues);
                        }

                        if (objectsToSelect.length >= totalIDs) {
                            W.selectionManager.setSelectedModels(objectsToSelect);
                            await delay(300); // Đợi UI/Model cập nhật selection
                            return resolve();
                        }

                        if (attempt === maxRetries) {
                            if (objectsToSelect.length > 0) {
                                W.selectionManager.setSelectedModels(objectsToSelect);
                                await delay(300);
                                log(`Chỉ tìm thấy ${objectsToSelect.length}/${totalIDs} đối tượng sau ${maxRetries} lần thử.`, 'warn');
                                resolve();
                            } else {
                                reject(new Error('Không tìm thấy đối tượng'));
                            }
                        }
                    }
                }, true);
            } catch (error) {
                log(`Lỗi khi xử lý "${value}": ${error.message}`, 'error');
                reject(error);
            }
        });
    }
    function updateUIState() {
        const hasLinks = permalinks.length > 0;
        const isEnd = currentIndex >= permalinks.length - 1;
        const isStart = currentIndex <= 0;
        const elements = {
            'prev_btn': !hasLinks || isStart || isLooping,
            'next_btn': !hasLinks || isEnd || isLooping,
            'reselect_btn': !hasLinks || isLooping,
            'run_workflow_btn': !document.getElementById('workflow_select').value || isLooping,
            'nav_index_input': !hasLinks || isLooping,
            'loop_workflow_btn': !hasLinks
        };
        Object.entries(elements).forEach(([id, disabled]) => {
            const el = document.getElementById(id);
            if (el) el.disabled = disabled;
        });
        const navInput = document.getElementById('nav_index_input');
        const navTotal = document.getElementById('nav_total_count');
        if (navInput && hasLinks) {
            navInput.value = currentIndex + 1;
            navInput.max = permalinks.length;
            navTotal.textContent = ` / ${permalinks.length}`;
        }
        const loopBtn = document.getElementById('loop_workflow_btn');
        if (loopBtn) {
            loopBtn.textContent = isLooping ? 'Dừng Lặp' : 'Bắt đầu Lặp';
            loopBtn.classList.toggle('looping', isLooping);
        }
        updateSaveButtonState();
    }
    function populateWorkflowSelector() {
        const select = document.getElementById('workflow_select');
        if (!select) return;
        const currentId = select.value;
        select.innerHTML = '';
        const emptyOption = document.createElement('option');
        emptyOption.value = '';
        emptyOption.textContent = Object.keys(allWorkflows).length === 0 ? '--- Không có workflow ---' : '--- Chọn workflow ---';
        select.appendChild(emptyOption);
        for (const id in allWorkflows) {
            const option = document.createElement('option');
            option.value = id;
            option.textContent = allWorkflows[id].name;
            select.appendChild(option);
        }
        if (currentId && allWorkflows[currentId]) {
            select.value = currentId;
        } else if (Object.keys(allWorkflows).length > 0) {
            const firstWorkflowId = Object.keys(allWorkflows)[0];
            if (firstWorkflowId) {
                select.value = firstWorkflowId;
            }
        } else {
            select.value = '';
        }
        updateUIState();
    }
    function deleteSelectedWorkflow() {
        const select = document.getElementById('workflow_select');
        const idToDelete = select.value;
        const workflowName = allWorkflows[idToDelete]?.name;
        if (!idToDelete) {
            alert("Vui lòng chọn một workflow để xóa.");
            return;
        }
        if (confirm(`Bạn có chắc chắn muốn xóa workflow "${workflowName}" không?`)) {
            delete allWorkflows[idToDelete];
            saveWorkflows();
            populateWorkflowSelector();
            log(`Đã xóa workflow: "${workflowName}"`, 'info');
        }
    }
    function openWorkflowEditor(workflowId = null) {
        const modal = document.getElementById('workflow-editor-modal');
        const nameInput = document.getElementById('workflow_name_input');
        const idInput = document.getElementById('editing_workflow_id');
        const title = document.getElementById('editor-title');
        if (workflowId && allWorkflows[workflowId]) {
            const wf = allWorkflows[workflowId];
            title.textContent = "Chỉnh sửa Workflow";
            nameInput.value = wf.name;
            idInput.value = workflowId;
            renderSdkTasksInEditor(wf.tasks || []);
        } else {
            title.textContent = "Tạo Workflow Mới";
            nameInput.value = '';
            idInput.value = '';
            renderSdkTasksInEditor([]);
        }
        modal.style.display = 'block';
    }
    function closeWorkflowEditor() {
        document.getElementById('workflow-editor-modal').style.display = 'none';
    }
    function saveWorkflowFromEditor() {
        const name = document.getElementById('workflow_name_input').value.trim();
        if (!name) return alert("Vui lòng nhập tên tác vụ.");
        const tasks = [];
        document.querySelectorAll('.task-enable-cb').forEach(cb => {
            if (cb.checked) {
                const taskId = cb.dataset.taskId;
                const params = {};
                document.querySelectorAll(`.task-param-input[data-task-id="${taskId}"]`).forEach(inp => {
                    params[inp.dataset.paramKey] = inp.value;
                });
                tasks.push({ taskId, enabled: true, params });
            }
        });
        if (tasks.length === 0) return alert("Vui lòng chọn ít nhất một hành động.");
        let id = document.getElementById('editing_workflow_id').value;
        if (!id) id = `sdk_wf_${Date.now()}`;
        allWorkflows[id] = { name, tasks };
        saveWorkflows();
        populateWorkflowSelector();
        document.getElementById('workflow_select').value = id;
        closeWorkflowEditor();
        log(`Đã lưu workflow SDK "${name}"`, 'success');
    }
    function saveAllSettings() {
        const settings = {};
        SETTINGS_IDS.forEach(id => {
            const el = document.getElementById(id);
            if (el) {
                if (el.type === 'checkbox') settings[id] = el.checked;
                else settings[id] = el.value;
            }
        });
        const dataSource = document.querySelector('input[name="data_source_mode"]:checked')?.value;
        if (dataSource) settings.data_source_mode = dataSource;
        const poiMode = document.querySelector('input[name="poi_creation_mode"]:checked')?.value;
        if (poiMode) settings.poi_creation_mode = poiMode;
        localStorage.setItem(STORAGE_KEY_SETTINGS, JSON.stringify(settings));
    }
    function loadAllSettings() {
        try {
            const saved = localStorage.getItem(STORAGE_KEY_SETTINGS);
            if (!saved) return;
            const settings = JSON.parse(saved);
            Object.entries(settings).forEach(([id, val]) => {
                const el = document.getElementById(id);
                if (el) {
                    if (el.type === 'checkbox') el.checked = val;
                    else el.value = val;
                }
            });
            if (settings.data_source_mode) {
                const r = document.querySelector(`input[name="data_source_mode"][value="${settings.data_source_mode}"]`);
                if (r) {
                    r.checked = true;
                    isGasMode = (settings.data_source_mode === 'gas');
                    document.getElementById('local_file_config').style.display = settings.data_source_mode === 'local' ? 'block' : 'none';
                    document.getElementById('gas_config').style.display = settings.data_source_mode === 'local' ? 'none' : 'block';
                    document.getElementById('save_status_btn').textContent = settings.data_source_mode === 'local' ? '💾 Lưu Status' : '☁️ Auto Sync';
                }
            }
            if (settings.poi_creation_mode) {
                const r = document.querySelector(`input[name="poi_creation_mode"][value="${settings.poi_creation_mode}"]`);
                if (r) r.checked = true;
            }
            if (settings.poi_category_select) selectedSubCategory = settings.poi_category_select;
        } catch (e) {
            log('Lỗi khi tải cài đặt.', 'error');
            console.error(e);
        }
    }
    resetData()
    /**
         * Tải dữ liệu từ Google Sheets thông qua GAS Web App.
         */
    function loadFromGoogleSheet() {
        const scriptUrl = document.getElementById('gas_url')?.value?.trim() || '';
        const sheetName = document.getElementById('sheet_name_input')?.value?.trim() || '';
        const urlColName = document.getElementById('url_col_name')?.value?.trim() || '';
        const skipDone = document.getElementById('skip_done_check')?.checked || false;
        if (!scriptUrl) { alert("Vui lòng nhập Web App URL!"); return; }
        saveAllSettings();
        permalinks = [];
        currentIndex = -1;
        previousIndex = -1;
        isGasMode = true;
        gasHeaders = null;
        hasUnsavedChanges = false;
        log("Đang tải dữ liệu từ Google Sheets...");
        const loadBtn = document.getElementById('load_sheet_btn');
        if (loadBtn) loadBtn.disabled = true;
        const readUrl = `${scriptUrl}?action=get&sheetName=${encodeURIComponent(sheetName)}`;
        GM_xmlhttpRequest({
            method: "GET",
            url: readUrl,
            onload: function (response) {
                if (loadBtn) loadBtn.disabled = false;
                if (response.status !== 200) {
                    log(`❌ Lỗi kết nối GAS: Status ${response.status}. Kiểm tra URL và quyền truy cập.`, 'error');
                    isGasMode = false;
                    updateUIState();
                    return;
                }
                try {
                    const json = JSON.parse(response.responseText);
                    if (json.result === "success" && json.data) {
                        if (json.headers && Array.isArray(json.headers)) {
                            gasHeaders = json.headers;
                            log("Đã load dữ liệu từ GG Sheets thành công", 'success')
                        } else {
                            log("Cảnh báo: Không nhận được headers từ GAS, mapping {{tên cột}} có thể không chính xác.", 'warn');
                        }
                        let foundIndex = -1;
                        let tempPermalinks = [];
                        json.data.forEach(row => {
                            const url = row[urlColName] || "";
                            const stt = row[STATUS_COL_NAME] || "";
                            const rowIndex = row["_rowIndex"] || null;
                            if (url && rowIndex !== null) {
                                const statusTrimmed = stt.toString().trim().toLowerCase();
                                if (skipDone && statusTrimmed === 'đã tạo') {
                                    return;
                                }
                                tempPermalinks.push({
                                    url: url.toString().trim(),
                                    rowIndex: rowIndex,
                                    status: statusTrimmed,
                                    rowData: row
                                });
                                if (foundIndex === -1 && statusTrimmed === 'đang tạo') {
                                    foundIndex = tempPermalinks.length - 1;
                                }
                            }
                        });
                        permalinks = tempPermalinks;
                        if (foundIndex === -1) {
                            foundIndex = permalinks.findIndex(p => p.status !== 'đã tạo');
                            if (foundIndex === -1 && permalinks.length > 0) foundIndex = 0;
                        }
                        currentIndex = foundIndex === -1 ? 0 : foundIndex;
                        if (permalinks.length > 0) {
                            updateStatus('Đang tạo');
                        }
                        updateUIState();
                        processCurrentLink();
                    } else {
                        log("❌ Lỗi Sheet: " + (json.message || "Lỗi dữ liệu trả về."));
                        isGasMode = false;
                    }
                } catch (e) {
                    log("❌ Lỗi parse JSON hoặc lỗi xử lý dữ liệu: " + e.message, 'error');
                    console.error(e);
                    isGasMode = false;
                }
            },
            onerror: function (err) {
                if (loadBtn) loadBtn.disabled = false;
                log("❌ Lỗi kết nối mạng GAS.", 'error');
                console.error(err);
                isGasMode = false;
            }
        });
    }
    function updateGasStatusByRowIndex(rowIndex, newStatus, newPermalink = null) {
        if (!isGasMode || !rowIndex) return;
        const scriptUrl = document.getElementById('gas_url')?.value?.trim();
        const sheetName = document.getElementById('sheet_name_input')?.value?.trim();
        if (!scriptUrl || !sheetName) {
            log('Lỗi: Thiếu Web App URL hoặc Tên Sheet để cập nhật GAS.', 'error');
            return;
        }
        let url = `${scriptUrl}?action=post&rowIndex=${rowIndex}&status=${encodeURIComponent(newStatus)}&sheetName=${encodeURIComponent(sheetName)}`;
        if (newPermalink) {
            const urlColName = document.getElementById('url_col_name')?.value?.trim();
            if (urlColName) {
                url += `&urlCol=${encodeURIComponent(urlColName)}`;
                url += `&permalink=${encodeURIComponent(newPermalink)}`;
            }
        }
        GM_xmlhttpRequest({
            method: "GET",
            url: url,
            onload: (response) => {
                try {
                    const res = JSON.parse(response.responseText);
                    if (res.result !== "success") {
                        log(`⚠️ Lỗi GAS ghi status (Row ${rowIndex}): ${res.message}`, 'warn');
                    }
                } catch (e) {
                    log(`⚠️ Lỗi phản hồi JSON từ GAS khi ghi status.`, 'warn');
                }
            },
            onerror: (err) => {
                log(`❌ Lỗi kết nối khi cập nhật GAS status (Row ${rowIndex}).`, 'error');
            }
        });
    }
    bootstrap();
})();