// Bevy basically forces "complex types" with Querys
#![allow(clippy::type_complexity)]

use games::*;

// *TODO: Detect when piece is going to go out of bounds and restirct parent from moving there
// TODO: When shape touches the rest of the pieces, re-parent to line entity
// TODO: When line is "full" (has 10 children) clear line and add to score

fn main() {
    App::new()
        .add_plugins(BaseGamePlugin {
            name: "falling-block-adventure".into(),
            target_resolution: (640.0, 480.0).into(),
            game_type: GameType::Two,
            ..default()
        })
        .init_state::<Falling>()
        .add_systems(Startup, (init_world, init_debug_ui))
        .add_systems(
            Update,
            (
                kb_input.run_if(on_event::<KeyboardInput>),
                falling
                    .run_if(in_state(Falling::On))
                    .run_if(clock_cycle(1.0)),
                update_shape_blocks
                    .run_if(any_component_added::<Shape>.or(any_component_changed::<Shape>)),
                sync_singleton_to_ui::<Shape>.run_if(any_component_changed::<Shape>),
                sync_singleton_to_ui::<Orientation>.run_if(any_component_changed::<Orientation>),
                update_position,
                add_piece.run_if(not(any_with_component::<Shape>)),
                clear_line.run_if(any_component_changed::<LineBlocks>),
            ),
        )
        .add_systems(Update, draw_grid)
        .add_observer(deactive_shape)
        .run();
}

const SCALE: f32 = 30.0;

// Declare the size of the play area
const X_MAX: u32 = 10;
const Y_MAX: u32 = 20;

// The blocks making up this shape
#[derive(Component)]
#[relationship_target(relationship = ShapeBlock)]
struct ShapeBlocks(Vec<Entity>);

/// A part of a piece, i.e., a single square of a piece
#[derive(Component, Debug)]
#[relationship(relationship_target = ShapeBlocks)]
struct ShapeBlock {
    #[relationship]
    shape: Entity,
}

// The blocks making up this shape
#[derive(Component, Default)]
#[relationship_target(relationship = LineBlock)]
struct LineBlocks(Vec<Entity>);

/// A part of a piece, i.e., a single square of a piece
#[derive(Component, Debug)]
#[require(Transform, Visibility)]
#[relationship(relationship_target = LineBlocks)]
struct LineBlock {
    #[relationship]
    line: Entity,
}

// A line holds up to 10 blocks before being cleared
#[derive(Component, Debug)]
struct Line(u8);

// Just marks a block either of a shape or line
#[derive(Component, Debug)]
struct Block;

#[derive(Component, Debug, Clone, Copy, PartialEq)]
#[require(Transform, Visibility)]
struct GridPosition {
    x: u32,
    y: u32,
}

impl GridPosition {
    fn with_offset(self, other_x: isize, other_y: isize) -> Result<GridPosition, GameError> {
        let x = self.x as isize + other_x;
        let y = self.y as isize + other_y;

        if x >= X_MAX as isize {
            Err(GameError::OutOfBoundsLeft)
        } else if x < 0 {
            Err(GameError::OutOfBoundsRight)
        } else if y < 0 {
            Err(GameError::OutOfBoundsDown)
        } else {
            Ok(GridPosition {
                x: x as u32,
                y: y as u32,
            })
        }
    }
}

impl Display for GridPosition {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "({},{})", self.x, self.y)
    }
}

#[derive(Error, Debug, PartialEq)]
enum GameError {
    #[error("Coordinates are out of bounds: Left")]
    OutOfBoundsLeft,
    #[error("Coordinates are out of bounds: Right")]
    OutOfBoundsRight,
    #[error("Coordinates are out of bounds: Down")]
    OutOfBoundsDown,
    #[error("Coordiante collision")]
    Collision,
}

impl Default for GridPosition {
    fn default() -> Self {
        GridPosition { x: 5, y: Y_MAX }
    }
}

impl From<&GridPosition> for Vec3 {
    fn from(GridPosition { x, y }: &GridPosition) -> Vec3 {
        // Grid Positions start in the bottom left of the area
        // So (0, 0) is the bottom left, (0, 9) is the bottom right, etc

        let x_0 = -SCALE * 5.0 + (0.5 * SCALE);
        let x = x_0 + ((*x as f32) * SCALE);

        let y_0 = -SCALE * 10.0 + (0.5 * SCALE);
        let y = y_0 + ((*y as f32) * SCALE);
        Vec3::new(x, y, 0.0)
    }
}

