import sys
from pathlib import Path
sys.path.insert(0, str(Path("work/python-deps").resolve()))
from lupa.lua51 import LuaRuntime
PACKAGE=Path(__file__).resolve().parent.parent
core=(PACKAGE/"LockPort.lua").read_text(encoding="utf-8")
setup=r'''
now=100; raidSize=5; partySize=0; moving=0; casting=nil; nativeOK=true
function GetTime() return now end
function GetRaidRosterInfo() return nil end
function GetNumRaidMembers() return raidSize end
function GetNumPartyMembers() return partySize end
function GetLockPortVersion() return "1.2.1" end
function LockPortNativeSummon(unit) nativeCalls=(nativeCalls or 0)+1; lastUnit=unit; return nativeOK end
function GetUnitSpeed() return moving end
function UnitName(u) if u=="player" then return "Tester" end return "Bob" end
function UnitClass() return "Warlock","WARLOCK" end
function UnitAffectingCombat() return false end
function UnitIsConnected() return true end
function UnitIsDeadOrGhost() return false end
function CreateFrame() return {RegisterEvent=function() end, SetScript=function() end} end
function SendAddonMessage() end
function SendChatMessage() end
function GetZoneText() return "Test" end
function GetSubZoneText() return "" end
function TargetUnit() end
function CastSpellByName() manualCalls=(manualCalls or 0)+1 end
C_Spell={UnitCastingInfo=function() return casting end,UnitChannelInfo=function() return nil end}
SlashCmdList={}
LockPortOptions={announceOpen=false,askHelpers=false,autoRemove=true}
'''
def env():
    L=LuaRuntime()
    L.execute(setup); L.execute(core)
    L.execute(r'''
LP=LockPort; LP.mods={}
LP.Print=function(self,text) lastPrint=text end
LP.RefreshOptions=function() end; LP.UpdateUI=function() end
LP.OpenAnnounce=function() openCalls=(openCalls or 0)+1 end
LP.ReadyState=function() return true end
LP.NextCandidate=function() if LP.autoRetryAfter and LP.autoRetryAfter.Bob and now<LP.autoRetryAfter.Bob then return nil end;return {name="Bob"} end
LP.Summon=function(self,name,automatic) casts=(casts or 0)+1; wasAutomatic=automatic end
''')
    return L
def check(name,script):
    L=env(); L.execute(script); print("PASS",name)
