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.

이 스크립트를 설치하려면 Tampermonkey, Greasemonkey 또는 Violentmonkey와 같은 확장 프로그램이 필요합니다.

이 스크립트를 설치하려면 Tampermonkey와 같은 확장 프로그램을 설치해야 합니다.

이 스크립트를 설치하려면 Tampermonkey 또는 Violentmonkey와 같은 확장 프로그램이 필요합니다.

이 스크립트를 설치하려면 Tampermonkey 또는 Userscripts와 같은 확장 프로그램이 필요합니다.

이 스크립트를 설치하려면 Tampermonkey와 같은 확장 프로그램이 필요합니다.

이 스크립트를 설치하려면 유저 스크립트 관리자 확장 프로그램이 필요합니다.

(이미 유저 스크립트 관리자가 설치되어 있습니다. 설치를 진행합니다!)

이 스타일을 설치하려면 Stylus와 같은 확장 프로그램이 필요합니다.

이 스타일을 설치하려면 Stylus와 같은 확장 프로그램이 필요합니다.

이 스타일을 설치하려면 Stylus와 같은 확장 프로그램이 필요합니다.

이 스타일을 설치하려면 유저 스타일 관리자 확장 프로그램이 필요합니다.

이 스타일을 설치하려면 유저 스타일 관리자 확장 프로그램이 필요합니다.

이 스타일을 설치하려면 유저 스타일 관리자 확장 프로그램이 필요합니다.

(이미 유저 스타일 관리자가 설치되어 있습니다. 설치를 진행합니다!)

// ==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();
})();