// src/application/GameService.ts
import { Game, Player, Palet, Master } from '../domain/entities';
import { GameUseCase } from '../domain/usecases/GameUseCase';
import { Vector3 } from '../types/Vector3';

export class GameService implements GameUseCase {
  private game: Game;
  private readonly WINNING_SCORE = 12;
  private readonly WINNING_SCORE_TIEBREAKER = 15;
  private readonly DISTANCE_TO_BOARD = 5; // en mètres
  private readonly PALETS_PER_PLAYER = 4;

  constructor() {
    this.game = this.initializeGame();
  }

  private initializeGame(): Game {
    const player1 = new Player('1', this.createPalets());
    const player2 = new Player('2', this.createPalets());
    const master = new Master(new Vector3(0, 0, 0));
    return new Game([player1, player2], master, 0, [0, 0]);
  }

  private createPalets(): Palet[] {
    return Array.from({ length: this.PALETS_PER_PLAYER }, (_, i) => 
      new Palet(`${i}`, new Vector3(0, 0, -this.DISTANCE_TO_BOARD))
    );
  }

  startGame(): void {
    this.game = this.initializeGame();
    this.determineMasterThrower();
  }

  private determineMasterThrower(): void {
    // Simuler le lancer d'un palet pour chaque joueur
    const distancePlayer1 = Math.random() * this.DISTANCE_TO_BOARD;
    const distancePlayer2 = Math.random() * this.DISTANCE_TO_BOARD;
    this.game.currentPlayerIndex = distancePlayer1 < distancePlayer2 ? 0 : 1;
  }

  throwMaster(playerId: string, position: Vector3): boolean {
    if (playerId !== this.game.players[this.game.currentPlayerIndex].id) {
      return false;
    }

    if (this.isValidMasterPosition(position)) {
      this.game.master.position = position;
      return true;
    }

    return false;
  }

  private isValidMasterPosition(position: Vector3): boolean {
    // Vérifier si la position du maître est sur la planche
    // Cette logique dépendra de la taille exacte de votre planche dans le jeu
    return position.x >= -0.5 && position.x <= 0.5 && 
           position.z >= -0.5 && position.z <= 0.5;
  }

  throwPalet(playerId: string, paletId: string, position: Vector3): void {
    const player = this.game.players.find(p => p.id === playerId);
    if (!player) return;

    const palet = player.palets.find(p => p.id === paletId);
    if (!palet) return;

    palet.position = position;

    this.switchTurn();
  }

  private switchTurn(): void {
    this.game.currentPlayerIndex = 1 - this.game.currentPlayerIndex;
  }

  calculateScore(): void {
    const distances = this.game.players.map(player => 
      player.palets.map(palet => this.distanceBetween(palet.position, this.game.master.position))
    );

    let scoringPlayer = distances[0][0] < distances[1][0] ? 0 : 1;
    let points = 0;

    for (let i = 0; i < this.PALETS_PER_PLAYER; i++) {
      if (distances[scoringPlayer][i] < distances[1-scoringPlayer][i]) {
        points++;
      } else {
        break;
      }
    }

    this.game.score[scoringPlayer] += points;
  }

  private distanceBetween(pos1: Vector3, pos2: Vector3): number {
    const dx = pos1.x - pos2.x;
    const dy = pos1.y - pos2.y;
    const dz = pos1.z - pos2.z;
    return Math.sqrt(dx*dx + dy*dy + dz*dz);
  }

  isGameOver(): boolean {
    const [score1, score2] = this.game.score;
    const maxScore = this.isTiebreaker() ? this.WINNING_SCORE_TIEBREAKER : this.WINNING_SCORE;
    return score1 >= maxScore || score2 >= maxScore;
  }

  private isTiebreaker(): boolean {
    return this.game.score[0] === this.WINNING_SCORE - 1 && 
           this.game.score[1] === this.WINNING_SCORE - 1;
  }

  getGameState(): Game {
    return this.game;
  }
}

// src/infrastructure/PlaycanvasAdapter.ts
import * as pc from 'playcanvas';
import { Vector3 } from '../types/Vector3';
import { Palet, Master, Game } from '../domain/entities';

export class PlaycanvasAdapter {
  private app: pc.Application;
  private scene: pc.Scene;
  private camera: pc.CameraComponent;
  private light: pc.LightComponent;
  private paletEntities: Map<string, pc.Entity> = new Map();
  private masterEntity: pc.Entity;
  private boardEntity: pc.Entity;

  constructor(canvas: HTMLCanvasElement) {
    this.app = new pc.Application(canvas);
    this.scene = this.app.scene;
    this.setupScene();
  }

