import random
import threading
import time

import gradio as gr

# ZeroGPU Spaces require at least one @spaces.GPU function at startup. This game needs no
# GPU, so this is a do-nothing placeholder. It is skipped when `spaces` isn't installed
# (local runs and regular CPU hardware).
try:
    import spaces

    @spaces.GPU
    def _gpu_placeholder():
        return None

except ImportError:
    pass

MAX_MOVES = 10
ROOM_TTL_SECONDS = 24 * 60 * 60
# No I, O, 0 or 1 so room codes are easy to read aloud and type on a phone.
ROOM_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"
DIGITS = list("123456789")

# ---------- shared room store (one per running server, shared by every visitor) ----------

_LOCK = threading.Lock()
_ROOMS = {}  # code -> {"secret": str, "created": float}


def create_room(secret: str) -> str:
    with _LOCK:
        now = time.time()
        for code in [c for c, r in _ROOMS.items() if now - r["created"] > ROOM_TTL_SECONDS]:
            del _ROOMS[code]
        while True:
            code = "".join(random.choices(ROOM_ALPHABET, k=4))
            if code not in _ROOMS:
                break
        _ROOMS[code] = {"secret": secret, "created": now}
    return code


def lookup_room(code: str):
    with _LOCK:
        room = _ROOMS.get(code.strip().upper())
        if room and time.time() - room["created"] <= ROOM_TTL_SECONDS:
            return room["secret"]
    return None


# ---------- game logic ----------

def new_code() -> str:
    """4 unique digits, 1-9 (no zeroes, no repeats)."""
    return "".join(random.sample("123456789", 4))


def score(secret: str, guess: str):
    """Return (right_place, right_number). Digits are unique, so a set overlap works."""
    right_place = sum(s == g for s, g in zip(secret, guess))
    right_number = len(set(secret) & set(guess))
    return right_place, right_number


def validate(guess: str, previous=()):
    if len(guess) != 4:
        return "You do not have the correct character amount (need exactly 4)."
    if not guess.isdigit() or "0" in guess:
        return "There are no letters or zeroes in the code."
    if len(set(guess)) != 4:
        return "There are no repeats in the code."
    if guess in previous:
        return "You already guessed that."
    return None


def win_message(move: int) -> str:
    if move == 1:
        return "Wow, first try, that was really lucky."
    if move < 5:
        return "Wow, you actually guessed it. Good job!!!"
    if move < 8:
        return "Cutting it a little close, but good job."
    return "Wow, nice guess but almost too late. Good job!"


def hint_message(right_number: int) -> str:
    if right_number == 0:
        return "Man, that wasn't even close."
    if right_number <= 2:
        return "You are doing well, nice guess. JK loser. HAHAHAHAHA"
    return "You are almost there. Don't let me win. HAHAHAHAHAHA"


# ---------- per-visitor state and rendering ----------

def fresh_state():
    return {"mode": "menu", "secret": "", "room_code": "", "history": [], "status": "playing"}


def game_state(mode, secret, room_code=""):
    return {"mode": mode, "secret": secret, "room_code": room_code, "history": [], "status": "playing"}


def history_table(history) -> str:
    """Guess history as a Markdown table (fixed layout, so it can't stretch on phones)."""
    if not history:
        return ""
    lines = [
        "**Previous guesses**",
        "",
        "| Move | Guess | Right place | Right number |",
        "|:---:|:---:|:---:|:---:|",
    ]
    for i, (g, rp, rn) in enumerate(history):
        lines.append(f"| {i + 1} | `{g}` | {rp} | {rn} |")
    return "\n".join(lines)


def view(s, msg="", reset_marks=False):
    """Updates for VIEW_OUTPUTS, in order."""
    in_game = s["mode"] != "menu"
    over = s["status"] != "playing"
    used = len(s["history"])

    if s["mode"] == "room":
        badge = f"Room **{s['room_code']}** · a friend set this code"
    else:
        badge = "Solo game · random code"

    if over:
        header = "### Game over"
    else:
        header = f"### Move {used + 1} of {MAX_MOVES}\n{MAX_MOVES - used} left"

    marks = gr.update(visible=in_game and not over)
    if reset_marks:
        marks = gr.update(visible=in_game and not over, value=DIGITS)

    history_md = history_table(s["history"])
    again_label = "🔄 Try this code again" if s["mode"] == "room" else "🔄 New game"

    return [
        s,
        gr.update(visible=not in_game),  # menu
        gr.update(visible=in_game),  # game
        badge,
        header,
        marks,
        gr.update(visible=in_game and not over),  # guess row
        msg,
        gr.update(value=history_md, visible=used > 0),
        gr.update(visible=over or used > 0, value=again_label),
        "",  # clear the guess box
    ]


