あしたも開く店の作り方

# MIT License
# 
# Copyright (c) 2026
# 
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# 
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# 
# Third-party exception: bitmap glyph data derived from Noto Sans CJK is licensed
# under the SIL Open Font License 1.1. See assets/NOTO-LICENSE.txt.

"""あしたも開く店: 第1段階。Python 3.11+ / Pyxel 2.9.9。"""
from dataclasses import dataclass, replace

ITEMS = ("MUG", "STAR")
NAMES = {"ハナ": "HANA", "レン": "REN", "ミナ": "MINA"}
SELL_PRICE = 2


def label(name):
    if name.endswith("の友人"):
        return NAMES.get(name[:-3], "GUEST") + " FRIEND"
    return NAMES.get(name, "GUEST")

QUEUE = (("ハナ", 0, "buy", ""), ("レン", 1, "buy", ""))

@dataclass(frozen=True)
class State:
    phase: str = "customer"
    cash: int = 6
    free: tuple = (1, 1)
    sold: int = 0
    index: int = 0


def initial():
    return State()


def shelf(s):
    return sum(s.free)


def customer(s):
    return QUEUE[s.index] if s.phase == "customer" else None


def actions(s):
    if s.phase == "customer":
        yield ("skip",)
        if s.free[customer(s)[1]] > 0:
            yield ("serve",)


def step(s, action):
    if type(action) not in (tuple, list) or not action or type(action[0]) is not str:
        raise ValueError("INVALID ACTION")
    if any(type(n) is not int for n in action[1:]):
        raise ValueError("INVALID ACTION COUNTS")
    action = tuple(action)
    if action not in actions(s):
        raise ValueError("ACTION NOT AVAILABLE")
    name, item, kind, origin = customer(s)
    free = list(s.free)
    cash, sold = s.cash, s.sold
    if action[0] == "skip":
        pass
    else:
        free[item] -= 1
        cash += SELL_PRICE
        sold += 1
    index = s.index + 1
    return replace(s, free=tuple(free), cash=cash, sold=sold, index=index,
                   phase="end" if index == len(QUEUE) else "customer")

class App:
    """The pure model is also usable without importing Pyxel."""
    def __init__(self):
        self.reset()

    def reset(self):
        self.state = initial()
        self.stock = [0, 0]
        self.item = 0
        self.previous = set()
        self.gated = False
        self.message = "READY"
        self.history = []

    def apply(self, action):
        try:
            after = step(self.state, action)
        except ValueError as error:
            self.message = str(error)
            return False
        # Undo is introduced in stage 5.
        self.state = after
        self.stock = [0, 0]
        self.message = action[0].upper()
        return True

    def control(self, down):
        down = set(down) & set(KEYS)
        fresh = down - self.previous
        self.previous = down
        if self.gated:
            if not down:
                self.gated = False
            return
        if not fresh:
            return
        self.gated = True
        if len(down) != 1:
            self.message = "RELEASE ALL KEYS"
            return
        key = next(iter(fresh))
        if key == "R":
            self.reset()
            self.gated = True
            self.previous = down
            return
        
        s = self.state
        if s.phase == "end":
            self.message = "ENDED / R TO RESET"
            return
        
        if s.phase == "customer":
            if key == "Z":
                self.apply(("collect",) if customer(s)[2] == "pickup" else ("serve",))
            elif key == "X":
                self.apply(("skip",))
        

    def draw(self, p):
        s = self.state
        p.cls(1)
        p.text(10, 10, "TOMORROW'S SHOP / STAGE 1", 10)
        day = getattr(s, "day", 1)
        p.text(10, 26, "DAY %d  %s" % (day, s.phase.upper()), 7)
        p.text(10, 40, "COINS %d   SOLD %d   OWNED %d" % (s.cash, s.sold, shelf(s)), 11)
        p.text(10, 55, "FICTIONAL COINS / NO REAL PURCHASES", 5)
        p.rectb(8, 70, 210, 105, 5)
        p.rectb(228, 70, 212, 105, 5)
        p.text(16, 78, "FREE STOCK", 6)
        for item in (0, 1):
            y = 98 + item * 28
            p.text(16, y, ITEMS[item], 7)
            for n in range(s.free[item]):
                x = 60 + n * 20
                if item == 0:
                    p.rect(x, y - 3, 12, 12, 12)
                    p.rectb(x + 10, y, 5, 6, 12)
                else:
                    p.rect(x, y - 3, 10, 15, 10)
                    p.text(x + 3, y + 1, "*", 1)
            p.text(174, y, "x%d" % s.free[item], 7)
        p.text(16, 156, "OWNED = FREE + RESERVED", 6)
        p.text(236, 78, "NAMED RESERVATIONS", 6)
        reservations = getattr(s, "reservations", ())
        for row, (name, item, due) in enumerate(reservations):
            p.text(236, 95 + row * 13, "%s %s D%d" % (label(name), ITEMS[item], due), 10)
        if not reservations:
            p.text(236, 98, "NONE", 5)
        p.text(10, 187, "CUSTOMER QUEUE / ARROW = CURRENT", 7)
        queue = s.queue if hasattr(s, "queue") else QUEUE
        for row, (name, item, kind, origin) in enumerate(queue):
            prefix = "> " if row == s.index and s.phase == "customer" else "  "
            line = prefix + label(name) + " / " + ITEMS[item] + " / " + kind.upper()
            p.text(10, 202 + row * 13, line, 10 if prefix == "> " else 6)
        if s.phase == "morning":
            p.text(10, 202, "BUY MUG %d  STAR %d / SELECT %s" % (*self.stock, ITEMS[self.item]), 10)
            p.text(10, 219, "RESERVATIONS STILL OCCUPY SHELF SPACE", 6)
            p.text(10, 235, "LEFT/RIGHT ITEM  UP/DOWN COUNT  Z OPEN", 7)
        if s.phase == "close":
            p.text(10, 260, "Z CLOSE / PAY 2 COINS", 10)
        elif s.phase == "end":
            end_text = "SALES PRACTICE COMPLETE"
            p.text(10, 260, end_text, 10)
        
        p.text(10, 287, self.message[:70], 11)
        p.text(10, 304, "Z SELL  X SKIP  R RESET  ESC QUIT", 6)

KEYS = ("LEFT", "RIGHT", "UP", "DOWN", "Z", "X", "U", "R")
DEMO_KEYS = ('Z',)


