"""Run production readiness/ack/timeout bodies with delayed replication adapters."""
from policy_harness import ROOT, body, run

source = ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_SpawnClientScene.c'
keys = ('bool ERR_SpawnSceneReady(', 'bool ERR_SpawnSceneMayFinish(',
        'protected void ERR_AcknowledgeSpawnScene(',
        'protected void ERR_ClearClientSpawnScene(',
        'protected void ERR_CheckClientSpawnScene(',
        'protected void ERR_CancelClientSpawnScene(')
methods = '\n'.join(body(source, key) for key in keys)
methods = methods.replace('protected ', '').replace('Replication.IsServer()', 'Replication::IsServer()')
methods = methods.replace('ERR_GameMode.Get()', 'Mode::Get()')
methods = methods.replace('RplComponent component = RplComponent.Cast(Replication.FindItem(id));', 'RplComponent* component = Replication::FindItem(id);')
methods = methods.replace('component.GetEntity()', 'component->GetEntity()')
methods = methods.replace('foreach (RplId id :', 'for (RplId id :')
methods = methods.replace('GetGame().GetWorld().GetWorldTime()', 'game.now')
methods = methods.replace('GetGame().GetCallqueue().Remove(ERR_CheckClientSpawnScene)', 'game.removes++')
methods = methods.replace('Rpc(ERR_AcknowledgeSpawnScene, token)', 'SendAck(token)')
run(r'''
#include <cassert>
#include <vector>
#include <map>
using RplId=int;
struct RplComponent{bool entity=true;bool GetEntity(){return entity;}};
namespace Replication{bool server=true;std::map<int,RplComponent*> items;bool IsServer(){return server;}RplComponent* FindItem(int id){return items.count(id)?items[id]:nullptr;}}
struct Mode{static bool present;static bool Get(){return present;}};bool Mode::present=true;
struct Game{float now=0;int removes=0;}game;Game* GetGame(){return &game;}
struct Nodes:std::vector<int>{using std::vector<int>::operator=;void Clear(){clear();}int Count(){return size();}};
template<typename... T>void PrintFormat(const char*,T...){}
struct Probe{
 int m_ERRSceneToken=4,m_ERRClientSceneToken=4,acks=0,lastAck=0;
 bool m_ERRScenePending=false,m_ERRSceneAcknowledged=false,m_ERRSceneTimedOut=false,m_ERRClientScenePending=false;
 float m_ERRSceneDeadline=1000,m_ERRSceneStartedAt=0;Nodes m_ERRClientSceneNodes,m_ERRClientStockOwners,m_ERRClientStockItems;
 bool stockReady=true;bool ERR_ClientStockReady(){return stockReady;}void ERR_RefreshSceneInventory(){}
 int GetPlayerId(){return 1;}void SendAck(int token){acks++;lastAck=token;}
'''+methods+r'''
};
int main(){
 Probe server;assert(!server.ERR_SpawnSceneReady());
 server.ERR_AcknowledgeSpawnScene(4);assert(!server.m_ERRSceneAcknowledged);
 server.m_ERRScenePending=true;assert(!server.ERR_SpawnSceneMayFinish());
 server.ERR_AcknowledgeSpawnScene(3);assert(!server.ERR_SpawnSceneReady());
 Replication::server=false;server.ERR_AcknowledgeSpawnScene(4);assert(!server.ERR_SpawnSceneReady());Replication::server=true;
 server.ERR_AcknowledgeSpawnScene(4);assert(server.ERR_SpawnSceneReady()&&server.ERR_SpawnSceneMayFinish());
 server.m_ERRSceneAcknowledged=false;game.now=999;assert(!server.ERR_SpawnSceneMayFinish());
 game.now=1000;assert(server.ERR_SpawnSceneMayFinish()&&server.m_ERRSceneTimedOut&&!server.ERR_SpawnSceneReady());
 server.ERR_AcknowledgeSpawnScene(4);assert(!server.ERR_SpawnSceneReady());
 Probe client;client.m_ERRClientScenePending=true;client.m_ERRClientSceneNodes={11,22,33};
 RplComponent root,wall,gate;Replication::items[11]=&root;
 for(int i=0;i<100;i++){client.ERR_CheckClientSpawnScene();}assert(client.acks==0&&client.m_ERRClientScenePending);
 Replication::items[22]=&wall;client.ERR_CheckClientSpawnScene();assert(client.acks==0);
 gate.entity=false;Replication::items[33]=&gate;client.ERR_CheckClientSpawnScene();assert(client.acks==0);
 gate.entity=true;client.stockReady=false;client.ERR_CheckClientSpawnScene();assert(client.acks==0&&client.m_ERRClientScenePending);
 client.stockReady=true;client.ERR_CheckClientSpawnScene();assert(client.acks==1&&client.lastAck==4&&!client.m_ERRClientScenePending&&client.m_ERRClientSceneNodes.empty());
 client.ERR_CheckClientSpawnScene();assert(client.acks==1);
 client.m_ERRClientScenePending=true;client.m_ERRClientSceneToken=5;client.m_ERRClientSceneNodes={99};
 client.ERR_CancelClientSpawnScene(4);assert(client.m_ERRClientScenePending);
 client.ERR_CancelClientSpawnScene(5);assert(!client.m_ERRClientScenePending&&client.m_ERRClientSceneNodes.empty());
 client.m_ERRClientScenePending=true;Mode::present=false;client.ERR_CheckClientSpawnScene();assert(!client.m_ERRClientScenePending&&client.acks==1);
}
''')
finalizer = ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_SpawnFinalization.c'
methods = '\n'.join(body(finalizer, key) for key in ('override bool CanFinalize_S(', 'override SCR_ESpawnResult FinalizeRequest_S('))
for old, new in [('override ', ''), ('SCR_SpawnRequestComponent requestComponent', 'Request* requestComponent'),
                 ('SCR_SpawnData data', 'Data* data'), ('IEntity entity', 'Actor* entity'),
                 ('ERR_SpawnLogic logic', 'Logic* logic'), ('ERR_SpawnTicket ticket', 'Ticket* ticket'),
                 ('ERR_GameMode.Get()', 'Mode::Get()'), ('SCR_ESpawnResult.', 'SCR_ESpawnResult::'),
                 ('requestComponent.', 'requestComponent->'), ('logic.', 'logic->'), ('super.', 'Native::')]:
    methods = methods.replace(old, new)
