What each player knows

using System.Text.Json;
using System.Text.Json.Serialization;
using Kallamo.Umwelt;
using var engine = UmweltEngine.Create("salt-road.umw");
const string projectId = "salt-road";
var gm = Provenance.Human("gm");
var json = new JsonSerializerOptions
{
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
    Converters = { new JsonStringEnumConverter(JsonNamingPolicy.KebabCaseLower) },
};
void Print(string label, object? value) => Console.WriteLine($"@@{label}\n{JsonSerializer.Serialize(value, json)}");

// The world, declared once: sending the same manifest again changes nothing.
engine.WorldEnsure(new EnsureWorldInput
{
    Project = new WorldProject { Id = projectId, Name = "The Salt Road", Timescale = "session" },
    EntityTypes = new()
    {
        new WorldEntityType { Id = "character", Name = "Character", Kind = EntityKind.Agent },
        new WorldEntityType { Id = "thing", Name = "Thing", Kind = EntityKind.Other },
    },
    Entities = new()
    {
        new WorldEntity { Id = "kira", TypeId = "character", Name = "Kira, the rogue" },
        new WorldEntity { Id = "oren", TypeId = "character", Name = "Oren, the cleric" },
        new WorldEntity { Id = "tavi", TypeId = "character", Name = "Tavi, the bard" },
        new WorldEntity { Id = "duke", TypeId = "character", Name = "Duke Halvard" },
        new WorldEntity { Id = "priest", TypeId = "character", Name = "The high priest" },
        new WorldEntity { Id = "caravan", TypeId = "thing", Name = "The salt caravan" },
        new WorldEntity { Id = "cult", TypeId = "thing", Name = "The Drowned Choir" },
        new WorldEntity { Id = "drowned-god", TypeId = "thing", Name = "The drowned god" },
    },
    Predicates = new()
    {
        new PredicateDef { Id = "was-raided", Label = "was raided", Object = ObjectKind.None, Cardinality = Cardinality.Many },
        new PredicateDef { Id = "meets", Label = "meets", Object = ObjectKind.Entity, Cardinality = Cardinality.Many },
        new PredicateDef { Id = "worships", Label = "worships", Object = ObjectKind.Entity, Cardinality = Cardinality.Many },
        new PredicateDef { Id = "leads", Label = "leads", Object = ObjectKind.Entity, Cardinality = Cardinality.Many },
    },
});
var raided = Claim.Unary("caravan", "was-raided");
var dukeMeetsCult = Claim.Entity("duke", "meets", "cult");
var cultWorships = Claim.Entity("cult", "worships", "drowned-god");
var priestLeads = Claim.Entity("priest", "leads", "cult");
var party = new List<string> { "kira", "oren", "tavi" };

// Session 1, together: the raid on the caravan.
engine.Witness(new WitnessInput
{
    ProjectId = projectId, AttemptId = "session-1",
    Event = new EventInput { Id = "session-1", Type = "session", Title = "Session 1: the raid", Position = Position.At(1), Participants = party, Provenance = gm },
    Claims = new() { new WitnessedClaim { Claim = raided, Canon = true, FactId = "canon-raid" } },
    Witnesses = party.Select(holder => new Witness { Holder = holder }).ToList(),
});
// The truth the game master keeps, written before session 2.
var two = Position.At(2);
engine.Commit(new CommitInput
{
    ProjectId = projectId, AttemptId = "gm-notes",
    Event = new EventInput { Id = "gm-notes", Type = "prep", Title = "The game master’s notes", Position = two, Participants = new(), Provenance = gm },
    Records = new()
    {
        Records.Fact(dukeMeetsCult, id: "canon-meets"),
        Records.Fact(cultWorships, id: "canon-worships"),
        Records.Fact(priestLeads, id: "canon-leads"),
    },
});
// Session 2, the party splits. Each player writes what their character learned.
// Notes are proposals: nothing counts until the game master reviews them.
// A note is signed by its player: the record's own provenance, not the event's.
RecordInput Learned(string id, string holder, Claim seen, string eventId) =>
    Records.Knows(holder, seen, Acquired.Witnessed(eventId), id: id, provenance: Provenance.Human(holder));