def parse_args(argv=None):
    """Validate all bounded QA flags before any Pyxel import or initialization."""
    import argparse
    from pathlib import Path
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--headless-smoke", action="store_true")
    parser.add_argument("--demo-checkpoint", action="store_true")
    parser.add_argument("--frames", type=int)
    parser.add_argument("--screenshot")
    args = parser.parse_args(argv)
    if (args.demo_checkpoint or args.screenshot or args.frames is not None) and not args.headless_smoke:
        parser.error("QA options require --headless-smoke")
    minimum = max(8, 2 * len(DEMO_KEYS) + 4) if args.demo_checkpoint else 8
    if args.frames is None:
        args.frames = minimum
    if not minimum <= args.frames <= 600:
        parser.error("--frames must be between %d and 600" % minimum)
    if args.screenshot:
        path = Path(args.screenshot).expanduser().resolve()
        if path.suffix.lower() != ".png" or path.exists() or not path.parent.is_dir():
            parser.error("screenshot must be a NEW .png file in an existing directory")
        args.screenshot = str(path)
    return args


def main(argv=None):
    args = parse_args(argv)
    import json
    from dataclasses import asdict
    import pyxel as p
    app = App()
    p.init(448, 320, title="Tomorrow's Shop / lesson 1", fps=30,
           display_scale=2, headless=args.headless_smoke)
    keys = {key: getattr(p, "KEY_" + key) for key in KEYS}
    def update():
        if args.headless_smoke and p.frame_count >= args.frames:
            if args.screenshot:
                p.screenshot(args.screenshot, scale=2)
            print(json.dumps({"state": asdict(app.state), "history_length": len(app.history)}, ensure_ascii=True), flush=True)
            p.quit()
            return
        if args.headless_smoke:
            index = p.frame_count // 2
            down = {DEMO_KEYS[index]} if args.demo_checkpoint and p.frame_count % 2 == 0 and index < len(DEMO_KEYS) else set()
        else:
            down = {key for key, value in keys.items() if p.btn(value)}
        app.control(down)
    p.run(update, lambda: app.draw(p))


if __name__ == "__main__":
    main()

# MIT License
# 
# Copyright (c) 2026
# 
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# 
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# 
# Third-party exception: bitmap glyph data derived from Noto Sans CJK is licensed
# under the SIL Open Font License 1.1. See assets/NOTO-LICENSE.txt.

"""あしたも開く店: 第2段階。Python 3.11+ / Pyxel 2.9.9。"""
from dataclasses import dataclass, replace

ITEMS = ("MUG", "STAR")
NAMES = {"ハナ": "HANA", "レン": "REN", "ミナ": "MINA"}
SELL_PRICE = 2


def label(name):
    if name.endswith("の友人"):
        return NAMES.get(name[:-3], "GUEST") + " FRIEND"
    return NAMES.get(name, "GUEST")

QUEUE = (("ハナ", 0, "buy", ""), ("レン", 1, "reserve", ""))

@dataclass(frozen=True)
class State:
    phase: str = "customer"
    cash: int = 6
    free: tuple = (1, 1)
    sold: int = 0
    index: int = 0
    reservations: tuple = ()


def initial():
    return State()


def shelf(s):
    return sum(s.free) + len(s.reservations)


def customer(s):
    return QUEUE[s.index] if s.phase == "customer" else None


def actions(s):
    if s.phase == "customer":
        yield ("skip",)
        if s.free[customer(s)[1]] > 0:
            yield ("serve",)


def step(s, action):
    if type(action) not in (tuple, list) or not action or type(action[0]) is not str:
        raise ValueError("INVALID ACTION")
    if any(type(n) is not int for n in action[1:]):
        raise ValueError("INVALID ACTION COUNTS")
    action = tuple(action)
    if action not in actions(s):
        raise ValueError("ACTION NOT AVAILABLE")
    name, item, kind, origin = customer(s)
    free = list(s.free)
    cash, sold = s.cash, s.sold
    reservations = list(s.reservations)
    if action[0] == "skip":
        pass
    elif kind == "reserve":
        free[item] -= 1
        reservations.append((name, item, 1 + 1))
    else:
        free[item] -= 1
        cash += SELL_PRICE
        sold += 1
    index = s.index + 1
    return replace(s, free=tuple(free), cash=cash, sold=sold, index=index,
                   phase="end" if index == len(QUEUE) else "customer",
                   reservations=tuple(reservations))

class App:
    """The pure model is also usable without importing Pyxel."""
    def __init__(self):
        self.reset()

    def reset(self):
        self.state = initial()
        self.stock = [0, 0]
        self.item = 0
        self.previous = set()
        self.gated = False
        self.message = "READY"
        self.history = []

    def apply(self, action):
        try:
            after = step(self.state, action)
        except ValueError as error:
            self.message = str(error)
            return False
        # Undo is introduced in stage 5.
        self.state = after
        self.stock = [0, 0]
        self.message = action[0].upper()
        return True

    def control(self, down):
        down = set(down) & set(KEYS)
        fresh = down - self.previous
        self.previous = down
        if self.gated:
            if not down:
                self.gated = False
            return
        if not fresh:
            return
        self.gated = True
        if len(down) != 1:
            self.message = "RELEASE ALL KEYS"
            return
        key = next(iter(fresh))
        if key == "R":
            self.reset()
            self.gated = True
            self.previous = down
            return
        
        s = self.state
        if s.phase == "end":
            self.message = "ENDED / R TO RESET"
            return
        
        if s.phase == "customer":
            if key == "Z":
                self.apply(("collect",) if customer(s)[2] == "pickup" else ("serve",))
            elif key == "X":
                self.apply(("skip",))
        

    def draw(self, p):
        s = self.state
        p.cls(1)
        p.text(10, 10, "TOMORROW'S SHOP / STAGE 2", 10)
        day = getattr(s, "day", 1)
        p.text(10, 26, "DAY %d  %s" % (day, s.phase.upper()), 7)
        p.text(10, 40, "COINS %d   SOLD %d   OWNED %d" % (s.cash, s.sold, shelf(s)), 11)
        p.text(10, 55, "FICTIONAL COINS / NO REAL PURCHASES", 5)
        p.rectb(8, 70, 210, 105, 5)
        p.rectb(228, 70, 212, 105, 5)
        p.text(16, 78, "FREE STOCK", 6)
        for item in (0, 1):
            y = 98 + item * 28
            p.text(16, y, ITEMS[item], 7)
            for n in range(s.free[item]):
                x = 60 + n * 20
                if item == 0:
                    p.rect(x, y - 3, 12, 12, 12)
                    p.rectb(x + 10, y, 5, 6, 12)
                else:
                    p.rect(x, y - 3, 10, 15, 10)
                    p.text(x + 3, y + 1, "*", 1)
            p.text(174, y, "x%d" % s.free[item], 7)
        p.text(16, 156, "OWNED = FREE + RESERVED", 6)
        p.text(236, 78, "NAMED RESERVATIONS", 6)
        reservations = getattr(s, "reservations", ())
        for row, (name, item, due) in enumerate(reservations):
            p.text(236, 95 + row * 13, "%s %s D%d" % (label(name), ITEMS[item], due), 10)
        if not reservations:
            p.text(236, 98, "NONE", 5)
        p.text(10, 187, "CUSTOMER QUEUE / ARROW = CURRENT", 7)
        queue = s.queue if hasattr(s, "queue") else QUEUE
        for row, (name, item, kind, origin) in enumerate(queue):
            prefix = "> " if row == s.index and s.phase == "customer" else "  "
            line = prefix + label(name) + " / " + ITEMS[item] + " / " + kind.upper()
            p.text(10, 202 + row * 13, line, 10 if prefix == "> " else 6)
        if s.phase == "morning":
            p.text(10, 202, "BUY MUG %d  STAR %d / SELECT %s" % (*self.stock, ITEMS[self.item]), 10)
            p.text(10, 219, "RESERVATIONS STILL OCCUPY SHELF SPACE", 6)
            p.text(10, 235, "LEFT/RIGHT ITEM  UP/DOWN COUNT  Z OPEN", 7)
        if s.phase == "close":
            p.text(10, 260, "Z CLOSE / PAY 2 COINS", 10)
        elif s.phase == "end":
            end_text = "RESERVED FOR DAY 2 / NEXT: STAGE 3"
            p.text(10, 260, end_text, 10)
        
        p.text(10, 287, self.message[:70], 11)
        p.text(10, 304, "Z SELL/RESERVE  X SKIP  R RESET  ESC QUIT", 6)