check("off without native DLL",r'''GetLockPortVersion=nil; LP:SetRaidAutoSummon(true); assert(not LP.raidAutoSummon)''')
check("requires group",r'''raidSize=0; LP:SetRaidAutoSummon(true); assert(not LP.raidAutoSummon)''')
check("enables open announcements",r'''LP:SetRaidAutoSummon(true); assert(LP.raidAutoSummon and LockPortOptions.announceOpen and openCalls==1)''')
check("auto starts without input after settling",r'''LP:SetRaidAutoSummon(true); LP:CheckRaidAutoSummon(100); LP:CheckRaidAutoSummon(101); assert(not casts); LP:CheckRaidAutoSummon(102); assert(casts==1 and wasAutomatic)''')
check("no duplicate or immediate uncertain retry",r'''LP:SetRaidAutoSummon(true); LP:CheckRaidAutoSummon(100); now=102;LP:CheckRaidAutoSummon(now); now=103;LP:CheckRaidAutoSummon(now);now=106;LP:CheckRaidAutoSummon(now); assert(casts==1)''')
check("movement pauses auto casting",r'''LP:SetRaidAutoSummon(true);moving=7; LP:CheckRaidAutoSummon(100);LP:CheckRaidAutoSummon(110);assert(not casts)''')
check("live ClassicAPI casting pauses auto casting",r'''LP:SetRaidAutoSummon(true);casting="Shadow Bolt"; LP:CheckRaidAutoSummon(100);LP:CheckRaidAutoSummon(110);assert(not casts)''')
check("works without ClassicAPI",r'''GetUnitSpeed=nil;C_Spell=nil;LP:SetRaidAutoSummon(true); LP:CheckRaidAutoSummon(100); LP:CheckRaidAutoSummon(102);assert(casts==1)''')
check("not ready pauses auto casting",r'''LP.ReadyState=function() return false end;LP:SetRaidAutoSummon(true);LP:CheckRaidAutoSummon(100);LP:CheckRaidAutoSummon(102);assert(not casts)''')
check("leaving raid disables and restores announcements",r'''LP:SetRaidAutoSummon(true);raidSize=0;LP.CheckRaidAutoSummon(LP,101);assert(not LP.raidAutoSummon and not LockPortOptions.announceOpen)''')
check("disabling auto always disables announcements",r'''LockPortOptions.announceOpen=true;LP:SetRaidAutoSummon(true);LP:SetRaidAutoSummon(false);assert(not LockPortOptions.announceOpen)''')
check("native disappearance disables",r'''LP:SetRaidAutoSummon(true);LockPortNativeSummon=nil;LP:CheckRaidAutoSummon(101);assert(not LP.raidAutoSummon)''')
# Test actual FinishPending and arrival watcher, with mocked game state.
for arrived in (True,False):
    L=env()
    L.execute(r'''
LP.pending={name="Bob",unit="raid2",started=true,interrupted=true}
LP.ScanRoster=function() return {Bob={unit="raid3"}} end
LP.IsNearby=function() return '''+("true" if arrived else "false")+r''' end
LP.RemoveRequest=function() removed=true end
LP.AddRequest=function() requeued=true end
LP.Fail=function() failureAnnouncements=(failureAnnouncements or 0)+1 end
LP:FinishPending()
assert(not failureAnnouncements)
assert(not LP.failCount.Bob)
''')
    L.execute('assert(removed)' if arrived else 'assert(requeued and LP.watch.unconfirmed)')
    print("PASS interruption with "+("arrival" if arrived else "unconfirmed completion"))
# Real Summon path: native attempt, manual fallback, and native rejection.
for native in (True,False):
    L=env();L.execute(core)
    L.execute(r'''
LP=LockPort;LP.Print=function() end;LP.UpdateUI=function() end
LP.IsWarlock=function() return true end;LP.KnowsRitual=function() return true end
LP.ScanRoster=function() return {Bob={unit="raid2"}} end
LP.TargetProblem=function() return nil end;LP.CountShards=function() return 5 end
LP.CountHelpers=function() return 2 end;LP.SendAddon=function() end
LP:Summon("Bob",'''+("true" if native else "false")+r''')
assert(LP.pending.name=="Bob")
''')
    L.execute('assert(nativeCalls==1 and not manualCalls)' if native else 'assert(manualCalls==1 and not nativeCalls)')
    print("PASS "+("automatic native spellbook" if native else "manual")+" Summon dispatch")
# All delivered Lua files parse with a Lua 5.1 runtime; source uses Lua 5.0 syntax.
L=LuaRuntime()
for p in PACKAGE.glob("*.lua"):
    L.execute('assert(loadstring(...))',p.read_text(encoding="utf-8"))
    print("PASS syntax",p.name)