impl From<(u32, u32)> for GridPosition {
    fn from((x, y): (u32, u32)) -> GridPosition {
        GridPosition { x, y }
    }
}

impl std::ops::Add for GridPosition {
    type Output = Self;

    fn add(self, GridPosition { x: x2, y: y2 }: Self) -> Self {
        GridPosition {
            x: self.x + x2,
            y: self.y + y2,
        }
    }
}

impl std::ops::AddAssign<&GridPosition> for GridPosition {
    fn add_assign(&mut self, rhs: &GridPosition) {
        *self = *self + *rhs;
    }
}

#[derive(Component, Default, Event, Clone, Debug)]
enum Orientation {
    #[default]
    Up,
    Left,
    Down,
    Right,
}

impl Orientation {
    fn next(&self) -> Self {
        match self {
            Self::Up => Self::Left,
            Self::Left => Self::Down,
            Self::Down => Self::Right,
            Self::Right => Self::Up,
        }
    }

    fn prev(&self) -> Self {
        match self {
            Self::Up => Self::Right,
            Self::Right => Self::Down,
            Self::Down => Self::Left,
            Self::Left => Self::Up,
        }
    }
}

impl Display for Orientation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Orientation::Up => write!(f, "up"),
            Orientation::Down => write!(f, "down"),
            Orientation::Left => write!(f, "<-"),
            Orientation::Right => write!(f, "->"),
        }
    }
}

#[derive(States, Clone, Eq, PartialEq, Debug, Hash, Default, Component)]
enum Falling {
    #[default]
    On,
    Off,
}

#[derive(Resource, Debug)]
struct Visuals {
    material: Handle<ColorMaterial>,
    mesh: Handle<Mesh>,
}

fn init_world(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
) {
    commands.insert_resource(Visuals {
        material: materials.add(ColorMaterial {
            color: WHITE.into(),
            ..default()
        }),
        mesh: meshes.add(Rectangle::new(SCALE, SCALE)),
    });

    (0..20).for_each(|i| {
        commands.spawn((Line(i), LineBlocks::default()));
    });
}

fn init_debug_ui(mut commands: Commands) {
    commands
        .spawn((
            Node {
                top: Val::Px(0.0),
                left: Val::Px(0.0),
                ..default()
            },
            DebuggingState::On,
        ))
        .with_children(|parent| {
            parent.spawn((
                Node::default(),
                children![
                    (Text::new("SHAPE"), SyncSingleton::<Shape>::default()),
                    (
                        Text::new("ORIENTATION"),
                        SyncSingleton::<Orientation>::default()
                    ),
                ],
            ));
        });
}

#[derive(Component, Debug, Clone, Copy)]
enum Shape {
    M4(Mat4),
    M3(Mat3),
}

impl Default for Shape {
    fn default() -> Self {
        Self::new_t()
    }
}

impl Display for Shape {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_ascii())
    }
}

impl Shape {
    fn from_mat4(input: Mat4) -> Self {
        Self::M4(input)
    }

    fn from_mat3(input: Mat3) -> Self {
        Self::M3(input)
    }

    fn new_o() -> Self {
        Self::from_mat4(Mat4::from_cols_array_2d(&[
            [0., 0., 0., 0.],
            [0., 1., 1., 0.],
            [0., 1., 1., 0.],
            [0., 0., 0., 0.],
        ]))
    }

    fn new_t() -> Self {
        Self::from_mat3(Mat3::from_cols_array_2d(&[
            [0., 1., 0.],
            [1., 1., 1.],
            [0., 0., 0.],
        ]))
    }

    fn new_l() -> Self {
        Self::from_mat4(Mat4::from_cols_array_2d(&[
            [0., 0., 0., 0.],
            [0., 1., 0., 0.],
            [0., 1., 0., 0.],
            [0., 1., 1., 0.],
        ]))
    }

    fn new_j() -> Self {
        Self::from_mat4(Mat4::from_cols_array_2d(&[
            [0., 0., 0., 0.],
            [0., 0., 1., 0.],
            [0., 0., 1., 0.],
            [0., 1., 1., 0.],
        ]))
    }

    fn new_s() -> Self {
        Self::from_mat4(Mat4::from_cols_array_2d(&[
            [0., 0., 0., 0.],
            [0., 1., 1., 0.],
            [1., 1., 0., 0.],
            [0., 0., 0., 0.],
        ]))
    }