KEYS = ("LEFT", "RIGHT", "UP", "DOWN", "Z", "X", "U", "R")
DEMO_KEYS = ('Z', 'Z')


def parse_args(argv=None):
    """Validate all bounded QA flags before any Pyxel import or initialization."""
    import argparse
    from pathlib import Path
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--headless-smoke", action="store_true")
    parser.add_argument("--demo-checkpoint", action="store_true")
    parser.add_argument("--frames", type=int)
    parser.add_argument("--screenshot")
    args = parser.parse_args(argv)
    if (args.demo_checkpoint or args.screenshot or args.frames is not None) and not args.headless_smoke:
        parser.error("QA options require --headless-smoke")
    minimum = max(8, 2 * len(DEMO_KEYS) + 4) if args.demo_checkpoint else 8
    if args.frames is None:
        args.frames = minimum
    if not minimum <= args.frames <= 600:
        parser.error("--frames must be between %d and 600" % minimum)
    if args.screenshot:
        path = Path(args.screenshot).expanduser().resolve()
        if path.suffix.lower() != ".png" or path.exists() or not path.parent.is_dir():
            parser.error("screenshot must be a NEW .png file in an existing directory")
        args.screenshot = str(path)
    return args


def main(argv=None):
    args = parse_args(argv)
    import json
    from dataclasses import asdict
    import pyxel as p
    app = App()
    p.init(448, 320, title="Tomorrow's Shop / lesson 2", fps=30,
           display_scale=2, headless=args.headless_smoke)
    keys = {key: getattr(p, "KEY_" + key) for key in KEYS}
    def update():
        if args.headless_smoke and p.frame_count >= args.frames:
            if args.screenshot:
                p.screenshot(args.screenshot, scale=2)
            print(json.dumps({"state": asdict(app.state), "history_length": len(app.history)}, ensure_ascii=True), flush=True)
            p.quit()
            return
        if args.headless_smoke:
            index = p.frame_count // 2
            down = {DEMO_KEYS[index]} if args.demo_checkpoint and p.frame_count % 2 == 0 and index < len(DEMO_KEYS) else set()
        else:
            down = {key for key, value in keys.items() if p.btn(value)}
        app.control(down)
    p.run(update, lambda: app.draw(p))


if __name__ == "__main__":
    main()

# MIT License
# 
# Copyright (c) 2026
# 
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# 
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# 
# Third-party exception: bitmap glyph data derived from Noto Sans CJK is licensed
# under the SIL Open Font License 1.1. See assets/NOTO-LICENSE.txt.

"""あしたも開く店: 第3段階。Python 3.11+ / Pyxel 2.9.9。"""
from dataclasses import dataclass, replace

ITEMS = ("MUG", "STAR")
NAMES = {"ハナ": "HANA", "レン": "REN", "ミナ": "MINA"}
SELL_PRICE = 2


def label(name):
    if name.endswith("の友人"):
        return NAMES.get(name[:-3], "GUEST") + " FRIEND"
    return NAMES.get(name, "GUEST")

CAPACITY = 5
RENT = 2
TABLE = (
    (("ハナ", 0, "buy"), ("レン", 1, "reserve")),
    (("ハナ", 1, "buy"), ("ミナ", 0, "reserve")),
    (("レン", 0, "buy"), ("ハナ", 0, "buy")),
)

@dataclass(frozen=True)
class State:
    day: int = 1
    phase: str = "morning"
    cash: int = 6
    free: tuple = (1, 1)
    sold: int = 0
    index: int = 0
    reservations: tuple = ()
    queue: tuple = ()
    bought: int = 0
    rent: int = 0


def initial():
    return State()


def shelf(s):
    return sum(s.free) + len(s.reservations)


def customer(s):
    return s.queue[s.index] if s.phase == "customer" else None


def success(s):
    return s.phase == "end" and s.sold >= 4 and s.cash >= 0


def forecast(s, buy=(0, 0)):
    if s.phase != "morning":
        raise ValueError("STOCK ONLY IN MORNING")
    if type(buy) not in (tuple, list) or len(buy) != 2:
        raise ValueError("USE TWO COUNTS")
    if any(type(n) is not int or not 0 <= n <= 3 for n in buy):
        raise ValueError("COUNTS MUST BE INTEGERS 0..3")
    if sum(buy) > 3:
        raise ValueError("BUY AT MOST 3")
    if sum(buy) > s.cash:
        raise ValueError("NOT ENOUGH COINS")
    if shelf(s) + sum(buy) > CAPACITY:
        raise ValueError("SHELF FULL INCLUDING RESERVATIONS")
    pickups = tuple((n, i, "pickup", "") for n, i, due in s.reservations if due == s.day)
    fixed = tuple((n, i, kind, "") for n, i, kind in TABLE[s.day - 1])
    queue = pickups + fixed
    return {"cost": sum(buy), "free": tuple(s.free[i] + buy[i] for i in (0, 1)),
            "shelf": shelf(s) + sum(buy), "queue": queue}


def actions(s):
    if s.phase == "morning":
        for mug in range(4):
            for star in range(4 - mug):
                try:
                    forecast(s, (mug, star))
                except ValueError:
                    continue
                yield ("stock", mug, star)
    elif s.phase == "close":
        yield ("close",)
    elif s.phase == "customer":
        if customer(s)[2] == "pickup":
            yield ("collect",)
        else:
            yield ("skip",)
            if s.free[customer(s)[1]] > 0:
                yield ("serve",)


