//! Procedural card rendering.
//!
//! Each card is a parent entity with a coloured body `Sprite` and a child
//! `Text2d` showing rank+suit. Entities are synced with `GameStateResource`
//! on every `StateChangedEvent`: missing cards are spawned, present cards
//! are repositioned/updated in place, and stale cards are despawned.
//!
//! Phase 3 uses ASCII rank letters ("A", "2"…"10", "J", "Q", "K") and ASCII
//! suit letters ("C", "D", "H", "S") so rendering does not depend on the
//! bundled font carrying Unicode suit glyphs. When real card art lands in a
//! later phase, this plugin is replaced — the `CardEntity` marker and the
//! "sync on StateChangedEvent" contract stay the same.

use std::collections::{HashMap, HashSet};

use bevy::color::Color;
use bevy::prelude::*;
use solitaire_core::card::{Card, Rank, Suit};
use solitaire_core::game_state::{DrawMode, GameState};
use solitaire_core::pile::PileType;

use solitaire_core::rules::{can_place_on_foundation, can_place_on_tableau};

use crate::animation_plugin::{CardAnim, EffectiveSlideDuration};
use crate::events::{CardFaceRevealedEvent, CardFlippedEvent, StateChangedEvent};
use crate::game_plugin::GameMutation;
use crate::layout::{Layout, LayoutResource};
use crate::pause_plugin::PausedResource;
use crate::resources::{DragState, GameStateResource};
use crate::settings_plugin::{SettingsChangedEvent, SettingsResource};
use crate::table_plugin::PileMarker;

/// Fraction of card height used as vertical offset between face-up tableau cards.
pub const TABLEAU_FAN_FRAC: f32 = 0.25;

/// Tighter fan for face-down cards in the tableau — just enough to show the stack.
const TABLEAU_FACEDOWN_FAN_FRAC: f32 = 0.12;

/// Fraction of card height used as a tiny offset between stacked cards in
/// non-tableau piles, so stacking is visible.
const STACK_FAN_FRAC: f32 = 0.003;

/// Font size as a fraction of card width.
const FONT_SIZE_FRAC: f32 = 0.28;

pub const CARD_FACE_COLOUR: Color = Color::srgb(0.98, 0.98, 0.95);
pub const RED_SUIT_COLOUR: Color = Color::srgb(0.78, 0.12, 0.15);
pub const BLACK_SUIT_COLOUR: Color = Color::srgb(0.08, 0.08, 0.08);

/// Alternative face tint for red-suit cards in color-blind mode — a subtle
/// blue wash that distinguishes them from black-suit cards without colour alone.
const CARD_FACE_COLOUR_RED_CBM: Color = Color::srgba(0.85, 0.92, 1.0, 1.0);

/// Returns the card back color for the given unlocked card-back index.
/// Index 0 = default blue; 1–4 are unlockable alternate designs.
fn card_back_colour(selected_card_back: usize) -> Color {
    match selected_card_back {
        0 => Color::srgb(0.15, 0.30, 0.55), // default blue
        1 => Color::srgb(0.55, 0.10, 0.10), // deep red
        2 => Color::srgb(0.05, 0.40, 0.10), // forest green
        3 => Color::srgb(0.35, 0.08, 0.52), // purple
        _ => Color::srgb(0.05, 0.40, 0.42), // teal (4+)
    }
}

/// Marker component linking a Bevy entity to a `solitaire_core::Card::id`.
#[derive(Component, Debug, Clone, Copy)]
pub struct CardEntity {
    pub card_id: u32,
}

/// Marker for the text child inside a card entity.
#[derive(Component, Debug)]
pub struct CardLabel;

/// Marker component indicating the card is currently highlighted as a hint.
/// `remaining` counts down in real seconds; the highlight is removed when it
/// reaches zero and the card sprite colour is restored to its normal value.
#[derive(Component, Debug, Clone)]
pub struct HintHighlight {
    /// Seconds remaining before the highlight is cleared.
    pub remaining: f32,
}

/// Countdown (seconds) until the `HintHighlight` on a card entity is removed.
///
/// Inserted alongside `HintHighlight` by the hint-visual system. When the timer
/// reaches zero both `HintHighlight` and `HintHighlightTimer` are removed from
/// the entity and the sprite colour is restored.
#[derive(Component, Debug, Clone)]
pub struct HintHighlightTimer(pub f32);

/// Marker on a `PileMarker` entity that is highlighted because the right-clicked
/// card can legally be placed there.
#[derive(Component, Debug)]
pub struct RightClickHighlight;

/// Countdown (seconds) until this right-click destination highlight despawns.
///
/// Inserted alongside `RightClickHighlight` so that highlights auto-clear after
/// 1.5 s even if the player does not make a move or click again. The existing
/// clear-on-state-change and clear-on-pause logic still fires early when
/// appropriate.
#[derive(Component, Debug, Clone)]
pub struct RightClickHighlightTimer(pub f32);

/// Marker placed on the child `Text2d` entity that shows "↺" on the stock pile
/// marker when the stock pile is empty.
#[derive(Component, Debug)]
pub struct StockEmptyLabel;

// ---------------------------------------------------------------------------
// Task #34 — Card-flip animation
// ---------------------------------------------------------------------------

/// Phase of the two-stage flip animation.
#[derive(Debug, Clone, PartialEq)]
pub enum FlipPhase {
    /// Scale X from 1.0 → 0.0 (hiding the back face).
    ScalingDown,
    /// Scale X from 0.0 → 1.0 (revealing the front face).
    ScalingUp,
}

/// Drives a 2-phase "card flip" animation on `CardEntity` entities.
///
/// The animation squashes X to 0, swaps the sprite to the face-up colour,
/// then expands X back to 1. Total duration is `2 × FLIP_HALF_SECS`.
#[derive(Component, Debug, Clone)]
pub struct CardFlipAnim {
    /// Seconds elapsed in the current phase.
    pub timer: f32,
    /// Which half of the flip we are in.
    pub phase: FlipPhase,
}

/// Duration of each half of the flip animation (scale-down or scale-up).
const FLIP_HALF_SECS: f32 = 0.08;

// ---------------------------------------------------------------------------
// Task #38 — Drag-elevation shadow
// ---------------------------------------------------------------------------