  private setupScene(): void {
    // Configurer la caméra
    this.camera = new pc.Entity();
    this.camera.addComponent('camera', {
      clearColor: new pc.Color(0.1, 0.1, 0.1)
    });
    this.camera.translateLocal(0, 10, 15);
    this.camera.lookAt(0, 0, 0);
    this.scene.addChild(this.camera);

    // Ajouter une lumière
    this.light = new pc.Entity();
    this.light.addComponent('light', {
      type: 'directional',
      color: new pc.Color(1, 1, 1),
      castShadows: true
    });
    this.light.setEulerAngles(45, 0, 0);
    this.scene.addChild(this.light);

    // Ajouter la planche
    this.boardEntity = this.createBoard();
    this.scene.addChild(this.boardEntity);

    // Démarrer le rendu
    this.app.start();
  }

  private createBoard(): pc.Entity {
    const board = new pc.Entity();
    board.addComponent('model', {
      type: 'box',
      material: new pc.StandardMaterial()
    });
    board.setLocalScale(2, 0.1, 1);
    return board;
  }

  createPalet(palet: Palet): void {
    const entity = new pc.Entity();
    entity.addComponent('model', {
      type: 'cylinder',
      material: new pc.StandardMaterial()
    });
    entity.setLocalScale(0.1, 0.02, 0.1);
    this.updatePaletPosition(palet);
    this.scene.addChild(entity);
    this.paletEntities.set(palet.id, entity);
  }

  createMaster(master: Master): void {
    this.masterEntity = new pc.Entity();
    this.masterEntity.addComponent('model', {
      type: 'cylinder',
      material: new pc.StandardMaterial()
    });
    this.masterEntity.setLocalScale(0.05, 0.01, 0.05);
    this.updateMasterPosition(master);
    this.scene.addChild(this.masterEntity);
  }

  updatePaletPosition(palet: Palet): void {
    const entity = this.paletEntities.get(palet.id);
    if (entity) {
      entity.setPosition(palet.position.x, palet.position.y, palet.position.z);
    }
  }

  updateMasterPosition(master: Master): void {
    this.masterEntity.setPosition(master.position.x, master.position.y, master.position.z);
  }

  animateThrow(from: Vector3, to: Vector3, duration: number, onComplete: () => void): void {
    // Implémenter l'animation de lancer ici
    // Vous pouvez utiliser les tweens de Playcanvas ou une autre méthode d'animation
  }

  updateGameState(game: Game): void {
    game.players.forEach(player => {
      player.palets.forEach(palet => {
        if (!this.paletEntities.has(palet.id)) {
          this.createPalet(palet);
        } else {
          this.updatePaletPosition(palet);
        }
      });
    });

    this.updateMasterPosition(game.master);
  }

  // Méthode pour gérer les entrées utilisateur (clic pour lancer un palet)
  setupInputHandling(onPaletThrow: (position: Vector3) => void): void {
    this.app.mouse.on(pc.EVENT_MOUSEDOWN, (event) => {
      const from = this.camera.getPosition();
      const to = this.camera.screenToWorld(event.x, event.y, this.camera.farClip);
      const result = this.scene.raycast(from, to);
      if (result) {
        onPaletThrow(result.point);
      }
    });
  }
}

// src/presentation/GameController.ts
export class GameController {
  constructor(
    private gameService: GameService,
    private playcanvasAdapter: PlaycanvasAdapter,
    private colyseusAdapter: ColyseusAdapter
  ) {
    this.setupMultiplayer();
  }

  private async setupMultiplayer() {
    try {
      await this.colyseusAdapter.joinOrCreateRoom("palet_breton");
      
      this.colyseusAdapter.setOnGameStateChange((game: Game) => {
        this.gameService.updateGameState(game);
        this.playcanvasAdapter.updateGameState(game);
      });

      this.colyseusAdapter.setOnPlayerJoin((playerId: string) => {
        console.log(`Player ${playerId} joined the game`);
        // Mise à jour de l'interface utilisateur, etc.
      });

      this.colyseusAdapter.setOnPlayerLeave((playerId: string) => {
        console.log(`Player ${playerId} left the game`);
        // Gestion du départ du joueur
      });

    } catch (e) {
      console.error("Erreur lors de la configuration du multijoueur:", e);
    }
  }

  throwPalet(playerId: string, paletId: string, position: Vector3) {
    // Envoyer l'action au serveur
    this.colyseusAdapter.sendAction("throwPalet", { playerId, paletId, position });
  }