# ---------- event handlers ----------

def on_start_solo():
    return view(game_state("solo", new_code()), reset_marks=True)


def on_create_room(secret_in):
    secret_in = (secret_in or "").strip()
    error = validate(secret_in)
    if error:
        return f"**{error}**", ""
    code = create_room(secret_in)
    return (
        f"Room created. Send this room code to your friend:\n\n## `{code}`\n\n"
        "They open this app, choose **Join a game**, and enter it. "
        "Rooms are cleared after 24 hours or when the app restarts."
    ), ""


def on_join(room_in):
    code = (room_in or "").strip().upper()
    if len(code) != 4:
        return view(fresh_state()) + ["**Room codes have 4 characters.**", ""]
    secret = lookup_room(code)
    if secret is None:
        return view(fresh_state()) + [
            "**Room not found.** Check the code, or ask your friend to set a new one "
            "(rooms are cleared when the app restarts).",
            "",
        ]
    return view(game_state("room", secret, code), reset_marks=True) + ["", ""]


def on_guess(s, guess_in):
    if s["mode"] == "menu" or s["status"] != "playing":
        return view(s)
    guess = (guess_in or "").strip()
    error = validate(guess, [h[0] for h in s["history"]])
    if error:
        return view(s, f"**{error}**")
    right_place, right_number = score(s["secret"], guess)
    s = {**s, "history": s["history"] + [(guess, right_place, right_number)]}
    used = len(s["history"])
    if guess == s["secret"]:
        s["status"] = "won"
        msg = (
            f"🎉 **{win_message(used)}**\n\nThe code was **{s['secret']}**. "
            f"You cracked it in {used} move(s)."
        )
    elif used >= MAX_MOVES:
        s["status"] = "lost"
        msg = f"**Out of moves!** The code was **{s['secret']}**. Better luck next time."
    else:
        msg = hint_message(right_number)
    return view(s, msg)


def on_again(s):
    if s["mode"] == "room":
        return view(game_state("room", s["secret"], s["room_code"]), reset_marks=True)
    return view(game_state("solo", new_code()), reset_marks=True)


def on_menu(s):
    return view(fresh_state())


# ---------- UI ----------

# Mobile first: everything is a single narrow column. On wider screens the page grows and the
# game splits into two panes (controls on the left, feedback and history on the right).
CSS = """
.gradio-container {
    max-width: 32rem !important;
    margin: 0 auto !important;
    padding-left: 0.75rem !important;
    padding-right: 0.75rem !important;
}
#menu { max-width: 32rem; margin: 0 auto; }
#history table { width: 100%; table-layout: fixed; }
#history th, #history td { text-align: center; word-break: break-word; }
#marks label { min-width: 2.6rem; justify-content: center; }

/* Inputs at 16px+ so iOS Safari does not zoom the page when a field is focused. */
#guess_in input, #guess_in textarea,
#room_in input, #room_in textarea,
#secret_in input, #secret_in textarea {
    font-size: 1.25rem !important;
    letter-spacing: 0.25em;
    text-align: center;
}
#room_in input, #room_in textarea { text-transform: uppercase; }

/* Touch screens: bigger tap targets. */
@media (pointer: coarse) {
    button { min-height: 3rem; font-size: 1.05rem !important; }
    #marks label { min-width: 3rem; min-height: 3rem; font-size: 1.1rem; }
    #marks .wrap { gap: 0.4rem; }
}

/* Small phones: tighter spacing, smaller table text. */
@media (max-width: 480px) {
    .gradio-container { padding-left: 0.5rem !important; padding-right: 0.5rem !important; }
    h1 { font-size: 1.6rem !important; }
    #history table { font-size: 0.8rem; }
    #history th, #history td { padding: 0.3rem 0.2rem; }
}

/* Laptops and desktops: use the extra width. */
@media (min-width: 900px) {
    .gradio-container { max-width: 60rem !important; }
    #game_panes { gap: 1.5rem; }
    #marks label { min-width: 2.4rem; }
}
"""

