"""Normal story AP sweep. Reference: baas-reference/module/explore_tasks/sweep_task.py
and task_utils.py.

Ported per CLAUDE.md's "OCR policy" and Handoff.md: sweeps a config-driven
list of exact (region, stage, count) targets (config.STORY_SWEEP_TARGETS),
navigating to each one deterministically instead of the previous "latest
unlocked region, then a random stage" heuristic -- see plan.md Phase 9's
retrospective for why that heuristic was a mistake.

`_rotation_target` adds a second, date-derived target on top of that static
list, per explicit user direction: rather than grinding one fixed stage in
their current last region every run, it cycles through that region's stages
one per day (a plain date-ordinal modulo, so the cycle doesn't skip or
repeat around a year boundary). See config.py's STORY_SWEEP_ROTATION_*
constants.

- `_go_to_region` ports task_utils.py::to_region: OCR the current region
  number, click the exact delta, re-check, bounded loop.
- `_find_stage_row` is a scoped-down port of core/image.py's
  swipe_search_target_str: OCR each visible stage row's label and match it
  against the configured target, rather than grabbing a random row.
- `_watch_sweep_result` is built on navigation.wait_for_state, this
  project's scoped port of core/picture.py::co_detect, and returns a named
  outcome ("swept", "inadequate_ap", "unrecognized_state", ...) the way the
  reference's start_sweep does, instead of a single generic "Done".

The MAX-button click-then-verify and the modal's own X-button close (both
calibrated and confirmed live in Phase 9) are reused unchanged -- see
plan.md Phase 9/10.

**2026-07-21 rewrite**: this module predates story_sweep_hard.py's own live
debugging (plan.md Phase 21), which found several real bugs in patterns this
module had originally established and story_sweep_hard.py had copied
verbatim. Per explicit user direction ("match the hard implementation on
best practices"), the same fixes are applied here too, even though most were
never actually triggered in production (this module's own
config.STORY_SWEEP_TARGETS is empty by default, so historically only one
rotation target ever ran per invocation -- never enough iterations to expose
a multi-target bug):

- An explicit Normal-tab guard (`_open_normal_tab`, config.NORMAL_TAB) and a
  loop-level self-heal (`_ensure_task_screen`), replacing the removed
  per-path "if on subscreen, press Escape" cleanup that used to fire after
  *every* target (success or abort) and would back all the way out of the
  region browser -- confirmed live as a real bug in story_sweep_hard.py,
  same copied code here. The Normal-tab guard is new, not just a bugfix:
  story_sweep_hard.py can now run earlier in the same `q4h` preset sequence
  and leave the Hard tab selected, which this module never had to account
  for before both tasks coexisted.
- `_click_max`/`_click_plus` no longer require the sweep count to visibly
  rise above 1 as proof a click landed -- low AP can legitimately cap the
  count at its floor, which is visually indistinguishable from "the click
  didn't register." `_click_plus` also now forces a known baseline via
  `_click_min` before applying "+" raises, porting bounty.py's own
  `_click_min_and_verify` fix for a stepper that remembers its last-used
  value across opens (see CLAUDE.md/plan.md Phase 15) -- this module's
  original `_click_plus_and_verify` never did that, a latent version of the
  exact overspend risk bounty.py hit for real.
- `_confirm_dialog_is_sweep` OCR-verifies the confirm dialog's own text
  before the one irreversible click, closing the same two-stacked-button
  hazard (cyan 掃討開始 directly above a gold 任務開始 real-battle button)
  config.py's own SWEEP_MAX_BUTTON comment already documented for this
  exact tabbed modal layout but this module never actually guarded against.
- `_watch_sweep_result` gained the same `clicked_any`-gated second `ends`
  condition event_sweep.py/story_sweep_hard.py needed: the post-sweep flow
  can land back on the bare region browser instead of leaving the modal
  open, which the original "swept" condition required.
- `_read_current_region` retries a None OCR read a couple of times before
  giving up, matching story_sweep_hard.py's own REGION_READ_RETRIES fix for
  a transient render/settle race confirmed live on the same region browser.
- A campaign-active guard, genuinely new (no reference equivalent -- see
  story_sweep_hard.py's own docstring for why): refuses to spend AP unless
  the pink "キャンペーン中" reward-campaign banner is showing for the Normal
  tab specifically (config.TASK_CAMPAIGN_BADGE_RECT, shared with
  story_sweep_hard.py's own check -- pixel-identical rect/color, confirmed
  live 2026-07-21, only the tab name in the banner text differs). Pass
  force=True (wired to the `story_sweep_force` CLI command) to bypass it.
"""
import datetime