  // Autres méthodes du contrôleur...
}

// Dans PlaycanvasAdapter

export class PlaycanvasAdapter {
  // ... autres propriétés ...
  private currentPalet: pc.Entity | null = null;
  private throwStartPosition: pc.Vec3 | null = null;
  private throwPowerIndicator: pc.Entity;

  // ... autres méthodes ...

  setupPaletThrow(onThrowComplete: (paletId: string, position: Vector3, velocity: Vector3) => void): void {
    this.throwPowerIndicator = this.createThrowPowerIndicator();
    this.scene.addChild(this.throwPowerIndicator);

    this.app.mouse.on(pc.EVENT_MOUSEDOWN, this.onMouseDown.bind(this));
    this.app.mouse.on(pc.EVENT_MOUSEMOVE, this.onMouseMove.bind(this));
    this.app.mouse.on(pc.EVENT_MOUSEUP, (event) => this.onMouseUp(event, onThrowComplete));
  }

  private createThrowPowerIndicator(): pc.Entity {
    const indicator = new pc.Entity();
    indicator.addComponent('model', {
      type: 'cylinder',
      material: new pc.StandardMaterial()
    });
    indicator.setLocalScale(0.05, 1, 0.05);
    indicator.enabled = false;
    return indicator;
  }

  private onMouseDown(event: pc.MouseEvent): void {
    if (this.currentPalet) return;

    const from = this.camera.getPosition();
    const to = this.camera.screenToWorld(event.x, event.y, this.camera.farClip);
    const result = this.app.systems.rigidbody.raycastFirst(from, to);

    if (result && result.entity.tags.has('palet')) {
      this.currentPalet = result.entity;
      this.throwStartPosition = this.currentPalet.getPosition().clone();
      this.throwPowerIndicator.setPosition(this.throwStartPosition);
      this.throwPowerIndicator.enabled = true;
    }
  }

  private onMouseMove(event: pc.MouseEvent): void {
    if (!this.currentPalet || !this.throwStartPosition) return;

    const from = this.camera.getPosition();
    const to = this.camera.screenToWorld(event.x, event.y, this.camera.farClip);
    const direction = to.sub(from).normalize();
    const distance = this.throwStartPosition.distance(this.camera.getPosition());
    const power = Math.min(distance * 0.1, 5); // Limiter la puissance maximale

    this.throwPowerIndicator.setLocalScale(0.05, power, 0.05);
    this.throwPowerIndicator.lookAt(this.throwStartPosition.add(direction.scale(power)));
  }

  private onMouseUp(event: pc.MouseEvent, onThrowComplete: (paletId: string, position: Vector3, velocity: Vector3) => void): void {
    if (!this.currentPalet || !this.throwStartPosition) return;

    const from = this.camera.getPosition();
    const to = this.camera.screenToWorld(event.x, event.y, this.camera.farClip);
    const direction = to.sub(from).normalize();
    const distance = this.throwStartPosition.distance(this.camera.getPosition());
    const power = Math.min(distance * 0.1, 5); // Limiter la puissance maximale

    const velocity = direction.scale(power * 10); // Ajuster ce multiplicateur selon vos besoins
    this.currentPalet.rigidbody.linearVelocity = velocity;

    const paletId = this.currentPalet.name; // Assurez-vous que chaque palet a un nom unique
    const position = this.currentPalet.getPosition();

    onThrowComplete(paletId, 
                    new Vector3(position.x, position.y, position.z), 
                    new Vector3(velocity.x, velocity.y, velocity.z));

    this.currentPalet = null;
    this.throwStartPosition = null;
    this.throwPowerIndicator.enabled = false;
  }
}

// Dans GameController

export class GameController {
  // ... autres propriétés et méthodes ...

  constructor(
    private gameService: GameService,
    private playcanvasAdapter: PlaycanvasAdapter,
    private colyseusAdapter: ColyseusAdapter
  ) {
    // ... autre code d'initialisation ...

    this.playcanvasAdapter.setupPaletThrow(this.onPaletThrown.bind(this));
  }

  private onPaletThrown(paletId: string, position: Vector3, velocity: Vector3): void {
    const currentPlayer = this.gameService.getCurrentPlayer();
    
    // Mettre à jour l'état local du jeu
    this.gameService.throwPalet(currentPlayer.id, paletId, position);
    
    // Envoyer l'action au serveur pour synchronisation
    this.colyseusAdapter.sendAction("throwPalet", { 
      playerId: currentPlayer.id, 
      paletId, 
      initialPosition: position, 
      initialVelocity: velocity 
    });
  }
}