"""Deterministic resource-side fencing reconstruction; no distributed lock implementation."""
import csv
import json
from pathlib import Path

class Resource:
    def __init__(self, fenced):
        self.fenced = fenced
        self.highest = 0
        self.value = None
        self.effects = 0

    def write(self, token, value):
        # One modeled atomic operation. A real receiver must enforce this atomically.
        if self.fenced and token < self.highest:
            return "rejected"
        self.highest = max(self.highest, token)
        self.value = value
        self.effects += 1
        return "accepted"

def run():
    events = []
    outcomes = []
    for fenced in (False, True):
        resource = Resource(fenced)
        mode = "fenced" if fenced else "unfenced"
        for step, (worker, token, value) in enumerate(
            [("B", 42, "new-result"), ("A", 41, "old-result")], 1
        ):
            result = resource.write(token, value)
            events.append(dict(mode=mode,write_step=step,worker=worker,token=token,
                               outcome=result,value_after=resource.value,highest=resource.highest))
        expected = "new-result" if fenced else "old-result"
        assert resource.value == expected
        outcomes.append(dict(case=mode,final_value=resource.value,effects=resource.effects,
                             interpretation="new result preserved" if fenced else "stale overwrite"))
        print(mode+" final value:", resource.value)
    same_owner = Resource(True)
    same_owner.write(42, "new-result")
    duplicate = same_owner.write(42, "new-result")
    assert duplicate == "accepted" and same_owner.effects == 2
    print("repeated current token:", duplicate)
    unseen = Resource(True)
    before_newer = unseen.write(41, "old-result")
    assert before_newer == "accepted"
    print("old token before newer token reaches resource:", before_newer)
    trace=dict(scope="Ordered in-memory resource model, not a lock service or timing benchmark",
               assumptions=["A pauses and loses its lease", "B receives a higher token", "The main trace delivers B's write before A resumes"],
               events=events,limits=dict(equal_token_outcome=duplicate,equal_token_effects=2,
                                        old_token_before_newer_seen=before_newer))
    Path("trace.json").write_text(json.dumps(trace,indent=2)+"\n")
    with Path("outcomes.csv").open("w",newline="") as f:
        writer=csv.DictWriter(f,fieldnames=list(outcomes[0]));writer.writeheader();writer.writerows(outcomes)

if __name__ == "__main__":
    run()