run(r'''
#include <cassert>
enum class SCR_ESpawnResult{OK,SPAWN_NOT_ALLOWED,CANNOT_ASSIGN};
struct Request{bool ready=false,mayFinish=false;int ends=0;bool ERR_SpawnSceneReady(){return ready;}bool ERR_SpawnSceneMayFinish(){return mayFinish;}bool preloadRequired=true;bool ERR_TakeScenePreload(){if(!ready||!preloadRequired)return false;preloadRequired=false;return true;}void ERR_EndSpawnScene(){ends++;}};
struct Data{};struct Actor{};struct Ticket{};
struct Mode{static bool current;static bool Get(){return current;}};bool Mode::current=true;
struct Logic{Ticket ticket;bool hasTicket=true,allowed=true;Ticket* TakeSpawnTicket(Request*,Data*,Actor*){return hasTicket?&ticket:nullptr;}bool MayFinalizeSpawn(Ticket*){return allowed;}};
struct Native{bool preloadReady=false;int assignments=0,preloadStarts=0;void OnFinalizeBegin_S(Request*,Data*,Actor*){preloadStarts++;preloadReady=false;}SCR_ESpawnResult result=SCR_ESpawnResult::OK;bool CanFinalize_S(Request*,Data*,Actor*){return preloadReady;}SCR_ESpawnResult FinalizeRequest_S(Request*,Data*,Actor*){assignments++;return result;}};
struct Handler:Native{Logic storage;Logic* logic=&storage;int rejects=0;Logic* ERR_AdmissionLogic(){return logic;}void ERR_RejectOwnedActor(Request*,Actor*,Data*){rejects++;}
'''+methods+r'''
};
int main(){
 Request request;Data data;Actor actor;Handler h;
 h.preloadReady=true;assert(!h.CanFinalize_S(&request,&data,&actor));
 request.mayFinish=true;h.preloadReady=false;assert(!h.CanFinalize_S(&request,&data,&actor));
 h.preloadReady=true;assert(h.CanFinalize_S(&request,&data,&actor));
 // Timeout can end the pending request, but cannot assign an actor.
 assert(h.FinalizeRequest_S(&request,&data,&actor)==SCR_ESpawnResult::SPAWN_NOT_ALLOWED&&h.assignments==0&&h.rejects==1&&request.ends==1);
 request.ready=true;assert(!h.CanFinalize_S(&request,&data,&actor)&&h.preloadStarts==1);
 h.preloadReady=true;assert(h.CanFinalize_S(&request,&data,&actor)&&h.preloadStarts==1);
 h.storage.allowed=false;
 assert(h.FinalizeRequest_S(&request,&data,&actor)==SCR_ESpawnResult::SPAWN_NOT_ALLOWED&&h.assignments==0&&h.rejects==2);
 h.storage.allowed=true;assert(h.FinalizeRequest_S(&request,&data,&actor)==SCR_ESpawnResult::OK&&h.assignments==1&&request.ends==3);
 h.storage.hasTicket=false;assert(h.FinalizeRequest_S(&request,&data,&actor)==SCR_ESpawnResult::SPAWN_NOT_ALLOWED&&h.assignments==1&&h.rejects==2);
 Mode::current=false;h.logic=nullptr;assert(h.FinalizeRequest_S(&request,&data,&actor)==SCR_ESpawnResult::OK&&h.assignments==2);
}
''')
cleanup = body(source, 'void ERR_EndSpawnScene(')
for old, new in [('Replication.IsServer()', 'Replication::server'),
                 ('foreach (IEntity entity :', 'for (int entity :'),
                 ('GetPlayerController().GetControlledEntity()', 'GetPlayerController()->GetControlledEntity()'),
                 ('Rpc(ERR_CancelClientSpawnScene, m_ERRSceneToken)', 'Cancel(m_ERRSceneToken)')]:
    cleanup = cleanup.replace(old, new)