# Build UI with lightweight frame mocks to check control placement and gating.
L=env()
L.execute(r'''
StaticPopupDialogs={};UISpecialFrames={};RAID_CLASS_COLORS={}
frames={}
local methods={}
function methods:GetName() return self.name end
function methods:SetText(v) self.text=v end
function methods:SetWidth(v) self.width=v end
function methods:SetHeight(v) self.height=v end
function methods:SetPoint(...) self.point={...} end
function methods:ClearAllPoints() self.point=nil end
function methods:SetScript(name,fn) self.scripts[name]=fn end
function methods:Hide() self.visible=false end
function methods:Show() self.visible=true end
function methods:IsVisible() return self.visible end
function methods:Enable() self.enabled=true end
function methods:Disable() self.enabled=false end
function methods:SetChecked(v) self.checked=v end
function methods:GetChecked() return self.checked end
local function frame(name)
 local f={name=name,scripts={},visible=true,enabled=true}
 setmetatable(f,{__index=function(t,k) return methods[k] or function() end end})
 if name then _G[name]=f;frames[name]=f end
 return f
end
function methods:CreateTexture(name) return frame(name) end
function methods:CreateFontString(name) return frame(name) end
function CreateFrame(kind,name) return frame(name) end
function getglobal(name) return _G[name] end
function GetBindingKey() return nil end
function PlaySound() end
LP.RefreshOptions=function() end
LP.ScanRoster=function() return {} end
LP.SortedRequests=function() return {} end
LP.CountShards=function() return 5 end
LP.InGroup=function() return raidSize>0 or partySize>0 end
LP.CountHelpers=function() return 2 end
LockPortOptions.theme="classic"
''')
L.execute((PACKAGE/"LockPort_UI.lua").read_text(encoding="utf-8"))
L.execute(r'''
LP:CreateUI()
LockPortFrame:Show();LP:RefreshList()
assert(LockPortFrame.raidAuto.visible)
assert(LockPortFrame.raidAuto.width==95 and LockPortFrame.groupSummon.width==95)
assert(LockPortFrame.groupSummon.visible and LockPortFrame.groupSummon.point[2]==LockPortFrame.raidAuto)
LP:ToggleGroups();assert(LockPortGroupsFrame.visible)
this=LockPortGroupsNone;this.scripts.OnClick();assert(LockPortOptions.summonGroups and not next(LockPortOptions.summonGroups))
this=LockPortGroupsFrame.groups[3];this.scripts.OnClick();assert(LockPortOptions.summonGroups[3])
this=LockPortGroupsAll;this.scripts.OnClick();assert(not LockPortOptions.summonGroups)
assert(LockPortFrame.summon.width==95 and LockPortFrame.chatToggle.width==95)
this=LockPortFrame.chatToggle;this.scripts.OnClick();assert(LockPortOptions.chatMuted)
LP:RefreshList();assert(string.find(this.text,"Off"))
this.scripts.OnClick();assert(not LockPortOptions.chatMuted)
local nativeHeight=LockPortFrame.height
assert(LockPortFrame.raidAuto.point[1]=="TOPLEFT")
assert(LockPortFrame.raidAuto.point[3]=="BOTTOMLEFT" and LockPortFrame.raidAuto.point[5]==-2)
GetLockPortVersion=nil;LP:RefreshList()
assert(not LockPortFrame.raidAuto.visible and LockPortFrame.groupSummon.visible and LockPortFrame.height==nativeHeight)
GetLockPortVersion=function() return "1.2.1" end;raidSize=0;LP:RefreshList()
assert(LockPortFrame.raidAuto.visible and not LockPortFrame.raidAuto.enabled)
assert(LockPortFrame.groupSummon.visible and not LockPortFrame.groupSummon.enabled and not LockPortGroupsFrame.visible)
partySize=3;LP:RefreshList();assert(LockPortFrame.groupSummon.visible and not LockPortFrame.groupSummon.enabled)
GetLockPortVersion=nil;LP:RefreshList();assert(LockPortFrame.groupSummon.visible and not LockPortFrame.groupSummon.enabled and LockPortFrame.height==nativeHeight)
GetLockPortVersion=function() return "1.2.1" end;partySize=0
raidSize=5;LP:RefreshList();assert(LockPortFrame.raidAuto.enabled and LockPortFrame.groupSummon.enabled)
this=LockPortFrame.raidAuto;this.checked=true
this.scripts.OnClick()
assert(LP.raidAutoSummon and LockPortOptions.announceOpen)
''')
print("PASS UI native-only visibility, expanded layout, raid gating, and button toggle")

