use bevy::ecs::system::RunSystemOnce;
use pomomon_garden::features::config::components::GameConfig;
use pomomon_garden::features::grid::components::{Grid, TileState};
use pomomon_garden::features::inventory::components::{Inventory, ItemStack, ItemType};
use pomomon_garden::features::phase::components::SessionTracker;
use pomomon_garden::features::pom::actions::InteractionAction;
use pomomon_garden::prelude::*;

mod common;
use common::setup_app;

#[test]
fn test_water_crop() {
    let seed_type = ItemType::BerrySeed {
        name: "TestSeed".into(),
    };
    let mut app = setup_app(
        3,
        3,
        &[(
            1,
            1,
            TileState::Occupied {
                seed: seed_type.clone(),
                watered: false,
                growth_stage: 0,
                withered: false,
                dry_counter: 0,
            },
        )],
        vec![],
        None,
    );

    // Verify Water option is available
    let _ = app.world_mut().run_system_once(
        move |grid: Res<Grid>,
              tile_query: Query<&TileState>,
              inventory: Res<Inventory>,
              item_query: Query<&ItemStack>,
              game_config: Res<GameConfig>| {
            let tile_entity = grid.get_tile((1, 1)).unwrap();
            let tile_state = tile_query.get(tile_entity).unwrap();
            let options =
                InteractionAction::list_options(tile_state, &inventory, item_query, &game_config);

            assert!(
                options.contains(&InteractionAction::Water),
                "Water option should be available"
            );
        },
    );

    // Execute Water
    let _ = app.world_mut().run_system_once(
        move |grid: Res<Grid>,
              mut tile_query: Query<&mut TileState>,
              mut inventory: ResMut<Inventory>,
              mut item_stack_query: Query<&mut ItemStack>,
              mut commands: Commands,
              game_config: Res<GameConfig>,
              mut session_tracker: ResMut<SessionTracker>| {
            let action = InteractionAction::Water;
            action.execute(
                (1, 1),
                &grid,
                &mut tile_query,
                &mut inventory,
                &mut item_stack_query,
                &mut commands,
                &game_config,
                &mut session_tracker,
            );
        },
    );

    app.update();

    // Assert Tile State Watered
    let grid = app.world().resource::<Grid>();
    let tile_entity = grid.get_tile((1, 1)).unwrap();
    let tile_state = app.world().entity(tile_entity).get::<TileState>().unwrap();

    if let TileState::Occupied { watered, .. } = tile_state {
        assert!(watered, "Tile should be watered");
    } else {
        panic!("Tile should be Occupied, found {:?}", tile_state);
    }

    // Verify Water option is NOT available
    let _ = app.world_mut().run_system_once(
        move |grid: Res<Grid>,
              tile_query: Query<&TileState>,
              inventory: Res<Inventory>,
              item_query: Query<&ItemStack>,
              game_config: Res<GameConfig>| {
            let tile_entity = grid.get_tile((1, 1)).unwrap();
            let tile_state = tile_query.get(tile_entity).unwrap();
            let options =
                InteractionAction::list_options(tile_state, &inventory, item_query, &game_config);

            assert!(
                !options.contains(&InteractionAction::Water),
                "Water option should NOT be available"
            );
        },
    );
}