run(r'''
#include <cassert>
#include <vector>
namespace Replication{bool server=true;}
struct Items:std::vector<int>{using std::vector<int>::vector;void Clear(){clear();}};
struct Controller{int GetControlledEntity(){return 42;}};
struct Probe{
 Items m_ERRSceneEntities{1,2},m_ERRSceneRoots,m_ERRSceneStockOwners,m_ERRSceneStockItems;
 bool m_ERRSceneObserver=true,m_ERRScenePending=true,m_ERRSceneAcknowledged=true,m_ERRSceneTimedOut=true,m_ERRScenePreloadRequired=true;
 int m_ERRSceneToken=7,restored=0,cancelled=0,observed=0;Controller controller;bool connected=true;
 Controller* GetPlayerController(){return connected?&controller:nullptr;}
 void ERR_StreamScene(int,bool normal){assert(normal);restored++;}
 void UpdateObserverMP_S(int entity){observed=entity;}void Cancel(int token){assert(token==7);cancelled++;}
'''+cleanup+r'''
};
int main(){
 Probe p;Replication::server=false;p.ERR_EndSpawnScene();assert(p.restored==0&&p.m_ERRScenePending);
 Replication::server=true;p.ERR_EndSpawnScene();assert(p.restored==2&&p.cancelled==1&&p.observed==42);
 assert(p.m_ERRSceneEntities.empty()&&!p.m_ERRSceneObserver&&!p.m_ERRScenePending&&!p.m_ERRSceneAcknowledged&&!p.m_ERRSceneTimedOut&&!p.m_ERRScenePreloadRequired);
 p.ERR_EndSpawnScene();assert(p.restored==2&&p.cancelled==1);
 Probe disconnected;disconnected.connected=false;disconnected.ERR_EndSpawnScene();assert(disconnected.observed==0&&!disconnected.m_ERRSceneObserver);
}
''')
print('PASS: delayed scene/inventory arrival, deferred preload, identity checks, stale replies, timeout and observer cleanup')