from ba_auto import detector, navigation

OPEN_RETRIES = 3
NORMAL_TAB_RETRIES = 3
POST_SWEEP_DISMISS_ROUNDS = 6
STAGE_MODAL_DIM_MAX_CHANNEL = 150
MODAL_CLOSE_RETRIES = 3
REGION_READ_RETRIES = 3


def _is_stage_modal_open(driver, config):
    r, g, b = driver.color_at(*config.STAGE_MODAL_PROBE)
    return r < STAGE_MODAL_DIM_MAX_CHANNEL and g < STAGE_MODAL_DIM_MAX_CHANNEL and b < STAGE_MODAL_DIM_MAX_CHANNEL


def _color_in_range(rgb, rgb_range):
    lo, hi = rgb_range
    r, g, b = rgb
    return lo[0] <= r <= hi[0] and lo[1] <= g <= hi[1] and lo[2] <= b <= hi[2]


def _is_sweep_usage_confirm(driver, config):
    # 掃討開始 always raises a "use N AP to sweep M times?" confirmation
    # before actually sweeping. Its OK button is this bright cyan.
    return _color_in_range(driver.color_at(*config.SWEEP_CONFIRM_BUTTON), config.SWEEP_CONFIRM_CYAN)


def _is_ap_purchase_prompt(driver, config):
    # If AP is too low for even one sweep, a visually similar dialog appears
    # at the *same* OK-button position but titled "AP購入" (spend real
    # Pyroxene to buy more AP) with a gold/yellow OK instead of cyan --
    # confirmed live by deliberately emptying the sweep count at low AP.
    # Told apart from the safe confirm above by color, not position.
    return _color_in_range(driver.color_at(*config.SWEEP_CONFIRM_BUTTON), config.SWEEP_CONFIRM_GOLD)


def _confirm_dialog_is_sweep(driver, config):
    """OCR-verify the confirm dialog reached after clicking 掃討開始 is
    genuinely the sweep-usage confirm ("APをN使用して、掃討をN回行いますか？"),
    not some other cyan-styled confirmation that happens to satisfy
    _is_sweep_usage_confirm's color-only check -- ports bounty.py's own
    _confirm_dialog_is_sweep fix (see that module and story_sweep_hard.py for
    the hazard class this guards against: this exact tabbed modal has a gold
    任務開始 "start mission" button directly beneath the cyan 掃討開始 one,
    both showing an identical AP-cost preview -- see config.py's
    SWEEP_MAX_BUTTON comment). Reuses config.BOUNTY_SWEEP_CONFIRM_TEXT_RECT
    directly, confirmed live to crop this modal's confirm text correctly too
    since it's the same shared "通知" dialog component. Substring match on
    "掃討" rather than an exact match, matching this project's own
    established dialog-classification convention.
    """
    text = detector.read_text(config.BOUNTY_SWEEP_CONFIRM_TEXT_RECT, psm=6, lang="jpn")
    return "掃討" in text


def _find_result_button(driver, config):
    # The "掃討完了" (sweep complete) results screen shows a SKIP button
    # (skips the reward-reveal animation) and then, once settled, a final
    # OK button -- both the same cyan as the usage-confirm OK, but ~120px
    # apart vertically. Finding whichever is showing by color avoids
    # hardcoding both positions.
    return detector.find_color_centroid(config.SWEEP_RESULT_BUTTON_REGION, *config.SWEEP_CONFIRM_CYAN)