Proposal Note(string eventId, string title, List<string> participants, List<RecordInput> records) => engine.Propose(new ProposeInput
{
    ProjectId = projectId,
    Event = new EventInput { Id = eventId, Type = "scene", Title = title, Position = two, Participants = participants, Provenance = gm },
    Records = records,
});
var notes = new Dictionary<string, Proposal>
{
    ["kira"] = Note("manor", "Kira scouts the manor", new() { "kira", "duke" }, new() { Learned("kira-duke", "kira", dukeMeetsCult, "manor"), Learned("kira-priest", "kira", priestLeads, "manor") }),
    ["oren"] = Note("temple", "Oren at the temple", new() { "oren", "priest" }, new() { Learned("oren-god", "oren", cultWorships, "temple") }),
    ["tavi"] = Note("tavern", "Tavi at the tavern", new() { "tavi" }, new() { Learned("tavi-duke", "tavi", dukeMeetsCult, "tavern") }),
};

// The game master's review: one decision per line, with the reason the players will read.
ReviewInput Decide(ulong index, ReviewDecision decision, string rationale) => new() { OperationIndex = index, Decision = decision, Rationale = rationale };
engine.ProposalReview(new ReviewPayload { ProposalId = notes["kira"].Id, Reviews = new()
{
    Decide(0, ReviewDecision.Accepted, "You watched them through the window."),
    Decide(1, ReviewDecision.Rejected, "The priest was never at the manor. You have no way to know."),
} });
engine.ProposalReview(new ReviewPayload { ProposalId = notes["oren"].Id, Reviews = new() { Decide(0, ReviewDecision.Accepted, "The murals in the crypt show it.") } });
engine.ProposalReview(new ReviewPayload { ProposalId = notes["tavi"].Id, Reviews = new() { Decide(0, ReviewDecision.Rejected, "Only Kira saw that, and she has not told anyone yet.") } });
foreach (var (who, proposal) in notes)
{
    if (who == "tavi") { engine.ProposalReject(new RejectPayload { ProposalId = proposal.Id, Rationale = "Nothing in this note happened to Tavi." }); continue; }
    engine.ProposalApply(new ApplyPayload { ProposalId = proposal.Id, AttemptId = $"notes-{who}" });
}
var reviewed = engine.ProposalList(new ProjectId { ProjectIdValue = projectId });
Print("notes", reviewed.Select(p => new
{
    @event = p.Input.Event.Title, status = p.Status,
    lines = (p.Reviews ?? new()).Select(r => new { decision = r.Decision, rationale = r.Rationale }),
    rejected = p.RejectionRationale,
}));
// Session 3: Kira tells the others what she saw at the manor.
engine.TransmitBatch(new TransmitBatchPayload
{
    Shared = new TransmitShared
    {
        ProjectId = projectId, From = "kira", SourceRecordId = "kira-duke", Intent = Intent.Honest,
        Attitude = Attitude.Believes, Confidence = 0.9, Position = Position.At(3),
    },
    Transmits = new[] { "oren", "tavi" }.Select(to => new TransmitBatchItem { AttemptId = $"kira-tells-{to}", To = to, RecordId = $"{to}-duke" }).ToList(),
});
// A character sheet is a query: what the character holds at that session, nothing else.
string Line(Claim claim) => $"{claim.Subject} {claim.Predicate} {(claim.Object as ClaimObject.Entity)?.Id}".Trim();
var sheets = new Dictionary<string, Dictionary<string, List<string>>>();
foreach (var who in party)
{
    sheets[who] = new();
    foreach (var session in new long[] { 1, 2, 3 })
    {
        var view = engine.Perspective(new PerspectivePayload { ProjectId = projectId, Holder = who, At = new At { Tick = session } });
        sheets[who][session.ToString()] = view.Holdings.Select(item => item.Record is Record.Holding h ? Line(h.Claim) : "").ToList();
    }
}
Print("sheets", sheets);

Print("kira-vs-tavi-2", engine.Compare(new ComparePayload { ProjectId = projectId, A = "kira", B = "tavi", At = new At { Tick = 2 } }).Counts);
Print("kira-vs-tavi-3", engine.Compare(new ComparePayload { ProjectId = projectId, A = "kira", B = "tavi", At = new At { Tick = 3 } }).Counts);
Print("who-knows-the-duke", engine.WhoHolds(new WhoHoldsPayload { ProjectId = projectId, Claim = dukeMeetsCult, At = new At { Tick = 3 } }));