/// Marker component for the semi-transparent shadow sprite shown while dragging.
#[derive(Component, Debug)]
pub struct ShadowEntity;

/// Renders cards by reading `GameStateResource` on `StateChangedEvent`.
pub struct CardPlugin;

impl Plugin for CardPlugin {
    fn build(&self, app: &mut App) {
        // PostStartup ensures TablePlugin's Startup system has inserted
        // LayoutResource before we try to read it.
        //
        // `handle_right_click` reads `ButtonInput<MouseButton>`. Under
        // `MinimalPlugins` (tests) this resource is absent by default, so we
        // ensure it exists here. Under `DefaultPlugins` the call is a no-op.
        app.init_resource::<ButtonInput<MouseButton>>()
            .add_event::<SettingsChangedEvent>()
            .add_event::<CardFlippedEvent>()
            .add_event::<CardFaceRevealedEvent>()
            .add_systems(PostStartup, (sync_cards_startup, update_stock_empty_indicator_startup))
            .add_systems(
                Update,
                (
                    sync_cards_on_change.after(GameMutation),
                    resync_cards_on_settings_change.before(sync_cards_on_change),
                    start_flip_anim.after(GameMutation),
                    tick_flip_anim,
                    update_drag_shadow,
                    tick_hint_highlight,
                    handle_right_click,
                    tick_right_click_highlights,
                    clear_right_click_highlights_on_state_change.after(GameMutation),
                    clear_right_click_highlights_on_pause,
                    update_stock_empty_indicator.after(GameMutation),
                ),
            );
    }
}

/// When card-back selection changes in Settings, re-render all cards so the
/// new back colour is applied immediately (without waiting for a state change).
fn resync_cards_on_settings_change(
    mut setting_events: EventReader<SettingsChangedEvent>,
    mut state_events: EventWriter<StateChangedEvent>,
) {
    if setting_events.read().next().is_some() {
        state_events.write(StateChangedEvent);
    }
}

/// Render the initial deal. Runs in `PostStartup`, so all `Startup` systems
/// (including `TablePlugin::setup_table` which inserts `LayoutResource`)
/// have already completed.
fn sync_cards_startup(
    commands: Commands,
    game: Res<GameStateResource>,
    layout: Option<Res<LayoutResource>>,
    slide_dur: Option<Res<EffectiveSlideDuration>>,
    settings: Option<Res<SettingsResource>>,
    entities: Query<(Entity, &CardEntity, &Transform)>,
) {
    if let Some(layout) = layout {
        let slide_secs = slide_dur.map_or(0.15, |d| d.slide_secs);
        let back_colour = settings
            .as_ref()
            .map_or_else(|| card_back_colour(0), |s| card_back_colour(s.0.selected_card_back));
        let color_blind = settings.as_ref().is_some_and(|s| s.0.color_blind_mode);
        sync_cards(commands, &game.0, &layout.0, slide_secs, back_colour, color_blind, &entities);
    }
}

fn sync_cards_on_change(
    mut events: EventReader<StateChangedEvent>,
    commands: Commands,
    game: Res<GameStateResource>,
    layout: Option<Res<LayoutResource>>,
    slide_dur: Option<Res<EffectiveSlideDuration>>,
    settings: Option<Res<SettingsResource>>,
    entities: Query<(Entity, &CardEntity, &Transform)>,
) {
    if events.read().next().is_none() {
        return;
    }
    if let Some(layout) = layout {
        let slide_secs = slide_dur.map_or(0.15, |d| d.slide_secs);
        let back_colour = settings
            .as_ref()
            .map_or_else(|| card_back_colour(0), |s| card_back_colour(s.0.selected_card_back));
        let color_blind = settings.as_ref().is_some_and(|s| s.0.color_blind_mode);
        sync_cards(commands, &game.0, &layout.0, slide_secs, back_colour, color_blind, &entities);
    }
}

fn sync_cards(
    mut commands: Commands,
    game: &GameState,
    layout: &Layout,
    slide_secs: f32,
    back_colour: Color,
    color_blind: bool,
    entities: &Query<(Entity, &CardEntity, &Transform)>,
) {
    let positions = card_positions(game, layout);

    // Map card_id -> (Entity, current_translation) for in-place updates.
    let mut existing: HashMap<u32, (Entity, Vec3)> = HashMap::new();
    for (entity, marker, transform) in entities.iter() {
        existing.insert(marker.card_id, (entity, transform.translation));
    }

    let live_ids: HashSet<u32> = positions.iter().map(|(c, _, _)| c.id).collect();

    // Despawn any entity whose card is no longer tracked.
    for (card_id, (entity, _)) in &existing {
        if !live_ids.contains(card_id) {
            commands.entity(*entity).despawn();
        }
    }

    // For each card in the current state: spawn or update its entity.
    for (card, position, z) in positions {
        match existing.get(&card.id) {
            Some(&(entity, cur)) => {
                update_card_entity(
                    &mut commands, entity, &card, position, z, layout,
                    slide_secs, back_colour, color_blind, cur,
                )
            }
            None => spawn_card_entity(&mut commands, &card, position, z, layout, back_colour, color_blind),
        }
    }
}