    fn new_z() -> Self {
        Self::from_mat4(Mat4::from_cols_array_2d(&[
            [0., 0., 0., 0.],
            [1., 1., 0., 0.],
            [0., 1., 1., 0.],
            [0., 0., 0., 0.],
        ]))
    }

    fn new_i() -> Self {
        Self::from_mat4(Mat4::from_cols_array_2d(&[
            [0., 0., 1., 0.],
            [0., 0., 1., 0.],
            [0., 0., 1., 0.],
            [0., 0., 1., 0.],
        ]))
    }

    // Rotates 90 degrees to the right
    // https://stackoverflow.com/a/8664879
    fn rotated(&self) -> Self {
        match self {
            Self::M4(inner) => {
                let mut new_self = inner.transpose();
                for i in 0..4 {
                    let col = new_self.col_mut(i);
                    *col = Vec4::new(col[3], col[2], col[1], col[0]);
                }
                Self::M4(new_self)
            }
            Self::M3(inner) => {
                let mut new_self = inner.transpose();
                for i in 0..3 {
                    let col = new_self.col_mut(i);
                    *col = Vec3::new(col[2], col[1], col[0]);
                }
                Self::M3(new_self)
            }
        }
    }

    fn rotate(&mut self) {
        *self = self.rotated();
    }

    fn coordinates(
        &self,
        center: &GridPosition,
    ) -> impl Iterator<Item = Result<GridPosition, GameError>> {
        let mut v: Vec<Result<GridPosition, GameError>> = Vec::new();
        match self {
            Self::M4(inner) => {
                for (i, y) in (-1..3).rev().enumerate() {
                    let c = inner.col(i);
                    for (j, x) in (-1..3).enumerate() {
                        if c[j] == 1.0 {
                            v.push(center.with_offset(x, y));
                        }
                    }
                }
            }
            Self::M3(inner) => {
                for (i, y) in (-1..2).rev().enumerate() {
                    let c = inner.col(i);
                    for (j, x) in (-1..2).enumerate() {
                        if c[j] == 1.0 {
                            v.push(center.with_offset(x, y));
                        }
                    }
                }
            }
        };
        v.into_iter()
    }

    fn as_ascii(&self) -> String {
        let mut output = String::default();

        match self {
            Self::M4(this) => {
                for i in 0..4 {
                    let col = this.col(i).to_array();
                    output += format!("{}{}{}{}\n", col[0], col[1], col[2], col[3]).as_str();
                }
            }
            Self::M3(this) => {
                for i in 0..3 {
                    let col = this.col(i).to_array();
                    output += format!("{}{}{}\n", col[0], col[1], col[2]).as_str();
                }
            }
        };

        output
    }
}

fn update_position(
    mut changed: Query<
        (Entity, &GridPosition, &mut Transform),
        Or<(Added<GridPosition>, Changed<GridPosition>)>,
    >,
) {
    changed.iter_mut().for_each(|(e, gp, mut t)| {
        let v3: Vec3 = gp.into();
        debug!(
            "Updating {e} with grid position {:?} to coordinates {:?}",
            gp, v3
        );

        t.translation = gp.into();
    });
}

// TODO: Inline this to when movement occurs
fn update_shape_blocks(
    query: Query<(Entity, &Shape, &Orientation, &GridPosition), Or<(Added<Shape>, Changed<Shape>)>>,
    mut blocks: Query<&mut GridPosition, (With<ShapeBlock>, Without<Shape>)>,
    mut commands: Commands,
    visuals: Res<Visuals>,
) {
    query.iter().for_each(|(e, s, o, center)| {
        info!("Setting piece: {e:?} {o:?} {center:?}\n{}", s.as_ascii());

        if blocks.is_empty() {
            let mesh = Mesh2d(visuals.mesh.clone());
            let mat = MeshMaterial2d(visuals.material.clone());
            commands
                .entity(e)
                .with_related_entities::<ShapeBlock>(|parent| {
                    s.coordinates(center).for_each(|gp| {
                        parent
                            .spawn((mesh.clone(), mat.clone(), gp.unwrap(), Block))
                            .observe(movement);
                    });
                });
        } else {
            let mut p = s.coordinates(center);
            blocks.iter_mut().for_each(|mut gp| {
                *gp = p.next().unwrap().unwrap();
            });
        }
    });
}