def step(s, action):
    if type(action) not in (tuple, list) or not action or type(action[0]) is not str:
        raise ValueError("INVALID ACTION")
    if any(type(n) is not int for n in action[1:]):
        raise ValueError("INVALID ACTION COUNTS")
    action = tuple(action)
    if action not in actions(s):
        raise ValueError("ACTION NOT AVAILABLE")
    if action[0] == "stock":
        f = forecast(s, action[1:])
        return replace(s, cash=s.cash - f["cost"], free=f["free"], queue=f["queue"],
                       index=0, phase="customer", bought=s.bought + f["cost"])
    if action[0] == "close":
        cash = s.cash - RENT
        end = s.day == 3 or cash < 0
        return replace(s, cash=cash, rent=s.rent + 1, day=s.day if end else s.day + 1,
                       phase="end" if end else "morning", queue=(), index=0)
    name, item, kind, origin = customer(s)
    free = list(s.free)
    cash, sold = s.cash, s.sold
    reservations = list(s.reservations)
    if action[0] == "skip":
        pass
    elif kind == "reserve":
        free[item] -= 1
        reservations.append((name, item, s.day + 1))
    else:
        if kind == "pickup":
            reservations.remove((name, item, s.day))
        else:
            free[item] -= 1
        cash += SELL_PRICE
        sold += 1
    index = s.index + 1
    return replace(s, free=tuple(free), cash=cash, sold=sold, index=index,
                   phase="close" if index == len(s.queue) else "customer",
                   reservations=tuple(reservations))

class App:
    """The pure model is also usable without importing Pyxel."""
    def __init__(self):
        self.reset()

    def reset(self):
        self.state = initial()
        self.stock = [0, 0]
        self.item = 0
        self.previous = set()
        self.gated = False
        self.message = "READY"
        self.history = []

    def apply(self, action):
        try:
            after = step(self.state, action)
        except ValueError as error:
            self.message = str(error)
            return False
        # Undo is introduced in stage 5.
        self.state = after
        self.stock = [0, 0]
        self.message = action[0].upper()
        return True

    def control(self, down):
        down = set(down) & set(KEYS)
        fresh = down - self.previous
        self.previous = down
        if self.gated:
            if not down:
                self.gated = False
            return
        if not fresh:
            return
        self.gated = True
        if len(down) != 1:
            self.message = "RELEASE ALL KEYS"
            return
        key = next(iter(fresh))
        if key == "R":
            self.reset()
            self.gated = True
            self.previous = down
            return
        
        s = self.state
        if s.phase == "end":
            self.message = "ENDED / R TO RESET"
            return
        if s.phase == "morning":
            if key in ("LEFT", "RIGHT"):
                self.item = 1 - self.item
            elif key in ("UP", "DOWN"):
                delta = 1 if key == "UP" else -1
                self.stock[self.item] = max(0, min(3, self.stock[self.item] + delta))
            elif key == "Z":
                self.apply(("stock", *self.stock))
            return
        if s.phase == "customer":
            if key == "Z":
                self.apply(("collect",) if customer(s)[2] == "pickup" else ("serve",))
            elif key == "X":
                self.apply(("skip",))
        elif s.phase == "close" and key == "Z":
            self.apply(("close",))

    def draw(self, p):
        s = self.state
        p.cls(1)
        p.text(10, 10, "TOMORROW'S SHOP / STAGE 3", 10)
        day = getattr(s, "day", 1)
        p.text(10, 26, "DAY %d  %s" % (day, s.phase.upper()), 7)
        p.text(10, 40, "COINS %d   SOLD %d   OWNED %d" % (s.cash, s.sold, shelf(s)), 11)
        p.text(10, 55, "FICTIONAL COINS / NO REAL PURCHASES", 5)
        p.rectb(8, 70, 210, 105, 5)
        p.rectb(228, 70, 212, 105, 5)
        p.text(16, 78, "FREE STOCK", 6)
        for item in (0, 1):
            y = 98 + item * 28
            p.text(16, y, ITEMS[item], 7)
            for n in range(s.free[item]):
                x = 60 + n * 20
                if item == 0:
                    p.rect(x, y - 3, 12, 12, 12)
                    p.rectb(x + 10, y, 5, 6, 12)
                else:
                    p.rect(x, y - 3, 10, 15, 10)
                    p.text(x + 3, y + 1, "*", 1)
            p.text(174, y, "x%d" % s.free[item], 7)
        p.text(16, 156, "OWNED = FREE + RESERVED", 6)
        p.text(236, 78, "NAMED RESERVATIONS", 6)
        reservations = getattr(s, "reservations", ())
        for row, (name, item, due) in enumerate(reservations):
            p.text(236, 95 + row * 13, "%s %s D%d" % (label(name), ITEMS[item], due), 10)
        if not reservations:
            p.text(236, 98, "NONE", 5)
        p.text(10, 187, "CUSTOMER QUEUE / ARROW = CURRENT", 7)
        queue = s.queue if hasattr(s, "queue") else QUEUE
        for row, (name, item, kind, origin) in enumerate(queue):
            prefix = "> " if row == s.index and s.phase == "customer" else "  "
            line = prefix + label(name) + " / " + ITEMS[item] + " / " + kind.upper()
            p.text(10, 202 + row * 13, line, 10 if prefix == "> " else 6)
        if s.phase == "morning":
            p.text(10, 202, "BUY MUG %d  STAR %d / SELECT %s" % (*self.stock, ITEMS[self.item]), 10)
            p.text(10, 219, "RESERVATIONS STILL OCCUPY SHELF SPACE", 6)
            p.text(10, 235, "LEFT/RIGHT ITEM  UP/DOWN COUNT  Z OPEN", 7)
        if s.phase == "close":
            p.text(10, 260, "Z CLOSE / PAY 2 COINS", 10)
        elif s.phase == "end":
            end_text = "GOAL MET" if success(s) else "REVIEW YOUR PLAN"
            p.text(10, 260, end_text, 10)
        
        p.text(10, 287, self.message[:70], 11)
        p.text(10, 304, "Z SERVE/OPEN/CLOSE  X SKIP  R RESET  ESC QUIT", 6)

KEYS = ("LEFT", "RIGHT", "UP", "DOWN", "Z", "X", "U", "R")
DEMO_KEYS = ('Z', 'Z', 'Z', 'Z', 'UP', 'UP', 'RIGHT', 'UP', 'Z')