/// Returns an ordered vec of (card, position, z) for every card in the game.
fn card_positions(game: &GameState, layout: &Layout) -> Vec<(Card, Vec2, f32)> {
    let mut out: Vec<(Card, Vec2, f32)> = Vec::with_capacity(52);
    let piles = [
        PileType::Stock,
        PileType::Waste,
        PileType::Foundation(Suit::Clubs),
        PileType::Foundation(Suit::Diamonds),
        PileType::Foundation(Suit::Hearts),
        PileType::Foundation(Suit::Spades),
        PileType::Tableau(0),
        PileType::Tableau(1),
        PileType::Tableau(2),
        PileType::Tableau(3),
        PileType::Tableau(4),
        PileType::Tableau(5),
        PileType::Tableau(6),
    ];

    for pile_type in piles {
        let Some(base) = layout.pile_positions.get(&pile_type) else {
            continue;
        };
        let Some(pile) = game.piles.get(&pile_type) else {
            continue;
        };
        let is_tableau = matches!(pile_type, PileType::Tableau(_));
        let is_waste = matches!(pile_type, PileType::Waste);

        // Tableau uses a two-speed fan: face-down cards are packed tighter
        // than face-up cards so the visible (playable) portion stands out.
        // Non-tableau piles stack with a negligible offset.
        //
        // Waste pile: only the top N cards are rendered to prevent bleed-through
        // while new cards animate in from the stock. Draw-One shows 1; Draw-Three
        // shows up to 3 fanned in X (matching the standard Klondike presentation).
        let cards = &pile.cards;
        let render_start = if is_waste {
            let visible = match game.draw_mode {
                DrawMode::DrawOne => 1_usize,
                DrawMode::DrawThree => 3_usize,
            };
            cards.len().saturating_sub(visible)
        } else {
            0
        };

        let mut y_offset = 0.0_f32;
        for (slot, card) in cards[render_start..].iter().enumerate() {
            let x_offset = if is_waste && matches!(game.draw_mode, DrawMode::DrawThree) {
                // Fan left→right; top card (last slot) is rightmost and playable.
                slot as f32 * layout.card_size.x * 0.28
            } else {
                0.0
            };
            let pos = Vec2::new(base.x + x_offset, base.y + y_offset);
            let z = 1.0 + (slot as f32) * STACK_FAN_FRAC;
            out.push((card.clone(), pos, z));
            if is_tableau {
                let step = if card.face_up {
                    TABLEAU_FAN_FRAC
                } else {
                    TABLEAU_FACEDOWN_FAN_FRAC
                };
                y_offset -= layout.card_size.y * step;
            }
        }
    }
    out
}

/// Returns the appropriate face-up body colour for a card.
///
/// In color-blind mode, red-suit cards receive a subtle blue tint
/// (`CARD_FACE_COLOUR_RED_CBM`) so they are distinguishable from black-suit
/// cards without relying on the text colour alone.
fn face_colour(card: &Card, color_blind: bool) -> Color {
    if color_blind && card.suit.is_red() {
        CARD_FACE_COLOUR_RED_CBM
    } else {
        CARD_FACE_COLOUR
    }
}

fn spawn_card_entity(commands: &mut Commands, card: &Card, pos: Vec2, z: f32, layout: &Layout, back_colour: Color, color_blind: bool) {
    let body_colour = if card.face_up {
        face_colour(card, color_blind)
    } else {
        back_colour
    };

    commands
        .spawn((
            CardEntity { card_id: card.id },
            Sprite {
                color: body_colour,
                custom_size: Some(layout.card_size),
                ..default()
            },
            Transform::from_xyz(pos.x, pos.y, z),
            Visibility::default(),
        ))
        .with_children(|b| {
            b.spawn((
                CardLabel,
                Text2d::new(label_for(card)),
                TextFont {
                    font_size: layout.card_size.x * FONT_SIZE_FRAC,
                    ..default()
                },
                TextColor(text_colour(card)),
                // Above the card body on z so it doesn't get occluded by the
                // parent sprite in back-to-front rendering.
                Transform::from_xyz(0.0, 0.0, 0.01),
                label_visibility(card),
            ));
        });
}

#[allow(clippy::too_many_arguments)]
fn update_card_entity(
    commands: &mut Commands,
    entity: Entity,
    card: &Card,
    pos: Vec2,
    z: f32,
    layout: &Layout,
    slide_secs: f32,
    back_colour: Color,
    color_blind: bool,
    cur: Vec3,
) {
    let body_colour = if card.face_up {
        face_colour(card, color_blind)
    } else {
        back_colour
    };

    let target = Vec3::new(pos.x, pos.y, z);

    // Always refresh the visual appearance.
    commands.entity(entity).insert(Sprite {
        color: body_colour,
        custom_size: Some(layout.card_size),
        ..default()
    });

    // Slide to the new position when it differs meaningfully; snap otherwise.
    if (cur.truncate() - target.truncate()).length() > 1.0 && slide_secs > 0.0 {
        let start = Vec3::new(cur.x, cur.y, z); // update Z immediately
        commands
            .entity(entity)
            .insert(Transform::from_translation(start))
            .insert(CardAnim {
                start,
                target,
                elapsed: 0.0,
                duration: slide_secs,
                delay: 0.0,
            });
    } else {
        commands
            .entity(entity)
            .remove::<CardAnim>()
            .insert(Transform::from_xyz(pos.x, pos.y, z));
    }

    // Despawn the old label child and respawn a fresh one, so rank/suit/
    // colour/visibility all stay in sync with the card's current state.
    commands.entity(entity).despawn_related::<Children>();
    commands.entity(entity).with_children(|b| {
        b.spawn((
            CardLabel,
            Text2d::new(label_for(card)),
            TextFont {
                font_size: layout.card_size.x * FONT_SIZE_FRAC,
                ..default()
            },
            TextColor(text_colour(card)),
            Transform::from_xyz(0.0, 0.0, 0.01),
            label_visibility(card),
        ));
    });
}

fn label_for(card: &Card) -> String {
    let rank = match card.rank {
        Rank::Ace => "A",
        Rank::Two => "2",
        Rank::Three => "3",
        Rank::Four => "4",
        Rank::Five => "5",
        Rank::Six => "6",
        Rank::Seven => "7",
        Rank::Eight => "8",
        Rank::Nine => "9",
        Rank::Ten => "10",
        Rank::Jack => "J",
        Rank::Queen => "Q",
        Rank::King => "K",
    };
    let suit = match card.suit {
        Suit::Clubs => "C",
        Suit::Diamonds => "D",
        Suit::Hearts => "H",
        Suit::Spades => "S",
    };
    format!("{rank}{suit}")
}

fn text_colour(card: &Card) -> Color {
    if card.suit.is_red() {
        RED_SUIT_COLOUR
    } else {
        BLACK_SUIT_COLOUR
    }
}

fn label_visibility(card: &Card) -> Visibility {
    if card.face_up {
        Visibility::Inherited
    } else {
        Visibility::Hidden
    }
}

// ---------------------------------------------------------------------------
// Task #34 — Card-flip animation systems
// ---------------------------------------------------------------------------