def _open_task_screen(driver, config):
    for attempt in range(1, OPEN_RETRIES + 1):
        driver.click(*config.WORK_ICON)
        driver.wait(2)
        if navigation.is_on_subscreen(driver):
            break
        print(f"[story_sweep] work hub not detected after click (attempt {attempt}/{OPEN_RETRIES})")
    else:
        return False

    for attempt in range(1, OPEN_RETRIES + 1):
        driver.click(*config.TASK_CARD)
        driver.wait(2)
        if navigation.is_on_subscreen(driver):
            return True
        print(f"[story_sweep] task screen not detected after click (attempt {attempt}/{OPEN_RETRIES})")
    return False


def _open_normal_tab(driver, config):
    for attempt in range(1, NORMAL_TAB_RETRIES + 1):
        driver.click(*config.NORMAL_TAB)
        driver.wait(1)
        if _color_in_range(driver.color_at(*config.NORMAL_TAB_ACTIVE_PROBE), config.NORMAL_TAB_ACTIVE_RGB):
            return True
        print(f"[story_sweep] Normal tab not confirmed active (attempt {attempt}/{NORMAL_TAB_RETRIES})")
    return False


def _campaign_active(driver, config):
    return detector.region_contains_color(config.TASK_CAMPAIGN_BADGE_RECT, *config.TASK_CAMPAIGN_BADGE_RGB)


def _ensure_task_screen(driver, config):
    """Re-verify we're still on the task screen's Normal tab before each
    target, self-healing from any navigation drift between targets the same
    way ba_daily.py's own _ensure_home does before each task, and the same
    way story_sweep_hard.py's own _ensure_hard_screen does between its
    targets -- see that function's docstring for the real incident this
    pattern was built to fix (a leftover per-path Escape press that backed
    out of the region browser after every single target).
    """
    if _color_in_range(driver.color_at(*config.NORMAL_TAB_ACTIVE_PROBE), config.NORMAL_TAB_ACTIVE_RGB):
        return True
    print("[story_sweep] task screen (Normal tab) not confirmed before target -- re-opening")
    return _open_task_screen(driver, config) and _open_normal_tab(driver, config)


def _read_current_region(driver, config):
    """OCR the current region number, retrying a None read a couple of times
    before giving up -- matching story_sweep_hard.py's own fix for a
    transient render/settle race confirmed live on this same region browser
    (a screenshot that read as None was, moments later, confirmed by eye to
    be a perfectly clean and legible digit).
    """
    for attempt in range(1, REGION_READ_RETRIES + 1):
        cur = detector.read_int(config.REGION_NUMBER_OCR_RECT)
        if cur is not None:
            return cur
        if attempt < REGION_READ_RETRIES:
            driver.wait(1)
    return None


def _region_arrow_visible(driver, config, center):
    # Both arrows render as a solid navy-blue "<"/">" chevron on a
    # light-blue backdrop when present. The last region in a given direction
    # (or a locked one, per the reference's own "region-unavailable"
    # template check) simply omits the arrow rather than greying it out --
    # confirmed live: at region 30 (this account's current last region), the
    # spot where the right arrow would be was plain background.
    #
    # Scans a small box around `center` rather than probing a single fixed
    # point: a chevron is concave, and a centroid-derived single point
    # landed in the notch between its two strokes -- reading as "absent"
    # even while the glyph was clearly rendered a few pixels away. See
    # plan.md Phase 10.
    cx, cy = center
    rect = (cx - 40, cy - 35, cx + 40, cy + 35)
    return detector.region_contains_color(rect, (40, 70, 120), (100, 130, 190))