fn kb_input(
    mut events: EventReader<KeyboardInput>,
    mut query: Query<(Entity, &Orientation, &mut Shape)>,
    curr: Res<State<Falling>>,
    mut next: ResMut<NextState<Falling>>,
    mut commands: Commands,
) {
    events.read().for_each(
        |KeyboardInput {
             key_code, state, ..
         }| {
            if let ButtonState::Pressed = state {
                query.iter_mut().for_each(|(e, o, mut s)| {
                    match key_code {
                        // Up arrow should rotate if in falling mode
                        // Only move up if in falling::off mode
                        KeyCode::ArrowUp => {
                            commands.entity(e).trigger(Movement::Rotate);
                        }
                        KeyCode::ArrowDown => {
                            commands.entity(e).trigger(Movement::Down);
                        }
                        KeyCode::ArrowLeft => {
                            commands.entity(e).trigger(Movement::Left);
                        }
                        KeyCode::ArrowRight => {
                            commands.entity(e).trigger(Movement::Right);
                        }
                        KeyCode::Space => next.set(match curr.get() {
                            Falling::On => Falling::Off,
                            Falling::Off => Falling::On,
                        }),
                        KeyCode::Digit1 => *s = Shape::new_t(),
                        KeyCode::Digit2 => *s = Shape::new_o(),
                        KeyCode::Digit3 => *s = Shape::new_l(),
                        KeyCode::Digit4 => *s = Shape::new_j(),
                        KeyCode::Digit5 => *s = Shape::new_s(),
                        KeyCode::Digit6 => *s = Shape::new_z(),
                        KeyCode::Digit7 => *s = Shape::new_i(),
                        _ => (),
                    }
                });
            }
        },
    );
}

fn draw_grid(mut gizmos: Gizmos) {
    gizmos
        .grid_2d(
            Isometry2d::IDENTITY,
            UVec2::new(X_MAX, Y_MAX),
            Vec2::new(SCALE, SCALE),
            GREEN,
        )
        .outer_edges();
}

fn falling(mut shape: Query<Entity, With<Shape>>, mut commands: Commands) {
    shape.iter_mut().for_each(|e| {
        info!("Making {:?} fall", e);
        commands.entity(e).trigger(Movement::Down);
    });
}

// Run condition that returns `true` every `n` seconds
// TODO: Update a resource with the current tick
fn clock_cycle(n: f32) -> impl FnMut(Res<Time>, Local<f32>) -> bool {
    move |t: Res<Time>, mut buf: Local<f32>| -> bool {
        *buf += t.delta_secs();
        if *buf > n {
            *buf = 0.0;
            true
        } else {
            false
        }
    }
}

fn add_piece(mut commands: Commands) {
    // TODO: Choose a different piece
    commands
        .spawn((
            Orientation::default(),
            GridPosition::default(),
            Shape::default(),
        ))
        .observe(movement);
}

/// When a line reaches 10 blocks, clear it
fn clear_line(
    lines: Query<(Entity, &LineBlocks), (With<LineBlocks>, Changed<LineBlocks>)>,
    mut commands: Commands,
) {
    lines.iter().for_each(|(e, lb)| {
        if lb.0.len() == 10 {
            commands.entity(e).despawn_related::<LineBlocks>();
            // TODO: re-parent all blocks above this to the next line down
            // TODO: Parent blocks to lines for movement
        }
    });
}

#[derive(Event, Copy, Clone, PartialEq)]
enum Movement {
    Down,
    Left,
    Right,
    Rotate,
}