/// Listens for `CardFlippedEvent` and inserts a `CardFlipAnim` on the entity.
///
/// Skipped when `EffectiveSlideDuration::slide_secs == 0.0` (Instant speed).
fn start_flip_anim(
    mut events: EventReader<CardFlippedEvent>,
    slide_dur: Option<Res<EffectiveSlideDuration>>,
    mut commands: Commands,
    card_entities: Query<(Entity, &CardEntity)>,
) {
    if slide_dur.is_some_and(|d| d.slide_secs == 0.0) {
        // Instant animation speed — skip the flip effect entirely.
        events.clear();
        return;
    }

    for CardFlippedEvent(card_id) in events.read() {
        for (entity, marker) in &card_entities {
            if marker.card_id == *card_id {
                commands.entity(entity).insert(CardFlipAnim {
                    timer: 0.0,
                    phase: FlipPhase::ScalingDown,
                });
                break;
            }
        }
    }
}

/// Advances `CardFlipAnim` each frame, modifying `Transform::scale.x`.
///
/// - Phase `ScalingDown`: lerps scale.x from 1.0 → 0.0 over `FLIP_HALF_SECS`.
/// - At the midpoint the phase switches to `ScalingUp`, scale.x resets to 0,
///   and a `CardFaceRevealedEvent` is fired so audio plays in sync with the reveal.
/// - Phase `ScalingUp`:  lerps scale.x from 0.0 → 1.0 over `FLIP_HALF_SECS`.
/// - When complete the component is removed and scale.x is restored to 1.0.
fn tick_flip_anim(
    mut commands: Commands,
    time: Res<Time>,
    mut anims: Query<(Entity, &CardEntity, &mut Transform, &mut CardFlipAnim)>,
    mut reveal_events: EventWriter<CardFaceRevealedEvent>,
) {
    let dt = time.delta_secs();
    for (entity, card_entity, mut transform, mut anim) in &mut anims {
        anim.timer += dt;
        match anim.phase {
            FlipPhase::ScalingDown => {
                let t = (anim.timer / FLIP_HALF_SECS).min(1.0);
                transform.scale.x = 1.0 - t;
                if t >= 1.0 {
                    anim.phase = FlipPhase::ScalingUp;
                    anim.timer = 0.0;
                    transform.scale.x = 0.0;
                    // Fire the reveal event exactly once, at the phase transition,
                    // so the flip sound is synchronised with the visual face reveal.
                    reveal_events.write(CardFaceRevealedEvent(card_entity.card_id));
                }
            }
            FlipPhase::ScalingUp => {
                let t = (anim.timer / FLIP_HALF_SECS).min(1.0);
                transform.scale.x = t;
                if t >= 1.0 {
                    transform.scale.x = 1.0;
                    commands.entity(entity).remove::<CardFlipAnim>();
                }
            }
        }
    }
}

// ---------------------------------------------------------------------------
// Task #38 — Drag-elevation shadow
// ---------------------------------------------------------------------------

/// Maintains a single `ShadowEntity` while cards are being dragged.
///
/// - If a drag is active, spawns (or repositions) a semi-transparent dark
///   sprite behind the top dragged card.
/// - If no drag is active, despawns the shadow entity.
fn update_drag_shadow(
    mut commands: Commands,
    drag: Res<DragState>,
    layout: Option<Res<LayoutResource>>,
    card_entities: Query<(&CardEntity, &Transform)>,
    mut shadow: Local<Option<Entity>>,
) {
    if drag.is_idle() {
        // No drag in progress — remove shadow if it exists.
        if let Some(e) = shadow.take() {
            commands.entity(e).despawn();
        }
        return;
    }

    let Some(layout) = layout else { return };
    let card_w = layout.0.card_size.x;
    let card_h = layout.0.card_size.y;

    // Find the world position of the first (top) dragged card.
    let first_id = drag.cards.first().copied();
    let top_pos = first_id.and_then(|id| {
        card_entities
            .iter()
            .find(|(marker, _)| marker.card_id == id)
            .map(|(_, t)| t.translation)
    });

    let Some(top_pos) = top_pos else { return };

    // Shadow is slightly larger, offset behind-and-below, at a z slightly
    // below the dragged cards.
    let shadow_pos = top_pos + Vec3::new(-4.0, 4.0, -1.0);

    match *shadow {
        Some(e) => {
            // Reposition the existing shadow.
            commands.entity(e).insert(Transform::from_translation(shadow_pos));
        }
        None => {
            // Spawn a new shadow sprite.
            let e = commands
                .spawn((
                    ShadowEntity,
                    Sprite {
                        color: Color::srgba(0.0, 0.0, 0.0, 0.35),
                        custom_size: Some(Vec2::new(card_w + 8.0, card_h + 8.0)),
                        ..default()
                    },
                    Transform::from_translation(shadow_pos),
                    Visibility::default(),
                ))
                .id();
            *shadow = Some(e);
        }
    }
}

// ---------------------------------------------------------------------------
// Task #28 — Hint highlight tick system
// ---------------------------------------------------------------------------

/// Counts down `HintHighlight::remaining` each frame. When it reaches zero,
/// removes both `HintHighlight` and `HintHighlightTimer` (if present) and
/// resets the card sprite to its normal face-up colour.
fn tick_hint_highlight(
    time: Res<Time>,
    mut commands: Commands,
    mut query: Query<(Entity, &mut HintHighlight, &mut Sprite, &CardEntity)>,
    game: Res<GameStateResource>,
    settings: Option<Res<SettingsResource>>,
) {
    let back_idx = settings.as_ref().map_or(0, |s| s.0.selected_card_back);
    for (entity, mut hint, mut sprite, card_entity) in query.iter_mut() {
        hint.remaining -= time.delta_secs();
        if hint.remaining <= 0.0 {
            // Restore normal face-up colour.
            let is_face_up = game.0.piles.values()
                .flat_map(|p| p.cards.iter())
                .find(|c| c.id == card_entity.card_id)
                .is_some_and(|c| c.face_up);
            sprite.color = if is_face_up {
                CARD_FACE_COLOUR
            } else {
                card_back_colour(back_idx)
            };
            commands
                .entity(entity)
                .remove::<HintHighlight>()
                .remove::<HintHighlightTimer>();
        }
    }
}

// ---------------------------------------------------------------------------
// Task #46 — Right-click legal destination highlights
// ---------------------------------------------------------------------------