def _go_to_region(driver, config, target_region):
    cur = _read_current_region(driver, config)
    if cur is None:
        print("[story_sweep] could not OCR the current region number")
        return False
    print(f"[story_sweep] current region {cur}, target region {target_region}")

    for attempt in range(1, config.REGION_NAV_MAX_ATTEMPTS + 1):
        if cur == target_region:
            return True
        going_left = cur > target_region
        arrow_pos = config.REGION_LEFT_ARROW if going_left else config.REGION_RIGHT_ARROW
        if not _region_arrow_visible(driver, config, arrow_pos):
            direction = "left" if going_left else "right"
            print(f"[story_sweep] region {target_region} unreachable -- no {direction} arrow at region {cur}")
            return False

        clicks = abs(cur - target_region)
        for _ in range(clicks):
            driver.click(*arrow_pos)
        driver.wait(1)

        new_cur = _read_current_region(driver, config)
        if new_cur is None or new_cur == cur:
            print(f"[story_sweep] region number unchanged after {clicks} click(s) (attempt {attempt}/{config.REGION_NAV_MAX_ATTEMPTS})")
            return False
        cur = new_cur

    print(f"[story_sweep] gave up navigating to region {target_region} after {config.REGION_NAV_MAX_ATTEMPTS} attempts")
    return False


def _normalize_label(text):
    # OCR sometimes reads the row's dash as a different dash-like glyph, or
    # picks up stray whitespace -- normalize before comparing.
    return text.strip().upper().replace("—", "-").replace("–", "-").replace(" ", "")


def _label_suffix(label):
    # Compare only the part after the dash (e.g. "2" in "30-2", "A" in
    # "30-A"), not the full "{region}-{stage}" string. Confirmed live: this
    # font's leading region-number digit is read unreliably by OCR (e.g. "3"
    # misread as "2") even after threshold preprocessing, while the stage
    # suffix after the dash reads correctly across every row tested -- and we
    # don't need the region digit anyway, since _go_to_region has already
    # independently confirmed we're in the right region. See plan.md Phase 10.
    parts = [p for p in _normalize_label(label).split("-") if p]
    return parts[-1] if parts else ""


def _row_label_rect(config, row_y):
    x1, x2 = config.STAGE_LABEL_OCR_X
    top_pad, bottom_pad = config.STAGE_LABEL_OCR_Y_PAD
    return (x1, row_y - top_pad, x2, row_y - bottom_pad)


def _find_stage_row(driver, config, region, stage):
    # Scoped-down swipe_search_target_str (see module docstring): this
    # client's stage list only ever needs the two already-calibrated scroll
    # extremes checked, not arbitrary swipe-and-retry.
    target_suffix = str(stage)
    x, y = config.STAGE_LIST_SCROLL_POINT

    driver.scroll(x, y, "up", config.STAGE_LIST_SCROLL_CLICKS)
    driver.wait(0.5)
    for row_y in config.STAGE_ROWS_AT_TOP_Y:
        label = detector.read_text(_row_label_rect(config, row_y), whitelist="0123456789-A")
        print(f"[story_sweep] row @ {row_y} (scrolled up): read '{label}'")
        if _label_suffix(label) == target_suffix:
            return row_y

    driver.scroll(x, y, "down", config.STAGE_LIST_SCROLL_CLICKS)
    driver.wait(0.5)
    for row_y in config.STAGE_ROWS_AT_BOTTOM_Y:
        label = detector.read_text(_row_label_rect(config, row_y), whitelist="0123456789-A")
        print(f"[story_sweep] row @ {row_y} (scrolled down): read '{label}'")
        if _label_suffix(label) == target_suffix:
            return row_y

    return None


def _click_min(driver, config):
    driver.click(*config.SWEEP_MIN_BUTTON)
    driver.wait(0.8)