def parse_args(argv=None):
    """Validate all bounded QA flags before any Pyxel import or initialization."""
    import argparse
    from pathlib import Path
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--headless-smoke", action="store_true")
    parser.add_argument("--demo-checkpoint", action="store_true")
    parser.add_argument("--frames", type=int)
    parser.add_argument("--screenshot")
    args = parser.parse_args(argv)
    if (args.demo_checkpoint or args.screenshot or args.frames is not None) and not args.headless_smoke:
        parser.error("QA options require --headless-smoke")
    minimum = max(8, 2 * len(DEMO_KEYS) + 4) if args.demo_checkpoint else 8
    if args.frames is None:
        args.frames = minimum
    if not minimum <= args.frames <= 600:
        parser.error("--frames must be between %d and 600" % minimum)
    if args.screenshot:
        path = Path(args.screenshot).expanduser().resolve()
        if path.suffix.lower() != ".png" or path.exists() or not path.parent.is_dir():
            parser.error("screenshot must be a NEW .png file in an existing directory")
        args.screenshot = str(path)
    return args


def main(argv=None):
    args = parse_args(argv)
    import json
    from dataclasses import asdict
    import pyxel as p
    app = App()
    p.init(448, 320, title="Tomorrow's Shop / lesson 3", fps=30,
           display_scale=2, headless=args.headless_smoke)
    keys = {key: getattr(p, "KEY_" + key) for key in KEYS}
    def update():
        if args.headless_smoke and p.frame_count >= args.frames:
            if args.screenshot:
                p.screenshot(args.screenshot, scale=2)
            print(json.dumps({"state": asdict(app.state), "history_length": len(app.history)}, ensure_ascii=True), flush=True)
            p.quit()
            return
        if args.headless_smoke:
            index = p.frame_count // 2
            down = {DEMO_KEYS[index]} if args.demo_checkpoint and p.frame_count % 2 == 0 and index < len(DEMO_KEYS) else set()
        else:
            down = {key for key, value in keys.items() if p.btn(value)}
        app.control(down)
    p.run(update, lambda: app.draw(p))


if __name__ == "__main__":
    main()

# MIT License
# 
# Copyright (c) 2026
# 
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# 
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# 
# Third-party exception: bitmap glyph data derived from Noto Sans CJK is licensed
# under the SIL Open Font License 1.1. See assets/NOTO-LICENSE.txt.

"""あしたも開く店: 第4段階。Python 3.11+ / Pyxel 2.9.9。"""
from dataclasses import dataclass, replace

ITEMS = ("MUG", "STAR")
NAMES = {"ハナ": "HANA", "レン": "REN", "ミナ": "MINA"}
SELL_PRICE = 2


def label(name):
    if name.endswith("の友人"):
        return NAMES.get(name[:-3], "GUEST") + " FRIEND"
    return NAMES.get(name, "GUEST")

CAPACITY = 5
RENT = 2
TABLE = (
    (("ハナ", 0, "buy"), ("レン", 1, "reserve")),
    (("ハナ", 1, "buy"), ("ミナ", 0, "reserve")),
    (("レン", 0, "buy"), ("ハナ", 0, "buy")),
)

@dataclass(frozen=True)
class State:
    day: int = 1
    phase: str = "morning"
    cash: int = 6
    free: tuple = (1, 1)
    sold: int = 0
    index: int = 0
    reservations: tuple = ()
    queue: tuple = ()
    bought: int = 0
    rent: int = 0
    memory: tuple = ()


def initial():
    return State()


def shelf(s):
    return sum(s.free) + len(s.reservations)


def customer(s):
    return s.queue[s.index] if s.phase == "customer" else None


def memory_for(s, name):
    return next((m for m in s.memory if m[0] == name), (name, 0, -1, 0, 0, ""))


def success(s):
    return s.phase == "end" and s.sold >= 4 and s.cash >= 0


def forecast(s, buy=(0, 0)):
    if s.phase != "morning":
        raise ValueError("STOCK ONLY IN MORNING")
    if type(buy) not in (tuple, list) or len(buy) != 2:
        raise ValueError("USE TWO COUNTS")
    if any(type(n) is not int or not 0 <= n <= 3 for n in buy):
        raise ValueError("COUNTS MUST BE INTEGERS 0..3")
    if sum(buy) > 3:
        raise ValueError("BUY AT MOST 3")
    if sum(buy) > s.cash:
        raise ValueError("NOT ENOUGH COINS")
    if shelf(s) + sum(buy) > CAPACITY:
        raise ValueError("SHELF FULL INCLUDING RESERVATIONS")
    pickups = tuple((n, i, "pickup", "") for n, i, due in s.reservations if due == s.day)
    fixed = tuple((n, i, kind, "") for n, i, kind in TABLE[s.day - 1])
    friends = ((pickups[0][0] + "の友人", 1 - pickups[0][1], "buy", pickups[0][0]),) if pickups else ()
    queue = pickups + fixed + friends
    return {"cost": sum(buy), "free": tuple(s.free[i] + buy[i] for i in (0, 1)),
            "shelf": shelf(s) + sum(buy), "queue": queue}


def actions(s):
    if s.phase == "morning":
        for mug in range(4):
            for star in range(4 - mug):
                try:
                    forecast(s, (mug, star))
                except ValueError:
                    continue
                yield ("stock", mug, star)
    elif s.phase == "close":
        yield ("close",)
    elif s.phase == "customer":
        if customer(s)[2] == "pickup":
            yield ("collect",)
        else:
            yield ("skip",)
            if s.free[customer(s)[1]] > 0:
                yield ("serve",)


def step(s, action):
    if type(action) not in (tuple, list) or not action or type(action[0]) is not str:
        raise ValueError("INVALID ACTION")
    if any(type(n) is not int for n in action[1:]):
        raise ValueError("INVALID ACTION COUNTS")
    action = tuple(action)
    if action not in actions(s):
        raise ValueError("ACTION NOT AVAILABLE")
    if action[0] == "stock":
        f = forecast(s, action[1:])
        return replace(s, cash=s.cash - f["cost"], free=f["free"], queue=f["queue"],
                       index=0, phase="customer", bought=s.bought + f["cost"])
    if action[0] == "close":
        cash = s.cash - RENT
        end = s.day == 3 or cash < 0
        return replace(s, cash=cash, rent=s.rent + 1, day=s.day if end else s.day + 1,
                       phase="end" if end else "morning", queue=(), index=0)
    name, item, kind, origin = customer(s)
    free = list(s.free)
    cash, sold = s.cash, s.sold
    reservations = list(s.reservations)
    memory = list(memory_for(s, name))
    memory[1] += 1
    if origin:
        memory[5] = origin
    if action[0] == "skip":
        if kind == "reserve":
            memory[4] += 1
    elif kind == "reserve":
        free[item] -= 1
        reservations.append((name, item, s.day + 1))
        memory[3] += 1
    else:
        if kind == "pickup":
            reservations.remove((name, item, s.day))
        else:
            free[item] -= 1
        cash += SELL_PRICE
        sold += 1
        memory[2] = item
    memories = {m[0]: m for m in s.memory}
    memories[name] = tuple(memory)
    index = s.index + 1
    return replace(s, free=tuple(free), cash=cash, sold=sold, index=index,
                   phase="close" if index == len(s.queue) else "customer",
                   reservations=tuple(reservations), memory=tuple(sorted(memories.values())))