/// Color applied to a `PileMarker` sprite when it is a legal destination for
/// the right-clicked card.
const RIGHT_CLICK_HIGHLIGHT_COLOUR: Color = Color::srgba(0.2, 0.8, 0.2, 0.6);
/// Restored color for `PileMarker` sprites when the highlight is cleared.
const PILE_MARKER_DEFAULT_COLOUR: Color = Color::srgba(1.0, 1.0, 1.0, 0.08);

/// Counts down `RightClickHighlightTimer` each frame and clears the highlight
/// when the timer expires.
///
/// This is a fallback expiry: highlights also clear immediately on
/// `StateChangedEvent` (move made) or when the game is paused, whichever comes
/// first. The 1.5 s timer ensures highlights always disappear even if the
/// player takes no further action.
fn tick_right_click_highlights(
    mut commands: Commands,
    time: Res<Time>,
    paused: Option<Res<PausedResource>>,
    mut highlights: Query<(Entity, &mut RightClickHighlightTimer, &mut Sprite), With<RightClickHighlight>>,
) {
    if paused.is_some_and(|p| p.0) {
        return;
    }
    let dt = time.delta_secs();
    for (entity, mut timer, mut sprite) in &mut highlights {
        timer.0 -= dt;
        if timer.0 <= 0.0 {
            // Restore the pile marker to its default colour before removing
            // the highlight marker component.
            sprite.color = PILE_MARKER_DEFAULT_COLOUR;
            commands
                .entity(entity)
                .remove::<RightClickHighlight>()
                .remove::<RightClickHighlightTimer>();
        }
    }
}

/// Removes the `RightClickHighlight` marker from every highlighted pile and
/// resets its sprite colour to `PILE_MARKER_DEFAULT_COLOUR`.
///
/// Shared by the on-state-change and on-pause clear systems to avoid
/// duplicating the removal logic.
fn clear_right_click_highlights(
    commands: &mut Commands,
    highlighted: &Query<Entity, With<RightClickHighlight>>,
    pile_markers: &mut Query<(Entity, &PileMarker, &mut Sprite)>,
) {
    for entity in highlighted.iter() {
        commands.entity(entity).remove::<RightClickHighlight>();
    }
    for (_entity, _, mut sprite) in pile_markers.iter_mut() {
        if sprite.color == RIGHT_CLICK_HIGHLIGHT_COLOUR {
            sprite.color = PILE_MARKER_DEFAULT_COLOUR;
        }
    }
}

/// Clears all right-click destination highlights whenever any game-state
/// mutation succeeds (`StateChangedEvent` fires).
///
/// This ensures stale highlights do not linger after a card is moved.
fn clear_right_click_highlights_on_state_change(
    mut events: EventReader<StateChangedEvent>,
    mut commands: Commands,
    highlighted: Query<Entity, With<RightClickHighlight>>,
    mut pile_markers: Query<(Entity, &PileMarker, &mut Sprite)>,
) {
    if events.read().next().is_none() {
        return;
    }
    clear_right_click_highlights(&mut commands, &highlighted, &mut pile_markers);
}

/// Clears all right-click destination highlights when the game is paused
/// (`PausedResource` changes to `true`).
///
/// Prevents highlighted pile markers from remaining visible behind the pause
/// overlay.
fn clear_right_click_highlights_on_pause(
    paused: Option<Res<PausedResource>>,
    mut commands: Commands,
    highlighted: Query<Entity, With<RightClickHighlight>>,
    mut pile_markers: Query<(Entity, &PileMarker, &mut Sprite)>,
) {
    let Some(paused) = paused else { return };
    if paused.is_changed() && paused.0 {
        clear_right_click_highlights(&mut commands, &highlighted, &mut pile_markers);
    }
}

/// Handles right-click: highlights legal destination piles for the clicked card,
/// and clears highlights on any subsequent right- or left-click.
///
/// This system lives in `CardPlugin` to keep `InputPlugin` untouched.
#[allow(clippy::too_many_arguments)]
fn handle_right_click(
    buttons: Option<Res<ButtonInput<MouseButton>>>,
    paused: Option<Res<PausedResource>>,
    drag: Res<DragState>,
    windows: Query<&Window, With<bevy::window::PrimaryWindow>>,
    cameras: Query<(&Camera, &GlobalTransform)>,
    layout: Option<Res<LayoutResource>>,
    game: Res<GameStateResource>,
    mut commands: Commands,
    mut pile_markers: Query<(Entity, &PileMarker, &mut Sprite)>,
    card_entities: Query<(Entity, &CardEntity, &Transform)>,
    highlighted: Query<Entity, With<RightClickHighlight>>,
) {
    if paused.is_some_and(|p| p.0) {
        return;
    }

    let Some(buttons) = buttons else { return };
    let left_pressed = buttons.just_pressed(MouseButton::Left);
    let right_pressed = buttons.just_pressed(MouseButton::Right);

    // Clear existing highlights on any click.
    if left_pressed || right_pressed {
        for entity in &highlighted {
            commands.entity(entity).remove::<RightClickHighlight>();
        }
        for (_entity, _, mut sprite) in &mut pile_markers {
            if sprite.color == RIGHT_CLICK_HIGHLIGHT_COLOUR {
                sprite.color = PILE_MARKER_DEFAULT_COLOUR;
            }
        }
    }

    // Only proceed for right-clicks while not dragging.
    if !right_pressed || !drag.is_idle() {
        return;
    }

    let Some(layout) = layout else { return };

    // Convert cursor to world-space position.
    let Some(world) = cursor_world_pos(&windows, &cameras) else { return };

    // Find the topmost face-up card under the cursor.
    let Some(card) = find_top_card_at(world, &game.0, &layout.0, &card_entities) else { return };

    // Tint piles that legally accept the card.
    for (entity, pile_marker, mut sprite) in &mut pile_markers {
        let pile_type = &pile_marker.0;
        let Some(pile) = game.0.piles.get(pile_type) else { continue };
        let legal = match pile_type {
            PileType::Foundation(suit) => {
                can_place_on_foundation(&card, pile, *suit)
            }
            PileType::Tableau(_) => can_place_on_tableau(&card, pile),
            _ => false,
        };
        if legal {
            sprite.color = RIGHT_CLICK_HIGHLIGHT_COLOUR;
            commands
                .entity(entity)
                .insert(RightClickHighlight)
                .insert(RightClickHighlightTimer(1.5));
        }
    }
}