check("party enables automatic casting",r'''raidSize=0;partySize=3;LP:SetRaidAutoSummon(true);assert(LP.raidAutoSummon and LockPortOptions.announceOpen);LP:CheckRaidAutoSummon(100);LP:CheckRaidAutoSummon(102);assert(casts==1 and wasAutomatic)''')
check("raid to party conversion stays enabled",r'''LP:SetRaidAutoSummon(true);raidSize=0;partySize=3;LP:CheckRaidAutoSummon(100);assert(LP.raidAutoSummon);LP:CheckRaidAutoSummon(102);assert(casts==1)''')
check("leaving party disables and restores announcements",r'''raidSize=0;partySize=3;LP:SetRaidAutoSummon(true);partySize=0;LP:CheckRaidAutoSummon(101);assert(not LP.raidAutoSummon and not LockPortOptions.announceOpen)''')
check("old raid-only DLL is rejected",r'''GetLockPortVersion=function() return "1.0.0" end;assert(not LP:HasNativeMod());LP:SetRaidAutoSummon(true);assert(not LP.raidAutoSummon)''')

check("live idle clears stale busy flag",r'''LP.castBusy=true;LP:RecoverCastTracking(100);assert(not LP.castBusy)''')
check("missing stop event releases pending summon conservatively",r'''LP.pending={name="Bob",unit="party1",t=90,started=true};LP.FinishPending=function(self) assert(self.pending.interrupted);self.pending.done=true end;LP:RecoverCastTracking(100);assert(not LP.pending.done);LP:RecoverCastTracking(102);assert(LP.pending.done)''')
check("active channel is never cleared by recovery",r'''C_Spell.UnitChannelInfo=function() return "Ritual of Summoning" end;LP.pending={name="Bob",t=90,started=true};LP:RecoverCastTracking(100);LP:RecoverCastTracking(105);assert(not LP.pending.done and LP.castBusy)''')
check("unknown live state preserves tracking",r'''C_Spell=nil;LP.castBusy=true;LP.pending={name="Bob",t=90,started=true};LP:RecoverCastTracking(100);LP:RecoverCastTracking(105);assert(not LP.pending.done and LP.castBusy)''')
check("brief idle gap during casting is tolerated",r'''LP.pending={name="Bob",t=90,started=true};LP:RecoverCastTracking(100);casting="Ritual of Summoning";LP:RecoverCastTracking(101);assert(not LP.pending.inactiveSince and not LP.pending.done)''')

# Exercise the real scheduler, candidate checks, Summon, and start-event handler together.
for unit in ("party2", "raid2"):
    L=env();L.execute(core)
    L.execute(r'''
LP=LockPort
raidSize='''+("0" if unit.startswith("party") else "5")+r''';partySize=3
LP.Print=function() end;LP.UpdateUI=function() end;LP.RefreshOptions=function() end
LP.OpenAnnounce=function() end;LP.SendAddon=function() end
LP.KnowsRitual=function() return true end
LP.CountShards=function() return 5 end;LP.CountHelpers=function() return 2 end
LP.TargetProblem=function() return nil end
LP.roster={Bob={unit="'''+unit+r'''",online=true}}
LP.ScanRoster=function(self) return self.roster end
LP.SortedRequests=function(self) return {{name="Bob",info=self.roster.Bob}} end
LP.requests={{name="Bob",t=90}}
LockPortNativeSummon=function(unit) actualCasts=actualCasts+1;arg1=LP.SPELL;LP:OnEvent("SPELLCAST_START");return true,"spellbook request sent" end
actualCasts=0
CastSpellByName=function(name)
 actualCasts=actualCasts+1;arg1=name;LP:OnEvent("SPELLCAST_START")
end
LP:SetRaidAutoSummon(true)
LP:CheckRaidAutoSummon(100)
now=102;LP:CheckRaidAutoSummon(now)
assert(actualCasts==1 and LP.pending.started and LP.pending.automatic)
assert(not LP.requests[1] and #LP.autoTrace>0)
''')
    print("PASS integrated automatic "+unit+" cast receives start event")