class App:
    """The pure model is also usable without importing Pyxel."""
    def __init__(self):
        self.reset()

    def reset(self):
        self.state = initial()
        self.stock = [0, 0]
        self.item = 0
        self.previous = set()
        self.gated = False
        self.message = "READY"
        self.history = []

    def apply(self, action):
        try:
            after = step(self.state, action)
        except ValueError as error:
            self.message = str(error)
            return False
        # Undo is introduced in stage 5.
        self.state = after
        self.stock = [0, 0]
        self.message = action[0].upper()
        return True

    def control(self, down):
        down = set(down) & set(KEYS)
        fresh = down - self.previous
        self.previous = down
        if self.gated:
            if not down:
                self.gated = False
            return
        if not fresh:
            return
        self.gated = True
        if len(down) != 1:
            self.message = "RELEASE ALL KEYS"
            return
        key = next(iter(fresh))
        if key == "R":
            self.reset()
            self.gated = True
            self.previous = down
            return
        
        s = self.state
        if s.phase == "end":
            self.message = "ENDED / R TO RESET"
            return
        if s.phase == "morning":
            if key in ("LEFT", "RIGHT"):
                self.item = 1 - self.item
            elif key in ("UP", "DOWN"):
                delta = 1 if key == "UP" else -1
                self.stock[self.item] = max(0, min(3, self.stock[self.item] + delta))
            elif key == "Z":
                self.apply(("stock", *self.stock))
            return
        if s.phase == "customer":
            if key == "Z":
                self.apply(("collect",) if customer(s)[2] == "pickup" else ("serve",))
            elif key == "X":
                self.apply(("skip",))
        elif s.phase == "close" and key == "Z":
            self.apply(("close",))

    def draw(self, p):
        s = self.state
        p.cls(1)
        p.text(10, 10, "TOMORROW'S SHOP / STAGE 4", 10)
        day = getattr(s, "day", 1)
        p.text(10, 26, "DAY %d  %s" % (day, s.phase.upper()), 7)
        p.text(10, 40, "COINS %d   SOLD %d   OWNED %d" % (s.cash, s.sold, shelf(s)), 11)
        p.text(10, 55, "FICTIONAL COINS / NO REAL PURCHASES", 5)
        p.rectb(8, 70, 210, 105, 5)
        p.rectb(228, 70, 212, 105, 5)
        p.text(16, 78, "FREE STOCK", 6)
        for item in (0, 1):
            y = 98 + item * 28
            p.text(16, y, ITEMS[item], 7)
            for n in range(s.free[item]):
                x = 60 + n * 20
                if item == 0:
                    p.rect(x, y - 3, 12, 12, 12)
                    p.rectb(x + 10, y, 5, 6, 12)
                else:
                    p.rect(x, y - 3, 10, 15, 10)
                    p.text(x + 3, y + 1, "*", 1)
            p.text(174, y, "x%d" % s.free[item], 7)
        p.text(16, 156, "OWNED = FREE + RESERVED", 6)
        p.text(236, 78, "NAMED RESERVATIONS", 6)
        reservations = getattr(s, "reservations", ())
        for row, (name, item, due) in enumerate(reservations):
            p.text(236, 95 + row * 13, "%s %s D%d" % (label(name), ITEMS[item], due), 10)
        if not reservations:
            p.text(236, 98, "NONE", 5)
        p.text(10, 187, "CUSTOMER QUEUE / ARROW = CURRENT", 7)
        queue = s.queue if hasattr(s, "queue") else QUEUE
        for row, (name, item, kind, origin) in enumerate(queue):
            prefix = "> " if row == s.index and s.phase == "customer" else "  "
            line = prefix + label(name) + " / " + ITEMS[item] + " / " + kind.upper()
            p.text(10, 202 + row * 13, line, 10 if prefix == "> " else 6)
        if s.phase == "morning":
            p.text(10, 202, "BUY MUG %d  STAR %d / SELECT %s" % (*self.stock, ITEMS[self.item]), 10)
            p.text(10, 219, "RESERVATIONS STILL OCCUPY SHELF SPACE", 6)
            p.text(10, 235, "LEFT/RIGHT ITEM  UP/DOWN COUNT  Z OPEN", 7)
        if s.phase == "close":
            p.text(10, 260, "Z CLOSE / PAY 2 COINS", 10)
        elif s.phase == "end":
            end_text = "GOAL MET" if success(s) else "REVIEW YOUR PLAN"
            p.text(10, 260, end_text, 10)
        c = customer(s)
        if c:
            m = memory_for(s, c[0])
            p.text(238, 260, "PAST VISITS %d / BOUGHT %s" % (m[1], "-" if m[2] < 0 else ITEMS[m[2]]), 6)
        p.text(10, 287, self.message[:70], 11)
        p.text(10, 304, "Z SERVE/OPEN/CLOSE  X SKIP  R RESET  ESC QUIT", 6)

KEYS = ("LEFT", "RIGHT", "UP", "DOWN", "Z", "X", "U", "R")
DEMO_KEYS = ('Z', 'Z', 'Z', 'Z', 'UP', 'UP', 'RIGHT', 'UP', 'Z')


def parse_args(argv=None):
    """Validate all bounded QA flags before any Pyxel import or initialization."""
    import argparse
    from pathlib import Path
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--headless-smoke", action="store_true")
    parser.add_argument("--demo-checkpoint", action="store_true")
    parser.add_argument("--frames", type=int)
    parser.add_argument("--screenshot")
    args = parser.parse_args(argv)
    if (args.demo_checkpoint or args.screenshot or args.frames is not None) and not args.headless_smoke:
        parser.error("QA options require --headless-smoke")
    minimum = max(8, 2 * len(DEMO_KEYS) + 4) if args.demo_checkpoint else 8
    if args.frames is None:
        args.frames = minimum
    if not minimum <= args.frames <= 600:
        parser.error("--frames must be between %d and 600" % minimum)
    if args.screenshot:
        path = Path(args.screenshot).expanduser().resolve()
        if path.suffix.lower() != ".png" or path.exists() or not path.parent.is_dir():
            parser.error("screenshot must be a NEW .png file in an existing directory")
        args.screenshot = str(path)
    return args