# Show the numeric keypad on phones for the digit and room-code fields, and turn off
# autocorrect/autocomplete so the browser does not interfere with guesses.
HEAD = """
<script>
(function () {
    const FIELDS = {
        guess_in: { inputmode: "numeric", pattern: "[1-9]*" },
        secret_in: { inputmode: "numeric", pattern: "[1-9]*" },
        room_in: { inputmode: "text", autocapitalize: "characters" },
    };
    function apply() {
        for (const [id, attrs] of Object.entries(FIELDS)) {
            const el = document.querySelector("#" + id + " input, #" + id + " textarea");
            if (!el) continue;
            el.setAttribute("autocomplete", "off");
            el.setAttribute("autocorrect", "off");
            el.setAttribute("spellcheck", "false");
            for (const [k, v] of Object.entries(attrs)) el.setAttribute(k, v);
        }
    }
    new MutationObserver(apply).observe(document.documentElement, { childList: true, subtree: true });
    window.addEventListener("load", apply);
})();
</script>
"""

with gr.Blocks(title="Crack the Code") as demo:
    state = gr.State(fresh_state())

    gr.Markdown("# 🔐 Crack the Code")

    # ----- menu -----
    with gr.Column(visible=True, elem_id="menu") as menu_col:
        gr.Markdown(
            "Guess a secret 4-digit code in **10 moves**. No repeats and no zeroes. "
            "Play alone, or set a code for a friend."
        )
        with gr.Tabs():
            with gr.Tab("Play solo"):
                gr.Markdown("I'll make up a random code.")
                solo_btn = gr.Button("Start", variant="primary")
            with gr.Tab("Set a code"):
                gr.Markdown(
                    "Pick a secret code for a friend to guess. You'll get a room code to send them. "
                    "They can join from any device."
                )
                secret_in = gr.Textbox(
                    label="Your secret code",
                    type="password",
                    max_length=4,
                    placeholder="4 digits, 1-9, no repeats",
                    elem_id="secret_in",
                )
                create_btn = gr.Button("Create room", variant="primary")
                set_out = gr.Markdown()
            with gr.Tab("Join a game"):
                gr.Markdown("Enter the room code your friend sent you.")
                room_in = gr.Textbox(
                    label="Room code", max_length=4, placeholder="e.g. KQ7M", elem_id="room_in"
                )
                join_btn = gr.Button("Join", variant="primary")
                join_out = gr.Markdown()

    # ----- game -----
    with gr.Column(visible=False) as game_col:
        badge = gr.Markdown()
        gr.Markdown(
            "The code has 4 digits: **no repeats and no zeroes**. "
            f"Guess it in **{MAX_MOVES} moves** or you lose. "
            "Good luck, HAHAHAHAHA!!!"
        )
        header = gr.Markdown()

        # Two panes side by side on wide screens; they stack automatically on narrow ones.
        with gr.Row(equal_height=False, elem_id="game_panes"):
            with gr.Column(scale=1, min_width=280):
                marks = gr.CheckboxGroup(
                    choices=DIGITS,
                    value=DIGITS,
                    label="Still possible",
                    info="Untick a digit to cross it off. This is only a note for you.",
                    elem_id="marks",
                    interactive=True,  # outputs-only components default to read-only; this one is a personal notepad
                )
                with gr.Column(visible=True) as guess_row:
                    guess_in = gr.Textbox(
                        label="Your guess",
                        max_length=4,
                        placeholder="e.g. 1234",
                        elem_id="guess_in",
                    )
                    guess_btn = gr.Button("Guess", variant="primary")
            with gr.Column(scale=1, min_width=280):
                msg = gr.Markdown()
                history = gr.Markdown(visible=False, elem_id="history")

        again_btn = gr.Button("🔄 New game", visible=False)
        menu_btn = gr.Button("Back to menu")
        with gr.Accordion("How hints work", open=False):
            gr.Markdown(
                "- **Right place**: digits that are correct *and* in the correct position.\n"
                "- **Right number**: digits that are in the code at all (in any position).\n"
                "- Right place is always ≤ right number."
            )

    VIEW_OUTPUTS = [
        state, menu_col, game_col, badge, header, marks, guess_row, msg, history, again_btn, guess_in,
    ]

    solo_btn.click(on_start_solo, None, VIEW_OUTPUTS)
    create_btn.click(on_create_room, secret_in, [set_out, secret_in])
    secret_in.submit(on_create_room, secret_in, [set_out, secret_in])
    join_btn.click(on_join, room_in, VIEW_OUTPUTS + [join_out, room_in])
    room_in.submit(on_join, room_in, VIEW_OUTPUTS + [join_out, room_in])
    guess_btn.click(on_guess, [state, guess_in], VIEW_OUTPUTS)
    guess_in.submit(on_guess, [state, guess_in], VIEW_OUTPUTS)
    again_btn.click(on_again, state, VIEW_OUTPUTS)
    menu_btn.click(on_menu, state, VIEW_OUTPUTS)

if __name__ == "__main__":
    demo.launch(css=CSS, head=HEAD)