check("off clears announcements even when already off",r'''LP.raidAutoSummon=false;LockPortOptions.announceOpen=true;LP:SetRaidAutoSummon(false);assert(not LP.raidAutoSummon and not LockPortOptions.announceOpen)''')
# Simulate SavedVariables surviving a reload while addon runtime state is recreated.
for enabled_by_auto in (True, False):
    before=env()
    if enabled_by_auto:
        before.execute("LP:SetRaidAutoSummon(true)")
    else:
        before.execute("LockPortOptions.announceOpen=true")
    after=env()
    after.globals().LockPortOptions.announceOpen=before.globals().LockPortOptions.announceOpen
    after.execute(r'''
    LP.DetectMods=function(self) self.mods={} end
    LP.CreateUI=function() end
    GetAddOnMetadata=function() return "test" end
    LP:Initialize()
    assert(not LP.raidAutoSummon and not LockPortOptions.announceOpen)
    sent=0;SendChatMessage=function() sent=sent+1 end
    ''')
    # env overrides OpenAnnounce; restore the production method before exercising its timer gate.
    after.execute(core)
    after.execute("LockPort:OpenAnnounce(1000); assert(sent==0)")
    print("PASS reload clears announcements", "auto" if enabled_by_auto else "manual")

# Chat dispatch uses stable message/sender values and never replays an outer chat
# event while handling a nested spell or addon-sync event.
def chat_check(name, reader, globals_text="123", globals_sender="Bob"):
    L=env()
    L.globals().arg1=globals_text; L.globals().arg2=globals_sender
    L.execute(r'''
    LP.MatchesTrigger=function(self,text) return text=="123" end
    LP.ScanRoster=function() arg1="clobbered";arg2="Wrong";return {Bob={unit="raid2"}} end
    LP.OnTrigger=function(self,name,info,event) triggered=(triggered or 0)+1;assert(name=="Bob" and info.unit=="raid2");triggerEvent=event end
    ''')
    L.execute(reader)
    L.execute('LP:OnEvent("CHAT_MSG_RAID");assert(triggered==1 and triggerEvent=="CHAT_MSG_RAID")')
    print("PASS",name)
chat_check("ClassicAPI chat payload survives overwritten globals",'GetCurrentChatEvent=function() return "CHAT_MSG_RAID","123","Bob" end',"wrong","Wrong")
chat_check("legacy chat fallback snapshots sender before roster scan",'GetCurrentChatEvent=nil')
chat_check("empty ClassicAPI chat result uses legacy fallback",'GetCurrentChatEvent=function() end')
chat_check("ClassicAPI chat errors use legacy fallback",'GetCurrentChatEvent=function() error("unavailable") end')
check("non-request actual payload does not use corrupted trigger globals",r'''GetCurrentChatEvent=function() return "CHAT_MSG_RAID","hello","Bob" end;arg1="123";arg2="Bob";LP.OnTrigger=function() error("false request") end;LP:OnEvent("CHAT_MSG_RAID")''')
check("nested spell event does not replay outer chat",r'''GetCurrentChatEvent=function() return "CHAT_MSG_RAID","123","Bob" end;LP.OnTrigger=function() error("duplicate request") end;arg1="Shadow Bolt";LP:OnEvent("SPELLCAST_START");assert(LP.castBusy)''')
check("addon sync payload is not replaced by chat reader",r'''GetCurrentChatEvent=function() error("must not read addon sync") end;LP.AddRequest=function(self,name) assert(name=="Bob");synced=true end;LP.ScanRoster=function() return {} end;arg1="RSAdd";arg2="Bob";arg4="Other";LockPortOptions.autoRemove=false;LP:OnEvent("CHAT_MSG_ADDON");assert(synced)''')