def main(argv=None):
    args = parse_args(argv)
    import json
    from dataclasses import asdict
    import pyxel as p
    app = App()
    p.init(448, 320, title="Tomorrow's Shop / lesson 4", fps=30,
           display_scale=2, headless=args.headless_smoke)
    keys = {key: getattr(p, "KEY_" + key) for key in KEYS}
    def update():
        if args.headless_smoke and p.frame_count >= args.frames:
            if args.screenshot:
                p.screenshot(args.screenshot, scale=2)
            print(json.dumps({"state": asdict(app.state), "history_length": len(app.history)}, ensure_ascii=True), flush=True)
            p.quit()
            return
        if args.headless_smoke:
            index = p.frame_count // 2
            down = {DEMO_KEYS[index]} if args.demo_checkpoint and p.frame_count % 2 == 0 and index < len(DEMO_KEYS) else set()
        else:
            down = {key for key, value in keys.items() if p.btn(value)}
        app.control(down)
    p.run(update, lambda: app.draw(p))


if __name__ == "__main__":
    main()

# MIT License
# 
# Copyright (c) 2026
# 
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# 
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# 
# Third-party exception: bitmap glyph data derived from Noto Sans CJK is licensed
# under the SIL Open Font License 1.1. See assets/NOTO-LICENSE.txt.

"""あしたも開く店: 第5段階。Python 3.11+ / Pyxel 2.9.9。"""
from dataclasses import dataclass, replace

ITEMS = ("MUG", "STAR")
NAMES = {"ハナ": "HANA", "レン": "REN", "ミナ": "MINA"}
SELL_PRICE = 2


def label(name):
    if name.endswith("の友人"):
        return NAMES.get(name[:-3], "GUEST") + " FRIEND"
    return NAMES.get(name, "GUEST")

CAPACITY = 5
RENT = 2
TABLE = (
    (("ハナ", 0, "buy"), ("レン", 1, "reserve")),
    (("ハナ", 1, "buy"), ("ミナ", 0, "reserve")),
    (("レン", 0, "buy"), ("ハナ", 0, "buy")),
)

@dataclass(frozen=True)
class State:
    day: int = 1
    phase: str = "morning"
    cash: int = 6
    free: tuple = (1, 1)
    sold: int = 0
    index: int = 0
    reservations: tuple = ()
    queue: tuple = ()
    bought: int = 0
    rent: int = 0
    memory: tuple = ()


def initial():
    return State()


def shelf(s):
    return sum(s.free) + len(s.reservations)


def customer(s):
    return s.queue[s.index] if s.phase == "customer" else None


def memory_for(s, name):
    return next((m for m in s.memory if m[0] == name), (name, 0, -1, 0, 0, ""))


def success(s):
    return s.phase == "end" and s.sold >= 4 and s.cash >= 0


def forecast(s, buy=(0, 0)):
    if s.phase != "morning":
        raise ValueError("STOCK ONLY IN MORNING")
    if type(buy) not in (tuple, list) or len(buy) != 2:
        raise ValueError("USE TWO COUNTS")
    if any(type(n) is not int or not 0 <= n <= 3 for n in buy):
        raise ValueError("COUNTS MUST BE INTEGERS 0..3")
    if sum(buy) > 3:
        raise ValueError("BUY AT MOST 3")
    if sum(buy) > s.cash:
        raise ValueError("NOT ENOUGH COINS")
    if shelf(s) + sum(buy) > CAPACITY:
        raise ValueError("SHELF FULL INCLUDING RESERVATIONS")
    pickups = tuple((n, i, "pickup", "") for n, i, due in s.reservations if due == s.day)
    fixed = tuple((n, i, kind, "") for n, i, kind in TABLE[s.day - 1])
    friends = ((pickups[0][0] + "の友人", 1 - pickups[0][1], "buy", pickups[0][0]),) if pickups else ()
    queue = pickups + fixed + friends
    return {"cost": sum(buy), "free": tuple(s.free[i] + buy[i] for i in (0, 1)),
            "shelf": shelf(s) + sum(buy), "queue": queue}


def actions(s):
    if s.phase == "morning":
        for mug in range(4):
            for star in range(4 - mug):
                try:
                    forecast(s, (mug, star))
                except ValueError:
                    continue
                yield ("stock", mug, star)
    elif s.phase == "close":
        yield ("close",)
    elif s.phase == "customer":
        if customer(s)[2] == "pickup":
            yield ("collect",)
        else:
            yield ("skip",)
            if s.free[customer(s)[1]] > 0:
                yield ("serve",)


def step(s, action):
    if type(action) not in (tuple, list) or not action or type(action[0]) is not str:
        raise ValueError("INVALID ACTION")
    if any(type(n) is not int for n in action[1:]):
        raise ValueError("INVALID ACTION COUNTS")
    action = tuple(action)
    if action not in actions(s):
        raise ValueError("ACTION NOT AVAILABLE")
    if action[0] == "stock":
        f = forecast(s, action[1:])
        return replace(s, cash=s.cash - f["cost"], free=f["free"], queue=f["queue"],
                       index=0, phase="customer", bought=s.bought + f["cost"])
    if action[0] == "close":
        cash = s.cash - RENT
        end = s.day == 3 or cash < 0
        return replace(s, cash=cash, rent=s.rent + 1, day=s.day if end else s.day + 1,
                       phase="end" if end else "morning", queue=(), index=0)
    name, item, kind, origin = customer(s)
    free = list(s.free)
    cash, sold = s.cash, s.sold
    reservations = list(s.reservations)
    memory = list(memory_for(s, name))
    memory[1] += 1
    if origin:
        memory[5] = origin
    if action[0] == "skip":
        if kind == "reserve":
            memory[4] += 1
    elif kind == "reserve":
        free[item] -= 1
        reservations.append((name, item, s.day + 1))
        memory[3] += 1
    else:
        if kind == "pickup":
            reservations.remove((name, item, s.day))
        else:
            free[item] -= 1
        cash += SELL_PRICE
        sold += 1
        memory[2] = item
    memories = {m[0]: m for m in s.memory}
    memories[name] = tuple(memory)
    index = s.index + 1
    return replace(s, free=tuple(free), cash=cash, sold=sold, index=index,
                   phase="close" if index == len(s.queue) else "customer",
                   reservations=tuple(reservations), memory=tuple(sorted(memories.values())))