def _click_max(driver, config):
    """Click the MAX button once. Deliberately does NOT require the sweep
    count to visibly rise above 1 as proof the click landed -- see
    story_sweep_hard.py's own _click_max for the real incident this fixes
    (low AP can legitimately cap the count at its floor, indistinguishable
    from "the click didn't register"; 11 real, affordable targets were
    wrongly skipped by the old verify-and-abort design in that module before
    this fix). The downstream confirm-dialog checks (_is_ap_purchase_prompt/
    _is_sweep_usage_confirm/_confirm_dialog_is_sweep) are the real safety net
    regardless of what the stepper visually showed here.
    """
    driver.click(*config.SWEEP_MAX_BUTTON)
    driver.wait(0.8)


def _click_plus(driver, config, count):
    """Raise the sweep count to an exact configured value via "+".

    Forces a known baseline of 1 via _click_min first -- the stepper
    remembers its last-used value across opens (confirmed live for real via
    bounty.py's own overspend incident, plan.md Phase 15/CLAUDE.md), so
    clicking "+" count-1 times on top of an unknown starting value could
    under- or over-shoot the intended count. This module's original
    _click_plus_and_verify never reset to a baseline first -- a latent
    version of the exact bug bounty.py hit for real, never triggered here
    only because config.STORY_SWEEP_TARGETS has always been empty in
    practice. Same as _click_max, does not require a visible post-click
    raise as proof of success.
    """
    _click_min(driver, config)
    for _ in range(count - 1):
        driver.click(*config.SWEEP_PLUS_BUTTON)
    driver.wait(0.8)


def _set_sweep_count(driver, config, count):
    if count == "max":
        _click_max(driver, config)
    else:
        _click_plus(driver, config, count)


def _close_stage_modal(driver, config):
    # Escape does not close this modal (confirmed live: it stayed open with
    # focus on the live "任務開始" button after two Escape presses) -- the
    # only reliable close path is clicking its own X button, verified.
    for _ in range(MODAL_CLOSE_RETRIES):
        if not _is_stage_modal_open(driver, config):
            return True
        driver.click(*config.STAGE_MODAL_CLOSE_BUTTON)
        driver.wait(1)
    return not _is_stage_modal_open(driver, config)


def _watch_sweep_result(driver, config):
    """Confirmed live 2026-07-20/21 (story_sweep_hard.py, plan.md Phase 21)
    that this shared modal's post-sweep flow can land all the way back on
    the bare region browser instead of leaving the 任務情報 modal open --
    the same terminal-state gap event_sweep.py hit historically. Ports
    event_sweep.py's/story_sweep_hard.py's own `clicked_any`-gated second
    `ends` condition: only treat "no modal, no result button" as "swept"
    once we've actually clicked through at least one result-screen button,
    so an immediate read on the very first check (before any SKIP/OK
    sequence has started) still can't be mistaken for a genuine completion.
    """
    clicked_any = {"value": False}

    def click_result_button(d):
        pos = _find_result_button(d, config)
        if pos:
            d.click(*pos)
            clicked_any["value"] = True
        d.wait(1.5)

    ends = {
        (lambda d, c: _is_stage_modal_open(d, c) and _find_result_button(d, c) is None): "swept",
        (lambda d, c: clicked_any["value"] and not _is_stage_modal_open(d, c) and _find_result_button(d, c) is None): "swept",
    }
    reactions = {
        (lambda d, c: _find_result_button(d, c) is not None): click_result_button,
    }
    outcome = navigation.wait_for_state(
        driver, config, reactions, ends,
        max_iterations=POST_SWEEP_DISMISS_ROUNDS, poll_interval=1.5,
    )
    return outcome or "unrecognized_state"


