#if SERVICE_HOST
using game.PlayerDataStorage;

static partial class Probe
{
    public sealed class M2EventFixture : Activity.Data.IEventData { public int Count { get; set; } }
    sealed class DailyTicks : TimeManager.ITimeTickService
    {
        public IObservable<long> SecondTick { get; } = new UniRx.Stream<long>();
        public IObservable<long> MinuteTick { get; } = new UniRx.Stream<long>();
        public void Start() { }
        public void Stop() { }
    }

    static void MergedDailyRefresh()
    {
        GContext.container.Values[typeof(cfg.Tables)] = new cfg.Tables();
        var user = new game.KVUserService();
        int refreshes = 0;
        using var events = GContext.OnEvent<TimeManager.Event.ActivityCrossDayRefreshEvent>().Subscribe(_ => refreshes++);
        using (var manager = new TimeManager.TimeRefreshManager(new DailyTicks(), user))
            Check(manager.GetLastLoginTime() == null && manager.InitialRefreshSucceeded && refreshes == 1,
                "actual daily manager consumes missing-login sentinel and records successful initial refresh");
        using (var failure = GContext.OnEvent<TimeManager.Event.ActivityCrossDayRefreshEvent>().Subscribe(_ => throw new InvalidOperationException("synthetic refresh failure")))
        using (var manager = new TimeManager.TimeRefreshManager(new DailyTicks(), user))
            Check(!manager.InitialRefreshSucceeded && user.LastLoginTime == DateTime.MinValue,
                "caught daily subscriber failure is visible to the timestamp commit gate");
        typeof(game.KVUserService).GetProperty(nameof(user.LastLoginTime)).SetValue(user, ZZTimeHelper.UtcNow().UtcNowOffset());
        var before = refreshes;
        using (var manager = new TimeManager.TimeRefreshManager(new DailyTicks(), user))
            Check(manager.InitialRefreshSucceeded && refreshes == before, "same configured game day needs no initial refresh");
        user.Logout();
        Pass("merged-real-daily-refresh-success-failure-and-login-sentinel");
    }
    static async Task MergedSaveContract(game.KVUserService user, Dictionary<string, string> remote, bool unknown, Action<Action> onNextSet)
    {
        var store = user.SaveStore;
        var original = (PlayerKVGameSessionHandle)typeof(game.KVUserService).GetField("handle",
            System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(user);
        try { ((KVPlayerSaveStore)store).Bind(original, user.LoginLifetime); throw new Exception("store rebound"); }
        catch (InvalidOperationException) { Check(true, "bound store cannot be rebound even to the same handle"); }
        Check(PlayerKVGameLoadGuard.TryEnter(out var guard), "save contract guard lease acquired");
        using (guard)
        {
            Check(!store.Read("Language").Success && !store.Write("M2Guarded", "x").Accepted && guard.Violations == 2,
                "common store preserves original read/write guard enforcement");
        }
        var absent = store.Read("M2Missing");
        Check(absent.Success && absent.Found == false && absent.Value == null, "successful missing key is explicit");
        var invalid = store.Read(null);
        Check(!invalid.Success && invalid.Found == null, "invalid read is never a missing key");
        try { invalid.ValueOrThrow(); throw new Exception("failed read swallowed"); }
        catch (InvalidOperationException) { Check(true, "failed read cannot enter a default-value branch"); }
        var local = store.Write("M2LocalOnly", "", false);
        Check(local.Accepted && store.Read("M2LocalOnly").Found == true && store.Read("M2LocalOnly").Value == "",
            "local-only empty string remains present: " + local.Error + "/" + original.Status);
        Check((await store.ConfirmAsync(local.Receipt)).Status == PlayerSaveStatus.LocalOnly && !remote.ContainsKey("M2LocalOnly"),
            "local-only acceptance never becomes remote confirmation");
        if (unknown)
        {
            await MergedUnknownRewards(user);
            var before = user.Language;
            try { await user.UpdateLanguage("de"); throw new Exception("unknown profile published"); }
            catch (InvalidOperationException) { Check(user.Language == before, "unknown profile save does not update public language"); }
            Check((await store.FlushAsync()).Status == PlayerSaveStatus.Unknown, "unknown outcome remains explicit");
            Check(!store.Write("M2BlockedAfterUnknown", "x").Accepted, "unknown outcome blocks further writes");
            var read = store.Read("M2Missing");
            Check(!read.Success && read.Found == null, "unreadable owner cannot impersonate an empty account");
        }
        else
        {
            await MergedActivityTokens(user, remote);
            await MergedRewardActions(user, remote, onNextSet);
            await MergedSurveyAndMail(user, remote, onNextSet);
            var repository = new Activity.Data.EventDataRepository(store);
            Check(!repository.Exists<M2EventFixture>() && repository.Load<M2EventFixture>().Count == 0,
                "real activity repository defaults only for an absent key");
            foreach (var malformed in new[] { "", "null", "{broken" })
            {
                store.Write(nameof(M2EventFixture), malformed, false).RequireAccepted();
                try { repository.Load<M2EventFixture>(); throw new Exception("corrupt activity became empty"); }
                catch (Newtonsoft.Json.JsonException) { Check(true, "bad activity JSON never becomes a new save"); }
            }
            repository.Save(new M2EventFixture { Count = 19 });
            Check(repository.Load<M2EventFixture>().Count == 19, "real activity repository preserves generic key and JSON");
            var first = store.Write("M2Replace", "first");
            var last = store.Write("M2Replace", "last");
            Check(first.Accepted && last.Accepted && !remote.ContainsKey("M2Replace"), "buffered writes are not sent immediately");
            Check((await store.ConfirmAsync(first.Receipt)).Status == PlayerSaveStatus.Superseded,
                "overwritten standalone receipt is not confirmed");
            Check((await store.ConfirmAsync(last.Receipt)).Confirmed && remote["M2Replace"] == "last",
                "final original receipt confirms its remote value");
            Check(!remote.ContainsKey("M2LocalOnly"), "flush never sends local-only keys");
            Check(Newtonsoft.Json.JsonConvert.DeserializeObject<M2EventFixture>(remote[nameof(M2EventFixture)]).Count == 19,
                "real repository data reaches the original KV transport");
            var other = new KVPlayerSaveStore();
            Check((await store.ConfirmAsync(new PlayerSaveReceipt(other, null))).Status == PlayerSaveStatus.Rejected,
                "a receipt from another store cannot cross accounts");
            await user.UpdateLanguage("de");
            Check(user.Language == "de" && remote["Language"] == "de", "real profile consumer publishes only after confirmation");
            for (int i = 0; i < 11; i++) store.Write("M2Watermark" + i, "initial").RequireAccepted();
            onNextSet(() => store.Write("M2Watermark10", "later").RequireAccepted());
            Check((await store.FlushAsync()).Status == PlayerSaveStatus.Superseded && !remote.ContainsKey("M2Watermark10"),
                "aggregate flush cannot confirm an unsent receipt replaced beyond its captured watermark");
            Check((await store.FlushAsync()).Confirmed && remote["M2Watermark10"] == "later",
                "later replacement requires its own flush and confirmation");
            using var cancelled = new CancellationTokenSource(); cancelled.Cancel();
            Check((await store.WriteAndConfirmAsync("M2Cancelled", "x", cancelled.Token)).Status == PlayerSaveStatus.Cancelled &&
                !store.Read("M2Cancelled").Found.Value, "pre-cancelled consumption does not enqueue a debit");
        }
        Pass(unknown ? "merged-save-unknown-is-not-missing-or-profile-success" : "merged-save-local-buffered-superseded-confirmed-and-foreign-receipt");
    }

    sealed class PFSurveyUser : game.PlayFabUserService { public PFSurveyUser() { UserId = "101"; } }
    static async Task MergedUnknownRewards(game.KVUserService user)
    {
        var store = user.SaveStore;
        int drops = 0, shown = 0, requests = 0;
        GContext.container.Values[typeof(game.PlayerData)] = new game.PlayerData { Save = () => store.Write("M2UnknownPrimary", "saved").RequireAccepted() };
        GContext.container.Values[typeof(game.PlayerItemData)] = new game.PlayerItemData { Drop = (id, inflated) =>
        {
            drops++;
            store.Write("M2UnknownItem", "credit").RequireAccepted();
            PlayerSaveAction.Present(() => GContext.Publish(new game.ShowData()));
        }};
        using var subscription = GContext.OnEvent<game.ShowData>().Subscribe(_ => shown++);
        var tables = new cfg.Tables();
        var definition = new cfg.SurveyData { ID = 99, Reward = 99 };
        var survey = new SurveyService(user, tables, store);
        try { await survey.GetSurveyCheckAnswer(definition); throw new Exception("unknown reward reported success"); }
        catch (InvalidOperationException) { Check(drops == 1 && shown == 0, "unknown actual survey credit never presents success"); }
        try { await survey.GetSurveyCheckAnswer(definition); throw new Exception("unknown survey was replayed"); }
        catch (InvalidOperationException) { Check(drops == 1, "actual survey rejects replay after unknown confirmation"); }
        try { await PlayerSaveAction.RunAsync(store, "another-reward", () => drops++, () => { }); throw new Exception("unknown owner mutated another reward"); }
        catch (InvalidOperationException) { Check(drops == 1, "readiness check rejects another reward before inventory mutation"); }
        var cache = new MailCache(tables.TbAutoDeliveryMail); cache.Load(user.UserId);
        var server = System.Reflection.DispatchProxy.Create<ICustomServerMgr, MailServerProbe>();
        ((MailServerProbe)(object)server).Post = (route, json) => { requests++; return Task.FromResult("{\"success\":true}"); };
        var handler = new BaseMailHandler(cache, server, user, store);
        Check(!await handler.TakeReward(new GameMail { Id="unknown", DropIds=new[]{1} }) && requests==0,
            "unknown KV owner blocks mail state request before consuming server reward");
        handler.Close(); cache.Unload();
        Pass("merged-actual-survey-unknown-no-replay-and-mail-before-state-readiness");
    }

    public class MailServerProbe : System.Reflection.DispatchProxy
    {
        public Func<string,string,Task<string>> Post;
        protected override object Invoke(System.Reflection.MethodInfo method, object[] args)
        {
            if (method.Name != "CustomServerPost") throw new Exception("Unexpected mail transport method: " + method.Name);
            return Post((string)args[0], (string)args[1]);
        }
    }
    static async Task MergedSurveyAndMail(game.KVUserService user, Dictionary<string,string> remote, Action<Action> onNextSet)
    {
        var store = user.SaveStore;
        GContext.container.Values[typeof(IPlayerSaveStore)] = store;
        var player = new game.PlayerData { lv = 10, Save = () => store.Write("M2RewardFixturePrimary", "saved").RequireAccepted() };
        var drops = new List<(int id, bool inflated)>();
        GContext.container.Values[typeof(game.PlayerData)] = player;
        GContext.container.Values[typeof(game.PlayerItemData)] = new game.PlayerItemData { Drop = (id, inflated) =>
        {
            drops.Add((id, inflated));
            store.Write("M2RewardFixtureDrop" + id, drops.Count.ToString()).RequireAccepted();
            PlayerSaveAction.Present(() => GContext.Publish(new game.ShowData()));
        }};
        var footprint = new FootPrintService { SaveStore = store };
        footprint.LoadData((1UL << 40).ToString());
        footprint.UpdateFootPrint(EFootPrint.IsFaceBookRewardLink);
        Check(store.Read("FootPrint").ValueOrThrow() == ((1UL << 40) | (uint)EFootPrint.IsFaceBookRewardLink).ToString(),
            "actual footprint write retains high KV bits while updating its legacy int view");
        var statue = new EventPartnerStatuePlayfabData { EventId=42, TicketCount=7, DisplayScoreMap=new(), RobotScoreMap=new() };
        statue.Save();
        var reloaded = EventPartnerStatuePlayfabData.Load();
        Check(reloaded.EventId==42 && reloaded.TicketCount==7, "actual dynamic archive constructor and static loader retain common store wire data");
        var tables = new cfg.Tables();
        var decimalSurvey = new cfg.SurveyData { ID = 11, Hash = "test", Reward = 501, TailNumberList = new List<int>{1} };
        tables.TbSurveyData.DataList.Add(decimalSurvey);
        tables.TbSurveyData.DataList.Add(new cfg.SurveyData { ID = 22, Hash = "test", Reward = 502, TailNumberList = new List<int>{7} });
        int presentations = 0;
        using var subscription = GContext.OnEvent<game.ShowData>().Subscribe(_ => presentations++);
        var survey = new SurveyService(user, tables, store);
        survey.GetSurveyMatchlist();
        Check(survey.tableData == decimalSurvey, "real survey uses decimal new user ID rather than PF hexadecimal tail");
        Check(survey.GetSurveyAnswer() == "https://wesurvey.com/s2/11/test/?&uid=101", "survey retains original external URL and custom ID semantics");
        Task duplicate = null;
        onNextSet(() => duplicate = survey.GetSurveyCheckAnswer(decimalSurvey));
        await survey.GetSurveyCheckAnswer(decimalSurvey);
        Check(duplicate != null && duplicate.IsFaulted && drops.Count == 1 && presentations == 2 && remote["SurveyData"] == "[\"11\"]",
            "actual survey rejects pending reentry and presents only after inventory plus marker confirmation");
        await survey.GetSurveyCheckAnswer(decimalSurvey);
        Check(drops.Count == 1, "already claimed survey never credits twice");
        store.Write("SurveyReadSidData", "null", false).RequireAccepted();
        try { new SurveyService(user, tables, store); throw new Exception("null survey JSON defaulted"); }
        catch (Newtonsoft.Json.JsonException) { Check(true, "actual survey rejects present null JSON"); }
        store.Write("SurveyReadSidData", "[\"11\"]").RequireAccepted();

        var cache = new MailCache(tables.TbAutoDeliveryMail); cache.Load(user.UserId);
        var first = new GameMail { Id = "m1", Type = EMailType.Personal, DropIds = new[]{601}, ExpireTime = ZZTimeHelper.UtcNow().AddDays(1) };
        var second = new GameMail { Id = "m2", Type = EMailType.Global, DropIds = new[]{602}, ExpireTime = first.ExpireTime };
        cache.Cache(new[]{first,second});
        var server = System.Reflection.DispatchProxy.Create<ICustomServerMgr, MailServerProbe>();
        var probe = (MailServerProbe)(object)server;
        var response = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
        Newtonsoft.Json.Linq.JObject sent = null;
        probe.Post = (route,json) => { Check(route == MailUrls.UpdateState, "mail keeps original updateState route"); sent = Newtonsoft.Json.Linq.JObject.Parse(json); return response.Task; };
        var handler = new BaseMailHandler(cache, server, user, store);
        var claim = handler.TakeReward(new[]{first,second,first});
        Check(!await handler.TakeReward(first) && sent["mailStates"].Count() == 2 && sent["mailStates"].All(m => ((int)m["state"] & (int)EMailState.RewardTaken) != 0),
            "batch deduplicates frozen eligible mails, requests RewardTaken and blocks a concurrent single claim");
        first.DropIds = new[]{999};
        response.SetResult("{\"success\":true}");
        Check(await claim && drops.Contains((601,true)) && drops.Contains((602,false)) && !drops.Any(d => d.id==999),
            "real mail batch preserves pre-request rewards and personal inflation after state update");
        Check(first.HasReward && second.HasReward && !await handler.TakeReward(first), "real mail cannot repeat a completed claim");
        var third = new GameMail { Id = "m3", DropIds = new[]{603}, ExpireTime = first.ExpireTime };
        cache.Cache(third);
        response = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
        var delayed = handler.TakeReward(third);
        int before = drops.Count;
        handler.Close(); cache.Unload();
        response.SetResult("{\"success\":true}");
        Check(!await delayed && drops.Count == before && !third.HasReward, "closed mail handler discards old response before cache or reward mutation");
        Pass("merged-real-survey-decimal-id-reentry-and-mail-batch-personal-stale-response");
    }

    static async Task MergedRewardActions(game.KVUserService user, Dictionary<string, string> remote, Action<Action> onNextSet)
    {
        var store = user.SaveStore;
        int shown = 0, applied = 0;
        await PlayerSaveAction.RunAsync(store, "test-reward", () =>
        {
            applied++;
            store.Write("M2Reward", "intermediate").RequireAccepted();
            PlayerSaveAction.Present(() => { Check(remote["M2Reward"] == "final", "presentation follows remote confirmation"); shown++; });
            store.Write("M2Reward", "final").RequireAccepted();
            Check(shown == 0, "nested presentation remains deferred during synchronous reward mutation");
        }, () => store.Write("M2RewardPrimary", "aggregate").RequireAccepted(), user.LoginLifetime);
        Check(applied == 1 && shown == 1 && remote["M2RewardPrimary"] == "aggregate", "same-action final receipt covers intermediate writes and primary save");
        bool outsidePresented = false;
        onNextSet(() =>
        {
            PlayerSaveAction.Present(() => outsidePresented = true);
            store.Write("M2RewardRace", "unrelated").RequireAccepted();
        });
        // The last key remains unsent when a different action supersedes its receipt.
        try
        {
            await PlayerSaveAction.RunAsync(store, "test-race", () =>
            {
                for (int i = 0; i < 11; i++) store.Write("M2RewardBatch" + i, "reward").RequireAccepted();
                store.Write("M2RewardRace", "reward").RequireAccepted();
                PlayerSaveAction.Present(() => shown++);
            }, () => store.Write("M2RewardBatch0", "primary").RequireAccepted());
            throw new Exception("unrelated superseding receipt confirmed a reward");
        }
        catch (InvalidOperationException) { Check(shown == 1 && outsidePresented, "collector ends before await; unrelated replacement cannot show reward success"); }
        try
        {
            await PlayerSaveAction.RunAsync(store, "test-race", () => applied++, () => { });
            throw new Exception("failed reward replayed");
        }
        catch (InvalidOperationException) { Check(applied == 1, "failed reward action stays reserved before mutation"); }
        Check((await store.FlushAsync()).Confirmed, "unrelated later writes can be flushed independently");
        try
        {
            await PlayerSaveAction.RunAsync(store, "test-local", () => store.Write("M2RewardLocal", "x", false), () => { });
            throw new Exception("local-only reward confirmed");
        }
        catch (InvalidOperationException) { Check(!remote.ContainsKey("M2RewardLocal"), "local-only final action receipt is never cloud success"); }
        Check(PlayerKVGameLoadGuard.TryEnter(out var guard), "reward rejected-write guard acquired");
        using (guard)
        {
            try
            {
                await PlayerSaveAction.RunAsync(store, "test-rejected", () => store.Write("M2RewardRejected", "x"), () => { });
                throw new Exception("ignored rejection reported reward success");
            }
            catch (InvalidOperationException) { Check(!remote.ContainsKey("M2RewardRejected"), "collector remembers rejection even if caller ignores return value"); }
        }
        Pass("merged-reward-final-receipts-presentation-race-rejection-and-no-replay");
    }

    static async Task MergedActivityTokens(game.KVUserService user, Dictionary<string, string> remote)
    {
        var store = user.SaveStore;
        foreach (var malformed in new[] { "", "null", "{bad", "[]" })
        {
            store.Write("TransitionData", malformed, false).RequireAccepted();
            var bad = new Activity.Services.EventTokenService(store);
            try { bad.GetTokenCount(1); throw new Exception("invalid token save became zero balance"); }
            catch (Newtonsoft.Json.JsonException) { Check(true, "invalid token JSON is not a zero balance"); }
        }
        store.Write("TransitionData", "{\"1\":10,\"2\":7}", false).RequireAccepted();
        var tokens = new Activity.Services.EventTokenService(store);
        int notifications = 0;
        using var subscription = GContext.OnEvent<Activity.ActivityEventTokenBalanceChanged>().Subscribe(_ => notifications++);
        Check(tokens.GetTokenCount(1) == 10 && tokens.GetTokenCount(3) == 0, "real token service preserves existing balances");
        Check(PlayerKVGameLoadGuard.TryEnter(out var guard), "token mutation rejection guard acquired");
        using (guard)
        {
            try { tokens.AddToken(1, 5); throw new Exception("guarded token mutation accepted"); }
            catch (InvalidOperationException) { Check(tokens.GetTokenCount(1) == 10 && notifications == 0, "rejected token write changes neither balance nor notification"); }
        }
        tokens.AddToken(1, 5);
        Check(tokens.GetTokenCount(1) == 15 && notifications == 1, "accepted token credit publishes its original notification");
        Check(tokens.RemoveToken(1, 20) == 15 && tokens.GetTokenCount(1) == 0 && notifications == 2, "token debit preserves original clamp and removes empty entry");
        tokens.SetTokens(new Dictionary<int, int> { [3] = 8, [4] = 9, [-1] = 10 });
        tokens.ClearTokens(new[] { 3, 4 });
        Check(tokens.GetAllTokens().Count == 0, "batch clear changes the complete candidate, not a per-key copy");
        tokens.SetToken(5, 17);
        tokens.ClearToken(999);
        Check((await store.FlushAsync()).Confirmed, "token data confirms through original KV store");
        var saved = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<int, int>>(remote["TransitionData"]);
        Check(saved.Count == 1 && saved[5] == 17, "token wire JSON retains original key and dictionary format");
        Pass("merged-real-activity-tokens-malformed-rejected-credit-debit-and-batch-save");
    }

    static async Task MergedPFStore(PlayFabMgr manager)
    {
        using var lifetime = new CancellationTokenSource();
        var store = new PlayFabPlayerSaveStore(manager, lifetime.Token);
        var pfTables = new cfg.Tables();
        var pfDefinition = new cfg.SurveyData { ID=22, TailNumberList=new List<int>{7} };
        pfTables.TbSurveyData.DataList.Add(pfDefinition);
        GContext.container.Values[typeof(game.PlayerData)] = new game.PlayerData { lv=10 };
        var pfSurvey = new SurveyService(new PFSurveyUser(), pfTables, store);
        pfSurvey.GetSurveyMatchlist();
        Check(pfSurvey.tableData == pfDefinition, "actual PF survey preserves hexadecimal identity tail");
        var tokens = new Activity.Services.EventTokenService(store);
        Check(tokens.GetTokenCount(91) == 0, "missing PF token key remains a valid empty balance");
        tokens.AddToken(91, 4);
        Check(Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<int, int>>(manager.GetLocalData("TransitionData"))[91] == 4,
            "same real token consumer preserves the PF storage route");
        var write = store.Write("M2PF", "unchanged");
        Check(write.Accepted && store.Read("M2PF").Value == "unchanged", "PF adapter uses original local buffer");
        Check((await store.ConfirmAsync(write.Receipt)).Status == PlayerSaveStatus.Buffered, "PF buffered receipt is not a cloud confirmation");
        Check((await store.WriteAndConfirmAsync("M2PFImmediate", "value")).Confirmed, "PF immediate operation keeps original acknowledgement");
        lifetime.Cancel();
        try { tokens.GetTokenCount(91); throw new Exception("closed token service returned cached balance"); }
        catch (InvalidOperationException) { Check(true, "closed token consumer rejects cached data before use"); }
        Check(!store.IsCurrent && !store.Write("M2PF", "stale").Accepted && !store.Read("M2PF").Success,
            "captured PF lifetime does not follow replacement login");
        Pass("merged-PF-original-provider-and-frozen-lifetime");
    }
}
#endif