// TODO: When out of bounds left/right, try to move piece away from wall
fn movement(
    trigger: Trigger<Movement>,
    mut grid_positions: Query<&mut GridPosition, Or<(With<ShapeBlock>, With<ShapeBlocks>)>>,
    mut shape: Query<&mut Shape>,
    inactive: Query<&GridPosition, (Without<ShapeBlock>, Without<ShapeBlocks>)>,
    mut commands: Commands,
) {
    if let (Ok(this_shape), Ok(center)) = (
        shape.get_mut(trigger.target()),
        grid_positions.get(trigger.target()),
    ) {
        let (new_center, new_shape) = match trigger.event() {
            Movement::Down => (center.with_offset(0, -1), *this_shape),
            Movement::Left => (center.with_offset(-1, 0), *this_shape),
            Movement::Right => (center.with_offset(1, 0), *this_shape),
            Movement::Rotate => (Ok(*center), this_shape.rotated()),
        };
        info!(
            "Proposed change: {:?}\n{}",
            new_center,
            new_shape.as_ascii()
        );
        match new_center {
            Err(GameError::OutOfBoundsLeft) | Err(GameError::OutOfBoundsRight) => (), // Do nothing
            Err(GameError::OutOfBoundsDown) => {
                commands.entity(trigger.target()).remove::<Shape>();
            }
            Err(GameError::Collision) => panic!("This shouldn't happen!"),
            Ok(new_center) => {
                let new_blocks = new_shape.coordinates(&new_center);
                for block_gp in new_blocks {
                    match block_gp {
                        Err(GameError::OutOfBoundsLeft) | Err(GameError::OutOfBoundsRight) => {
                            return;
                        } // Do nothing
                        Err(GameError::OutOfBoundsDown) => {
                            commands.entity(trigger.target()).remove::<Shape>();
                            return;
                        }
                        Err(GameError::Collision) => panic!("This shouldn't happen!"),
                        Ok(gp) => {
                            for other_gp in inactive.iter() {
                                // If there would be a collision between blocks
                                if gp == *other_gp {
                                    // And we are moving down
                                    if *trigger.event() == Movement::Down {
                                        // De-activate this piece
                                        commands.entity(trigger.target()).remove::<Shape>();
                                    }
                                    // Regardless, cancel the move
                                    return;
                                }
                            }
                        }
                    }
                }
                // Update center
                let mut gp = grid_positions.get_mut(trigger.target()).unwrap();
                *gp = new_center;
                // Update shape/rotation
                let mut s = shape.get_mut(trigger.target()).unwrap();
                *s = new_shape;
            }
        }
    } else {
        warn!("Triggered movement on non-shape entity");
    }
}

// TODO: Just despawn?
fn deactive_shape(
    trigger: Trigger<OnRemove, Shape>,
    grid_positions: Query<&GridPosition>,
    parent: Query<&ShapeBlocks>,
    lines: Query<(Entity, &Line), With<LineBlocks>>,
    mut commands: Commands,
) {
    parent.iter_descendants(trigger.target()).for_each(|block| {
        let GridPosition { y, .. } = grid_positions.get(block).unwrap();
        let parent_line = lines.iter().find_map(|(e, Line(i))| (*y == *i as u32).then_some(e)).unwrap();
        commands.entity(parent_line).add_one_related::<LineBlock>(block);
    });
    commands.entity(trigger.target()).despawn();
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_shape_t() {
        let mut shape = Shape::new_t();

        let expected_up = "010\n\
                           111\n\
                           000\n";

        let expected_right = "010\n\
                              011\n\
                              010\n";

        let expected_down = "000\n\
                             111\n\
                             010\n";

        let expected_left = "010\n\
                             110\n\
                             010\n";

        assert_eq!(shape.as_ascii(), expected_up);
        shape.rotate();
        assert_eq!(shape.as_ascii(), expected_right);
        shape.rotate();
        assert_eq!(shape.as_ascii(), expected_down);
        shape.rotate();
        assert_eq!(shape.as_ascii(), expected_left);
        shape.rotate();
        assert_eq!(shape.as_ascii(), expected_up);
    }

    #[test]
    fn test_shape_i() {
        let mut shape = Shape::new_i();

        let expected_up = "0010\n\
                           0010\n\
                           0010\n\
                           0010\n";

        let expected_right = "0000\n\
                              0000\n\
                              1111\n\
                              0000\n";

        let expected_down = "0100\n\
                             0100\n\
                             0100\n\
                             0100\n";

        let expected_left = "0000\n\
                             1111\n\
                             0000\n\
                             0000\n";

        assert_eq!(shape.as_ascii(), expected_up);
        shape.rotate();
        assert_eq!(shape.as_ascii(), expected_right);
        shape.rotate();
        assert_eq!(shape.as_ascii(), expected_down);
        shape.rotate();
        assert_eq!(shape.as_ascii(), expected_left);
        shape.rotate();
        assert_eq!(shape.as_ascii(), expected_up);
    }

    #[test]
    fn test_coordinates() {
        let shape = Shape::new_t();

        let center = GridPosition { x: 5, y: 5 };

        let expected: Vec<Result<GridPosition, GameError>> = vec![
            Ok((5, 6).into()),
            Ok((4, 5).into()),
            Ok((5, 5).into()),
            Ok((6, 5).into()),
        ];

        let actual: Vec<Result<GridPosition, GameError>> = shape.coordinates(&center).collect();

        assert_eq!(actual, expected);
    }
}