class App:
    """The pure model is also usable without importing Pyxel."""
    def __init__(self):
        self.reset()

    def reset(self):
        self.state = initial()
        self.stock = [0, 0]
        self.item = 0
        self.previous = set()
        self.gated = False
        self.message = "READY"
        self.history = []

    def apply(self, action):
        try:
            after = step(self.state, action)
        except ValueError as error:
            self.message = str(error)
            return False
        self.history.append(self.state)
        self.state = after
        self.stock = [0, 0]
        self.message = action[0].upper()
        return True

    def control(self, down):
        down = set(down) & set(KEYS)
        fresh = down - self.previous
        self.previous = down
        if self.gated:
            if not down:
                self.gated = False
            return
        if not fresh:
            return
        self.gated = True
        if len(down) != 1:
            self.message = "RELEASE ALL KEYS"
            return
        key = next(iter(fresh))
        if key == "R":
            self.reset()
            self.gated = True
            self.previous = down
            return
        if key == "U":
            if self.history:
                self.state = self.history.pop()
                self.stock = [0, 0]
                self.message = "UNDO"
            else:
                self.message = "NOTHING TO UNDO"
            return
        s = self.state
        if s.phase == "end":
            self.message = "ENDED / R TO RESET"
            return
        if s.phase == "morning":
            if key in ("LEFT", "RIGHT"):
                self.item = 1 - self.item
            elif key in ("UP", "DOWN"):
                delta = 1 if key == "UP" else -1
                self.stock[self.item] = max(0, min(3, self.stock[self.item] + delta))
            elif key == "Z":
                self.apply(("stock", *self.stock))
            return
        if s.phase == "customer":
            if key == "Z":
                self.apply(("collect",) if customer(s)[2] == "pickup" else ("serve",))
            elif key == "X":
                self.apply(("skip",))
        elif s.phase == "close" and key == "Z":
            self.apply(("close",))

    def draw(self, p):
        s = self.state
        p.cls(1)
        p.text(10, 10, "TOMORROW'S SHOP / STAGE 5", 10)
        day = getattr(s, "day", 1)
        p.text(10, 26, "DAY %d  %s" % (day, s.phase.upper()), 7)
        p.text(10, 40, "COINS %d   SOLD %d   OWNED %d" % (s.cash, s.sold, shelf(s)), 11)
        p.text(10, 55, "FICTIONAL COINS / NO REAL PURCHASES", 5)
        p.rectb(8, 70, 210, 105, 5)
        p.rectb(228, 70, 212, 105, 5)
        p.text(16, 78, "FREE STOCK", 6)
        for item in (0, 1):
            y = 98 + item * 28
            p.text(16, y, ITEMS[item], 7)
            for n in range(s.free[item]):
                x = 60 + n * 20
                if item == 0:
                    p.rect(x, y - 3, 12, 12, 12)
                    p.rectb(x + 10, y, 5, 6, 12)
                else:
                    p.rect(x, y - 3, 10, 15, 10)
                    p.text(x + 3, y + 1, "*", 1)
            p.text(174, y, "x%d" % s.free[item], 7)
        p.text(16, 156, "OWNED = FREE + RESERVED", 6)
        p.text(236, 78, "NAMED RESERVATIONS", 6)
        reservations = getattr(s, "reservations", ())
        for row, (name, item, due) in enumerate(reservations):
            p.text(236, 95 + row * 13, "%s %s D%d" % (label(name), ITEMS[item], due), 10)
        if not reservations:
            p.text(236, 98, "NONE", 5)
        p.text(10, 187, "CUSTOMER QUEUE / ARROW = CURRENT", 7)
        queue = s.queue if hasattr(s, "queue") else QUEUE
        for row, (name, item, kind, origin) in enumerate(queue):
            prefix = "> " if row == s.index and s.phase == "customer" else "  "
            line = prefix + label(name) + " / " + ITEMS[item] + " / " + kind.upper()
            p.text(10, 202 + row * 13, line, 10 if prefix == "> " else 6)
        if s.phase == "morning":
            p.text(10, 202, "BUY MUG %d  STAR %d / SELECT %s" % (*self.stock, ITEMS[self.item]), 10)
            p.text(10, 219, "RESERVATIONS STILL OCCUPY SHELF SPACE", 6)
            p.text(10, 235, "LEFT/RIGHT ITEM  UP/DOWN COUNT  Z OPEN", 7)
        if s.phase == "close":
            p.text(10, 260, "Z CLOSE / PAY 2 COINS", 10)
        elif s.phase == "end":
            end_text = "GOAL MET" if success(s) else "REVIEW YOUR PLAN"
            p.text(10, 260, end_text, 10)
        c = customer(s)
        if c:
            m = memory_for(s, c[0])
            p.text(238, 260, "PAST VISITS %d / BOUGHT %s" % (m[1], "-" if m[2] < 0 else ITEMS[m[2]]), 6)
        p.text(10, 287, self.message[:70], 11)
        p.text(10, 304, "Z SERVE/OPEN/CLOSE  X SKIP  U UNDO  R RESET  ESC QUIT", 6)

KEYS = ("LEFT", "RIGHT", "UP", "DOWN", "Z", "X", "U", "R")
DEMO_KEYS = ('Z', 'Z', 'Z', 'Z', 'UP', 'UP', 'RIGHT', 'UP', 'Z', 'Z', 'U')


def parse_args(argv=None):
    """Validate all bounded QA flags before any Pyxel import or initialization."""
    import argparse
    from pathlib import Path
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--headless-smoke", action="store_true")
    parser.add_argument("--demo-checkpoint", action="store_true")
    parser.add_argument("--frames", type=int)
    parser.add_argument("--screenshot")
    args = parser.parse_args(argv)
    if (args.demo_checkpoint or args.screenshot or args.frames is not None) and not args.headless_smoke:
        parser.error("QA options require --headless-smoke")
    minimum = max(8, 2 * len(DEMO_KEYS) + 4) if args.demo_checkpoint else 8
    if args.frames is None:
        args.frames = minimum
    if not minimum <= args.frames <= 600:
        parser.error("--frames must be between %d and 600" % minimum)
    if args.screenshot:
        path = Path(args.screenshot).expanduser().resolve()
        if path.suffix.lower() != ".png" or path.exists() or not path.parent.is_dir():
            parser.error("screenshot must be a NEW .png file in an existing directory")
        args.screenshot = str(path)
    return args


def main(argv=None):
    args = parse_args(argv)
    import json
    from dataclasses import asdict
    import pyxel as p
    app = App()
    p.init(448, 320, title="Tomorrow's Shop / lesson 5", fps=30,
           display_scale=2, headless=args.headless_smoke)
    keys = {key: getattr(p, "KEY_" + key) for key in KEYS}
    def update():
        if args.headless_smoke and p.frame_count >= args.frames:
            if args.screenshot:
                p.screenshot(args.screenshot, scale=2)
            print(json.dumps({"state": asdict(app.state), "history_length": len(app.history)}, ensure_ascii=True), flush=True)
            p.quit()
            return
        if args.headless_smoke:
            index = p.frame_count // 2
            down = {DEMO_KEYS[index]} if args.demo_checkpoint and p.frame_count % 2 == 0 and index < len(DEMO_KEYS) else set()
        else:
            down = {key for key, value in keys.items() if p.btn(value)}
        app.control(down)
    p.run(update, lambda: app.draw(p))


if __name__ == "__main__":
    main()