import 'package:flame/collisions.dart';
import 'package:flame/components.dart';
import 'package:flame/game.dart';
import 'package:flame/input.dart';
import 'package:flutter/services.dart';
import 'package:flutter/widgets.dart';

Vector2 CalcPerpendicular(Vector2 vec, {bool clockwise = true}) {
  if (clockwise) {
    return Vector2(vec.y, -vec.x);
  } else {
    return Vector2(-vec.y, vec.x);
  }
}

class Ninja extends RectangleComponent
    with KeyboardHandler, CollisionCallbacks {
  final Set<LogicalKeyboardKey> keysPressed = {};
  final Set<LogicalKeyboardKey> keysDown = {};
  final double speed = 64;
  PolygonComponent? _hitbox;
  Vector2? _delta;

  @override
  void render(Canvas canvas) {
    super.render(canvas);
    canvas.drawCircle(Offset(this.size.x / 2, this.size.y / 2), this.size.x / 2,
        Paint()..color = Color.fromARGB(255, 178, 186, 247));
  }

  @override
  void update(double dt) {
    if (_hitbox != null) {
      if (!isColliding) {
        print('move');
        this.position += _delta!;
      }
      remove(_hitbox!);
      _hitbox = null;
    }

    double dx = 0;
    double dy = 0;
    if (keysPressed.contains(LogicalKeyboardKey.arrowRight)) {
      dx = dt * speed;
    }
    if (keysPressed.contains(LogicalKeyboardKey.arrowLeft)) {
      dx = -dt * speed;
    }
    if (keysPressed.contains(LogicalKeyboardKey.arrowUp)) {
      dy = -dt * speed;
    }
    if (keysPressed.contains(LogicalKeyboardKey.arrowDown)) {
      dy = dt * speed;
    }

    _delta = Vector2(dx, dy);
    if (_delta!.length2 > 0) {
      _hitbox = PolygonHitbox([
        CalcPerpendicular(_delta!, clockwise: true).normalized() * (width / 2) +
            (this.size * 0.5),
        CalcPerpendicular(_delta!, clockwise: false).normalized() *
                (width / 2) +
            (this.size * 0.5),
        CalcPerpendicular(_delta!, clockwise: false).normalized() *
                (width / 2) +
            (this.size * 0.5) +
            _delta! +
            _delta!.normalized() * 16,
        CalcPerpendicular(_delta!, clockwise: true).normalized() * (width / 2) +
            (this.size * 0.5) +
            _delta! +
            _delta!.normalized() * 16,
      ]);
      print('attempt ${_delta} ${_hitbox!.vertices}');
      _hitbox!.debugColor = Color(0xffff0000);
      add(_hitbox!);
    }
  }

  bool onKeyEvent(KeyEvent event, Set<LogicalKeyboardKey> keysPressed) {
    this.keysDown.clear();
    for (final key in keysPressed) {
      if (!this.keysPressed.contains(key)) {
        this.keysDown.add(key);
      }
    }
    this.keysPressed.clear();
    this.keysPressed.addAll(keysPressed);
    return false;
  }

  @override
  void onCollision(Set<Vector2> points, PositionComponent other) {
    print('collision $other');
    super.onCollision(points, other);
  }
}

class NinjaWorld extends World {
  @override
  Future<void> onLoad() async {
    final test =
        RectangleComponent(position: Vector2(100, 100), size: Vector2(16, 16))
          ..add(RectangleHitbox())
          ..debugMode = true;
    add(test);

    for (int j = 12; j <= 14; ++j) {
      for (int i = 0; i < 30; ++i) {
        int xpos = i * 16;
        int ypos = j * 16;
        final ShapeComponent shape = RectangleComponent(
            position: Vector2(xpos.toDouble(), ypos.toDouble()),
            paint: Paint()..color = Color.fromARGB(255, 205, 35, 35),
            size: Vector2(16, 16))
          ..add(RectangleHitbox());
        add(shape);
      }
    }

    final ninja = Ninja();
    ninja.position = Vector2(0, 0);
    ninja.size = Vector2(32, 32);
    ninja.debugMode = true;
    add(ninja);
  }
}

class NinjaGame extends FlameGame
    with HasKeyboardHandlerComponents, HasQuadTreeCollisionDetection {
  NinjaGame()
      : super(
            camera:
                CameraComponent.withFixedResolution(width: 512, height: 288),
            world: NinjaWorld());

  @override
  Future<void> onLoad() async {
    initializeCollisionDetection(
      mapDimensions: const Rect.fromLTWH(0, 0, 5120, 288),
    );
    camera.moveTo(Vector2(256, 144));
    camera.viewfinder.zoom = 1.0;
  }
}

void main() {
  final game = NinjaGame();
  runApp(GameWidget(game: game));
}