/// Converts cursor position to 2-D world coordinates.
fn cursor_world_pos(
    windows: &Query<&Window, With<bevy::window::PrimaryWindow>>,
    cameras: &Query<(&Camera, &GlobalTransform)>,
) -> Option<Vec2> {
    let window = windows.single().ok()?;
    let cursor = window.cursor_position()?;
    let (camera, camera_transform) = cameras.single().ok()?;
    camera.viewport_to_world_2d(camera_transform, cursor).ok()
}

/// Returns the topmost face-up `Card` under `cursor` by checking axis-aligned
/// bounding rectangles of all card sprites, picking the highest Z.
fn find_top_card_at(
    cursor: Vec2,
    game: &GameState,
    layout: &Layout,
    card_entities: &Query<(Entity, &CardEntity, &Transform)>,
) -> Option<Card> {
    let half = layout.card_size / 2.0;
    let mut best: Option<(f32, Card)> = None;

    for (_, card_entity, transform) in card_entities.iter() {
        let pos = transform.translation.truncate();
        if cursor.x < pos.x - half.x
            || cursor.x > pos.x + half.x
            || cursor.y < pos.y - half.y
            || cursor.y > pos.y + half.y
        {
            continue;
        }
        let card = game
            .piles
            .values()
            .flat_map(|p| p.cards.iter())
            .find(|c| c.id == card_entity.card_id && c.face_up)
            .cloned();
        if let Some(card) = card {
            let z = transform.translation.z;
            if best.as_ref().is_none_or(|(bz, _)| z > *bz) {
                best = Some((z, card));
            }
        }
    }
    best.map(|(_, card)| card)
}

// ---------------------------------------------------------------------------
// Task #28 — Stock-empty visual indicator
// ---------------------------------------------------------------------------

/// Sprite colour applied to the stock `PileMarker` when the stock pile is empty,
/// to signal to the player that there are no more cards to draw.
const STOCK_EMPTY_DIM_COLOUR: Color = Color::srgba(1.0, 1.0, 1.0, 0.4);

/// Sprite colour applied to the stock `PileMarker` when cards remain in stock.
const STOCK_NORMAL_COLOUR: Color = Color::srgba(1.0, 1.0, 1.0, 0.08);

/// Shared logic for updating the stock pile marker's dim state and "↺" label.
///
/// If the stock pile is empty the marker sprite is dimmed to
/// `STOCK_EMPTY_DIM_COLOUR` and a child `Text2d` with `StockEmptyLabel` is
/// spawned (if not already present). When the stock is non-empty the marker is
/// restored to `STOCK_NORMAL_COLOUR` and any `StockEmptyLabel` children are
/// despawned.
fn apply_stock_empty_indicator(
    commands: &mut Commands,
    game: &GameState,
    pile_markers: &mut Query<(Entity, &PileMarker, &mut Sprite)>,
    label_children: &Query<(Entity, &ChildOf), With<StockEmptyLabel>>,
    layout: &Layout,
) {
    let stock_empty = game
        .piles
        .get(&PileType::Stock)
        .is_none_or(|p| p.cards.is_empty());

    for (entity, pile_marker, mut sprite) in pile_markers.iter_mut() {
        if pile_marker.0 != PileType::Stock {
            continue;
        }

        if stock_empty {
            // Dim the marker sprite.
            sprite.color = STOCK_EMPTY_DIM_COLOUR;

            // Spawn the "↺" label only if one does not already exist.
            let already_has_label = label_children
                .iter()
                .any(|(_, parent)| parent.parent() == entity);
            if !already_has_label {
                let font_size = layout.card_size.x * 0.4;
                commands.entity(entity).with_children(|b| {
                    b.spawn((
                        StockEmptyLabel,
                        Text2d::new("↺"),
                        TextFont { font_size, ..default() },
                        TextColor(Color::srgba(1.0, 1.0, 1.0, 0.7)),
                        Transform::from_xyz(0.0, 0.0, 0.1),
                    ));
                });
            }
        } else {
            // Restore normal brightness.
            sprite.color = STOCK_NORMAL_COLOUR;

            // Despawn any existing "↺" label children.
            for (label_entity, parent) in label_children.iter() {
                if parent.parent() == entity {
                    commands.entity(label_entity).despawn();
                }
            }
        }
    }
}

/// Runs at `PostStartup` to apply the stock-empty indicator for the initial
/// game state (before any `StateChangedEvent` fires).
fn update_stock_empty_indicator_startup(
    mut commands: Commands,
    game: Res<GameStateResource>,
    layout: Option<Res<LayoutResource>>,
    mut pile_markers: Query<(Entity, &PileMarker, &mut Sprite)>,
    label_children: Query<(Entity, &ChildOf), With<StockEmptyLabel>>,
) {
    let Some(layout) = layout else { return };
    apply_stock_empty_indicator(
        &mut commands,
        &game.0,
        &mut pile_markers,
        &label_children,
        &layout.0,
    );
}