check("mute blocks summon say and whisper then resumes",r'''LP.CountShards=function() return 5 end;LP.RemoveRequest=function() end;LP.SendAddon=function() end;sent=0;SendChatMessage=function() sent=sent+1 end;LockPortOptions.whisper=true;LP:SetChatMuted(true);LP.pending={name="Bob"};LP:OnRitualStarted();assert(sent==0 and LP.pending.started);LP:SetChatMuted(false);LP.pending={name="Bob"};LP:OnRitualStarted();assert(sent==2)''')
check("mute clears pending status whispers and skips new replies",r'''LP.whisperQueue={{key="status:Bob",name="Bob",text="old",at=0}};LP:SetChatMuted(true);assert(table.getn(LP.whisperQueue)==0);LockPortOptions.whisperStatus=true;LP:QueueWhisper("Bob","status","new");assert(table.getn(LP.whisperQueue)==0);LP:SetChatMuted(false);LP:ProcessWhisperQueue(100);assert(table.getn(LP.whisperQueue)==0)''')
L=env();L.execute(core);L.execute(r'''LP=LockPort;LockPortOptions.chatMuted=true;GetNumRaidMembers=function() error("must stop before sending") end;LP:OpenAnnounce(100,true)''');print("PASS mute blocks forced availability announcements")

check("raid group selection defaults to all and supports none",r'''assert(LP:IsSelectedRaidGroup({subgroup=8}));LP:SetSummonGroups({});assert(not LP:IsSelectedRaidGroup({subgroup=1}));LP:SetSummonGroups(nil);assert(LP:IsSelectedRaidGroup({subgroup=1}))''')
check("group selection ignores party roster",r'''raidSize=0;partySize=3;LP:SetSummonGroups({[8]=true});assert(LP:IsSelectedRaidGroup({unit="party1"}))''')
check("group selection releases outstanding reservation",r'''LP.coordReservation={id=1,target="Bob",phase="reserve"};LP.autoReadyName="Bob";LP:SetSummonGroups({[2]=true});assert(not LP.coordReservation and not LP.autoReadyName);assert(LP:IsSelectedRaidGroup({subgroup=2}) and not LP:IsSelectedRaidGroup({subgroup=1}))''')
# Parse the real raid roster's third field and immediately follow subgroup moves.
L=env();L.execute(r'''raidSize=1;group=4;function GetRaidRosterInfo() return "Bob",0,group,60,"Warrior","WARRIOR","Test",true,false end;LP:SetSummonGroups({[4]=true});assert(LP:IsSelectedRaidGroup(LP:ScanRoster().Bob));group=5;assert(not LP:IsSelectedRaidGroup(LP:ScanRoster().Bob))''');print("PASS real raid roster subgroup parsing and subgroup changes")
# Exercise real candidate selection and direct casts against an assignment.
L=env();L.execute(core);L.execute(r'''
LP=LockPort;LP.Print=function() end;LP.UpdateUI=function() end;LP.SendAddon=function() end
LP.roster={Alice={unit="raid2",subgroup=1,online=true},Bob={unit="raid3",subgroup=2,online=true}}
LP.ScanRoster=function(self) return self.roster end;LP.TargetProblem=function() return nil end
LP.CountShards=function() return 5 end;LP.CountHelpers=function() return 2 end;LP.KnowsRitual=function() return true end
LP.requests={{name="Alice",t=1},{name="Bob",t=2}}
LP:SetSummonGroups({[2]=true});assert(LP:NextCandidate().name=="Bob")
LP:Summon("Alice");assert(not LP.pending and not manualCalls)
LP:SummonNext();assert(LP.pending.name=="Bob" and manualCalls==1)
LP.pending=nil;LP:SetSummonGroups({});assert(not LP:NextCandidate())
''');print("PASS Summon and direct row casts respect raid group selection")

check("saved raid group selection survives initialization",r'''LockPortOptions.summonGroups={[2]=true,[7]=true};LP.DetectMods=function(self) self.mods={} end;LP.CreateUI=function() end;GetAddOnMetadata=function() return "3.9.0" end;LP:Initialize();assert(LockPortOptions.summonGroups[2] and LockPortOptions.summonGroups[7] and not LockPortOptions.summonGroups[1])''')