def _sweep_target(driver, config, region, stage, count):
    print(f"[story_sweep] --- target {region}-{stage} x {count} ---")

    if not _go_to_region(driver, config, region):
        return "region_unavailable"

    row_y = _find_stage_row(driver, config, region, stage)
    if row_y is None:
        print(f"[story_sweep] stage {region}-{stage} not found in the visible stage list")
        return "stage_not_found"

    driver.click(config.STAGE_ENTER_X, row_y)
    driver.wait(2)

    if not _is_stage_modal_open(driver, config):
        print("[story_sweep] stage info panel not detected, aborting")
        return "unrecognized_state"

    _set_sweep_count(driver, config, count)

    driver.click(*config.SWEEP_START_BUTTON)
    driver.wait(1.5)

    if _is_ap_purchase_prompt(driver, config):
        print("[story_sweep] insufficient AP for this sweep -- cancelling without purchasing")
        driver.click(*config.SWEEP_CONFIRM_CANCEL_BUTTON)
        driver.wait(1)
        _close_stage_modal(driver, config)
        return "inadequate_ap"

    if not _is_sweep_usage_confirm(driver, config):
        print("[story_sweep] sweep-usage confirmation not detected, aborting without further input")
        _close_stage_modal(driver, config)
        return "unrecognized_state"

    # Hard safety gate before the one irreversible click in this whole flow
    # -- see module docstring / bounty.py's own real incident. Color already
    # matched above (_is_sweep_usage_confirm); verify the actual dialog text
    # too before committing rather than trusting color alone.
    if not _confirm_dialog_is_sweep(driver, config):
        print("[story_sweep] confirm dialog text did not read as a sweep confirmation -- cancelling without confirming")
        driver.click(*config.SWEEP_CONFIRM_CANCEL_BUTTON)
        driver.wait(1)
        _close_stage_modal(driver, config)
        return "unrecognized_state"

    driver.click(*config.SWEEP_CONFIRM_BUTTON)
    driver.wait(1.5)
    print("[story_sweep] sweep confirmed, waiting for results")
    outcome = _watch_sweep_result(driver, config)
    print(f"[story_sweep] result: {outcome}")

    if not _close_stage_modal(driver, config):
        print("[story_sweep] warning: could not confirm stage info modal closed -- leaving it open rather than pressing further keys blindly")
    return outcome


def _rotation_target(config):
    region = getattr(config, "STORY_SWEEP_ROTATION_REGION", None)
    if not region:
        return None
    stage_count = config.STORY_SWEEP_ROTATION_STAGE_COUNT
    stage = (datetime.date.today().toordinal() % stage_count) + 1
    return (region, stage, config.STORY_SWEEP_ROTATION_COUNT)


def run(driver, config, force=False):
    driver.focus_game()

    ap = navigation.current_ap(driver)
    if ap is not None and ap < config.SWEEP_MIN_AP:
        print(f"[story_sweep] current AP ({ap}) is below the minimum ({config.SWEEP_MIN_AP}) -- skipping, nothing to do")
        return

    targets = list(config.STORY_SWEEP_TARGETS)
    rotation = _rotation_target(config)
    if rotation:
        print(f"[story_sweep] today's rotation target: region {rotation[0]} stage {rotation[1]}")
        targets.append(rotation)

    if not targets:
        print("[story_sweep] no targets configured (config.STORY_SWEEP_TARGETS is empty and rotation is disabled), nothing to do")
        return

    if not _open_task_screen(driver, config):
        print("[story_sweep] could not confirm task screen is open, aborting without pressing further keys")
        return

    if not _open_normal_tab(driver, config):
        print("[story_sweep] could not confirm Normal tab is selected, aborting without pressing further keys")
        return

    if force:
        print("[story_sweep] force=True -- skipping campaign check")
    else:
        if not _campaign_active(driver, config):
            print("[story_sweep] no active Normal-task reward campaign detected -- skipping sweep (run story_sweep_force to override)")
            return
        print("[story_sweep] campaign confirmed active, proceeding")

    for region, stage, count in targets:
        if not _ensure_task_screen(driver, config):
            print(f"[story_sweep] could not confirm/recover the task screen before target {region}-{stage} -- stopping")
            break
        outcome = _sweep_target(driver, config, region, stage, count)
        if outcome == "inadequate_ap":
            print("[story_sweep] insufficient AP -- stopping, not attempting remaining targets")
            break
        if outcome != "swept":
            print(f"[story_sweep] target {region}-{stage} ended in '{outcome}' -- skipping to next target")

    print("[story_sweep] Done.")