/// Runs each `Update` tick when a `StateChangedEvent` arrives, keeping the
/// stock pile marker dim state and "↺" label in sync with the current stock.
fn update_stock_empty_indicator(
    mut events: EventReader<StateChangedEvent>,
    mut commands: Commands,
    game: Res<GameStateResource>,
    layout: Option<Res<LayoutResource>>,
    mut pile_markers: Query<(Entity, &PileMarker, &mut Sprite)>,
    label_children: Query<(Entity, &ChildOf), With<StockEmptyLabel>>,
) {
    if events.read().next().is_none() {
        return;
    }
    let Some(layout) = layout else { return };
    apply_stock_empty_indicator(
        &mut commands,
        &game.0,
        &mut pile_markers,
        &label_children,
        &layout.0,
    );
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::game_plugin::GamePlugin;
    use crate::table_plugin::TablePlugin;

    fn app() -> App {
        let mut app = App::new();
        app.add_plugins(MinimalPlugins)
            .add_plugins(GamePlugin)
            .add_plugins(TablePlugin)
            .add_plugins(CardPlugin);
        app.update();
        app
    }

    #[test]
    fn label_for_ace_of_hearts_is_ah() {
        let c = Card {
            id: 0,
            suit: Suit::Hearts,
            rank: Rank::Ace,
            face_up: true,
        };
        assert_eq!(label_for(&c), "AH");
    }

    #[test]
    fn label_for_ten_of_clubs_is_10c() {
        let c = Card {
            id: 0,
            suit: Suit::Clubs,
            rank: Rank::Ten,
            face_up: true,
        };
        assert_eq!(label_for(&c), "10C");
    }

    #[test]
    fn text_colour_is_red_for_hearts_and_diamonds() {
        let h = Card {
            id: 0,
            suit: Suit::Hearts,
            rank: Rank::Ace,
            face_up: true,
        };
        let d = Card {
            id: 0,
            suit: Suit::Diamonds,
            rank: Rank::Ace,
            face_up: true,
        };
        assert_eq!(text_colour(&h), RED_SUIT_COLOUR);
        assert_eq!(text_colour(&d), RED_SUIT_COLOUR);
    }

    #[test]
    fn text_colour_is_black_for_clubs_and_spades() {
        let c = Card {
            id: 0,
            suit: Suit::Clubs,
            rank: Rank::Ace,
            face_up: true,
        };
        let s = Card {
            id: 0,
            suit: Suit::Spades,
            rank: Rank::Ace,
            face_up: true,
        };
        assert_eq!(text_colour(&c), BLACK_SUIT_COLOUR);
        assert_eq!(text_colour(&s), BLACK_SUIT_COLOUR);
    }

    #[test]
    fn card_plugin_spawns_all_52_cards() {
        let mut app = app();
        let count = app
            .world_mut()
            .query::<&CardEntity>()
            .iter(app.world())
            .count();
        assert_eq!(count, 52);
    }

    #[test]
    fn tableau_face_down_cards_start_hidden_label() {
        let mut app = app();
        // Every tableau column except column 0 has face-down cards. Count
        // CardLabels with Visibility::Hidden — should equal 0+1+2+3+4+5+6 = 21
        // (every tableau card except the top of each column is face-down).
        let hidden_count = app
            .world_mut()
            .query::<(&CardLabel, &Visibility)>()
            .iter(app.world())
            .filter(|(_, v)| matches!(v, Visibility::Hidden))
            .count();
        // 21 tableau face-down + 24 stock face-down = 45.
        assert_eq!(hidden_count, 45);
    }

    #[test]
    fn state_changed_event_triggers_resync() {
        let mut app = app();
        // Trigger a draw, which moves a card from stock to waste and should
        // flip it face-up. Count visible labels after.
        app.world_mut().send_event(crate::events::DrawRequestEvent);
        app.update();
        // Now 1 card in waste (face-up), 23 in stock (face-down). So 24
        // hidden labels total in stock, plus 21 in tableau = 44.
        let hidden_count = app
            .world_mut()
            .query::<(&CardLabel, &Visibility)>()
            .iter(app.world())
            .filter(|(_, v)| matches!(v, Visibility::Hidden))
            .count();
        assert_eq!(hidden_count, 44);
    }

    #[test]
    fn card_positions_includes_all_52_cards_at_game_start() {
        // At game start waste is empty, so all 52 cards are across stock + tableau.
        let g = GameState::new(42, solitaire_core::game_state::DrawMode::DrawOne);
        let layout =
            crate::layout::compute_layout(Vec2::new(1280.0, 800.0));
        let positions = card_positions(&g, &layout);
        assert_eq!(positions.len(), 52);
    }

    #[test]
    fn waste_draw_one_only_renders_top_card() {
        use solitaire_core::game_state::DrawMode;
        let mut g = GameState::new(42, DrawMode::DrawOne);
        // Draw 3 cards so the waste pile has 3 cards.
        for _ in 0..3 {
            let _ = g.draw();
        }
        let waste_ids: std::collections::HashSet<u32> = g.piles[&PileType::Waste]
            .cards
            .iter()
            .map(|c| c.id)
            .collect();
        assert_eq!(waste_ids.len(), 3);

        let layout = crate::layout::compute_layout(Vec2::new(1280.0, 800.0));
        let positions = card_positions(&g, &layout);

        // Filter rendered positions to only waste cards (by card ID).
        let waste_rendered: Vec<_> = positions
            .iter()
            .filter(|(card, _, _)| waste_ids.contains(&card.id))
            .collect();
        // Draw-One: only 1 waste card should be rendered regardless of pile depth.
        assert_eq!(waste_rendered.len(), 1);
        // The single rendered card must be the top (last) waste card.
        let top_id = g.piles[&PileType::Waste].cards.last().unwrap().id;
        assert_eq!(waste_rendered[0].0.id, top_id);
    }

    #[test]
    fn waste_draw_three_renders_up_to_three_fanned_cards() {
        use solitaire_core::game_state::DrawMode;
        let mut g = GameState::new(42, DrawMode::DrawThree);
        // 5 draw() calls in Draw-Three mode accumulates multiple waste cards.
        for _ in 0..5 {
            let _ = g.draw();
        }
        let waste_pile = &g.piles[&PileType::Waste].cards;
        assert!(waste_pile.len() >= 3, "need at least 3 waste cards for this test");

        let waste_ids: std::collections::HashSet<u32> =
            waste_pile.iter().map(|c| c.id).collect();

        let layout = crate::layout::compute_layout(Vec2::new(1280.0, 800.0));
        let positions = card_positions(&g, &layout);

        let mut waste_rendered: Vec<_> = positions
            .iter()
            .filter(|(card, _, _)| waste_ids.contains(&card.id))
            .collect();
        // Draw-Three: at most 3 waste cards rendered.
        assert_eq!(waste_rendered.len(), 3);

        // The three fanned cards must have strictly increasing X coordinates
        // (left = oldest visible, right = top/playable).
        waste_rendered.sort_by(|a, b| a.1.x.partial_cmp(&b.1.x).unwrap());
        for w in waste_rendered.windows(2) {
            assert!(w[1].1.x > w[0].1.x, "fanned waste cards must have distinct X positions");
        }
        // Top card (rightmost) must be the last card in the waste pile.
        let top_id = waste_pile.last().unwrap().id;
        assert_eq!(waste_rendered.last().unwrap().0.id, top_id);
    }

    #[test]
    fn card_positions_tableau_cards_are_fanned_downward() {
        let g = GameState::new(42, solitaire_core::game_state::DrawMode::DrawOne);
        let layout =
            crate::layout::compute_layout(Vec2::new(1280.0, 800.0));
        let positions = card_positions(&g, &layout);

        // Collect positions for Tableau(6) (should have 7 cards).
        let tableau_6_base = layout.pile_positions[&PileType::Tableau(6)];
        let mut ys: Vec<f32> = positions
            .iter()
            .filter(|(_, pos, _)| (pos.x - tableau_6_base.x).abs() < 1e-3)
            .map(|(_, pos, _)| pos.y)
            .collect();
        ys.sort_by(|a, b| b.partial_cmp(a).unwrap());
        assert_eq!(ys.len(), 7);
        // Every subsequent card should be strictly lower.
        for w in ys.windows(2) {
            assert!(w[0] > w[1]);
        }
    }

    #[test]
    fn card_back_colour_known_indices_are_distinct() {
        // Indices 0–3 must each produce a unique colour.
        let colours: Vec<_> = (0..4).map(card_back_colour).collect();
        for i in 0..colours.len() {
            for j in (i + 1)..colours.len() {
                assert_ne!(colours[i], colours[j], "indices {i} and {j} must be distinct");
            }
        }
    }

    #[test]
    fn card_back_colour_out_of_range_does_not_panic() {
        // Indices >= 4 are beyond the defined set; the wildcard arm must handle them
        // without panicking and return the same teal fallback for all.
        let c4  = card_back_colour(4);
        let c5  = card_back_colour(5);
        let c99 = card_back_colour(99);
        assert_eq!(c4, c5,  "out-of-range indices must share the fallback colour");
        assert_eq!(c4, c99, "index 99 must share the fallback colour");
    }

    // -----------------------------------------------------------------------
    // Task #34 pure-function / phase-transition tests
    // -----------------------------------------------------------------------

    #[test]
    fn flip_phase_scaling_down_starts_at_one() {
        // A brand-new flip anim in ScalingDown at timer=0 should produce scale 1.0
        // (no time has elapsed yet).
        let t = 0.0_f32 / FLIP_HALF_SECS;
        let scale_x = 1.0 - t.min(1.0);
        assert!((scale_x - 1.0).abs() < 1e-6, "scale_x at timer=0 must be 1.0");
    }

    #[test]
    fn flip_phase_scaling_down_reaches_zero_at_half_secs() {
        let t = (FLIP_HALF_SECS / FLIP_HALF_SECS).min(1.0);
        let scale_x = 1.0 - t;
        assert!(scale_x.abs() < 1e-6, "scale_x must reach 0.0 after one half-period");
    }

    #[test]
    fn flip_phase_scaling_up_starts_at_zero() {
        let t = 0.0_f32 / FLIP_HALF_SECS;
        let scale_x = t.min(1.0);
        assert!(scale_x.abs() < 1e-6, "scale_x at start of ScalingUp must be 0.0");
    }

    #[test]
    fn flip_phase_scaling_up_reaches_one_at_half_secs() {
        let t = (FLIP_HALF_SECS / FLIP_HALF_SECS).min(1.0);
        let scale_x = t;
        assert!((scale_x - 1.0).abs() < 1e-6, "scale_x must reach 1.0 after second half-period");
    }

    #[test]
    fn flip_phase_enum_equality() {
        assert_eq!(FlipPhase::ScalingDown, FlipPhase::ScalingDown);
        assert_eq!(FlipPhase::ScalingUp, FlipPhase::ScalingUp);
        assert_ne!(FlipPhase::ScalingDown, FlipPhase::ScalingUp);
    }

    // -----------------------------------------------------------------------
    // Task #5 — RightClickHighlightTimer pure-function tests
    // -----------------------------------------------------------------------

    /// Verify that a freshly-created timer with 1.5 s has a positive countdown
    /// and has not yet expired.
    #[test]
    fn right_click_highlight_timer_starts_positive() {
        let timer = RightClickHighlightTimer(1.5);
        assert!(
            timer.0 > 0.0,
            "timer must start with a positive countdown, got {}",
            timer.0
        );
    }

    /// Simulate ticking the timer by a delta that exceeds its initial value and
    /// verify the resulting value is ≤ 0 (expiry condition).
    #[test]
    fn right_click_highlight_timer_expires_after_sufficient_ticks() {
        let mut remaining = 1.5_f32;
        // Tick by more than the initial value to ensure expiry.
        remaining -= 2.0;
        assert!(
            remaining <= 0.0,
            "timer must be expired (≤ 0) after 2.0 s tick on a 1.5 s timer, got {}",
            remaining
        );
    }

    /// Simulate ticking by less than the initial value and verify the timer is
    /// still positive (not yet expired).
    #[test]
    fn right_click_highlight_timer_not_expired_before_duration() {
        let mut remaining = 1.5_f32;
        remaining -= 0.5; // only 0.5 s elapsed
        assert!(
            remaining > 0.0,
            "timer must still be positive after only 0.5 s on a 1.5 s timer, got {}",
            remaining
        );
    }

    #[test]
    fn facedown_cards_use_tighter_fan_than_uniform_faceup_fan() {
        let g = GameState::new(42, solitaire_core::game_state::DrawMode::DrawOne);
        let layout = crate::layout::compute_layout(Vec2::new(1280.0, 800.0));
        let positions = card_positions(&g, &layout);

        // Tableau(6) has 7 cards: 6 face-down + 1 face-up on top.
        // Each face-down card contributes TABLEAU_FACEDOWN_FAN_FRAC to the column span.
        // Total span should be 6 * FACEDOWN < 6 * TABLEAU_FAN_FRAC (the old uniform value).
        let col6_base = layout.pile_positions[&PileType::Tableau(6)];
        let mut col6_ys: Vec<f32> = positions
            .iter()
            .filter(|(_, pos, _)| (pos.x - col6_base.x).abs() < 1e-3)
            .map(|(_, pos, _)| pos.y)
            .collect();
        col6_ys.sort_by(|a, b| b.partial_cmp(a).unwrap());
        assert_eq!(col6_ys.len(), 7);
        let actual_span = col6_ys[0] - col6_ys[6];
        let uniform_span = 6.0 * TABLEAU_FAN_FRAC * layout.card_size.y;
        assert!(
            actual_span < uniform_span,
            "tighter face-down fan should reduce column span ({actual_span:.1} >= uniform {uniform_span:.1})"
        );
    }
}