import {
  forwardRef,
  HttpException,
  HttpStatus,
  Inject,
  Injectable,
} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Game } from '../entities/game.entity';
import { Repository } from 'typeorm';
import { EventEmitter2 } from '@nestjs/event-emitter';
import { Player } from '../entities/player.entity';
import { User } from 'src/users/entities/user.entity';

import { WordService } from 'src/word/services/word.service';
import {
  GameMessageDeleteEvent,
  GameMessageEvent,
  GameStartEvent,
} from 'events/game.events';
import random from 'random';
import { platform } from 'os';
import { Message } from '../entities/message.entity';

@Injectable()
export class GameService {
  constructor(
    @InjectRepository(Game) private gameRepository: Repository<Game>,
    @InjectRepository(Message) private messageResporitory: Repository<Message>,
    private readonly wordService: WordService,
    private eventEmitter: EventEmitter2,
  ) {}

  async start(game: Game) {
    const rng = random.clone(game.seed);
    game.started = true;
    game.currentPlayer = rng.choice(game.players);
    const words = await this.wordService.listActive();
    game.currentWord = rng.choice(words);

    await this.gameRepository.save(game);
    this.eventEmitter.emit(
      'sse.game.' + game.id,
      new GameStartEvent(game.currentPlayer),
    );
  }

  async postMessage(game: Game, author: Player, value: string) {
    const message = this.messageResporitory.create();
    message.author = author;
    message.game = Promise.resolve(game);
    message.value = value;
    await this.messageResporitory.save(message);
    this.eventEmitter.emit(
      'sse.game.' + game.id,
      new GameMessageEvent(message),
    );
    const oldMessage = game.messages[0];
    const oldMessageId = oldMessage.id;
    if (game.messages.length > 3) {
      await this.messageResporitory.remove(oldMessage);
    }
    this.eventEmitter.emit(
      'sse.game.' + game.id,
      new GameMessageDeleteEvent(oldMessageId),
    );
  }

  async end(game: Game, winner: Player) {
    throw Error('Not Implemented');
  }

  async guessWord(game: Game, user: User, word: string) {
    throw Error('Not Implemented');
  }
}