import { Connection } from "../connection/Connection";
import { v4 as uuidv4 } from "uuid";
import { User } from "../user/User";
import { MessageHandler } from "../message/MessageHandler";
import {
  ServerInboundMessage,
  ServerOutboundMessage,
  ServerOutboundMessageKey,
} from "../../common";
import { RoomDescription, RoomInfo, UserData } from "../../common/dataType";
import { RoomManager } from "./RoomManager";

export class Room {
  public readonly uuid: string;

  public name: string;
  public readonly maxUsers: number;

  public readonly roomManager: RoomManager;

  public users: User[] = [];
  public admin?: User;

  public closed: boolean = false;

  public handler: MessageHandler;

  constructor(
    roomManager: RoomManager,
    name: string,
    admin?: User,
    maxUsers: number = 8
  ) {
    this.uuid = uuidv4();
    this.name = name;
    this.maxUsers = maxUsers;
    this.roomManager = roomManager;
    this.admin = admin;

    this.handler = new MessageHandler({
      chat: (user, message) => {
        this.sendChat(user, message.message);
        return { ok: true };
      },
      leaveRoom: (user, message) => {
        this.disconnect(user);
        return { ok: true };
      },
    });

    if (this.admin) {
      this.connect(this.admin);
    }
  }

  public connect(user: User): void {
    if (this.users.includes(user) || this.users.length >= this.maxUsers) {
      return;
    }

    this.broadcast("updateRoomUser", {
      state: "added",
      user: {
        username: user.username,
        admin: user === this.admin,
      },
    });

    this.users.push(user);
    user.room = this;
  }

  public disconnect(user: User): void {
    const index = this.users.indexOf(user);
    if (index > -1) {
      this.users.splice(index, 1);
      user.room = undefined;

      this.broadcast("updateRoomUser", {
        state: "removed",
        user: {
          username: user.username,
          admin: user === this.admin,
        },
      });

      if (this.users.length === 0) {
        this.close();
      } else {
        this.setNextAdmin();
      }
    }
  }

  private setNextAdmin(): void {
    const nextAdmin = this.users[Math.floor(Math.random() * this.users.length)];
    this.admin = nextAdmin;
  }

  public sendChat(user: User, message: string): void {
    this.broadcast("chat", { sender: user.username, message: message });
  }

  public getDescription(): RoomDescription {
    return {
      uuid: this.uuid,
      name: this.name,
      currentUsers: this.users.length,
      maxUsers: this.maxUsers,
    };
  }

  public getInfo(): RoomInfo {
    return {
      uuid: this.uuid,
      name: this.name,
      maxUsers: this.maxUsers,
      users: this.users.map((u) => {
        return {
          username: u.username,
          admin: u === this.admin,
        };
      }),
    };
  }

  public broadcast<T extends ServerOutboundMessageKey>(
    type: T,
    message: ServerOutboundMessage<T>,
    except?: User
  ): void {
    this.users.forEach((u) => {
      if (u !== except) {
        u.connection.send(type, message);
      }
    });
  }

  public close(): void {
    if (!this.closed) {
      this.users.forEach((u) => this.disconnect(u));
      this.closed = true;
      this.roomManager.delete(this.uuid);
    }
  }
}