import { Zone } from '@prisma/client'
import ZoneRepository from '../repositories/zoneRepository'
import ZoneService from '../services/zoneService'
import LoadedZone from '../models/loadedZone'
import { gameLogger } from '../utilities/logger'
import ZoneCharacter from '../models/zoneCharacter'

class ZoneManager {
  private readonly zones = new Map<number, LoadedZone>()

  public async boot(): Promise<void> {
    // Create first zone if it doesn't exist
    if (!(await ZoneRepository.getById(1))) {
      await new ZoneService().createDemoZone()
    }

    const zones = await ZoneRepository.getAll()
    await Promise.all(zones.map((zone) => this.loadZone(zone)))

    gameLogger.info(`Zone manager loaded with ${this.zones.size} zones`)
  }

  public async loadZone(zone: Zone): Promise<void> {
    const loadedZone = new LoadedZone(zone)
    this.zones.set(zone.id, loadedZone)
    gameLogger.info(`Zone ID ${zone.id} loaded`)
  }

  public unloadZone(zoneId: number): void {
    this.zones.delete(zoneId)
    gameLogger.info(`Zone ID ${zoneId} unloaded`)
  }

  public getLoadedZones(): LoadedZone[] {
    return Array.from(this.zones.values())
  }

  public getZoneById(zoneId: number): LoadedZone | undefined {
    return this.zones.get(zoneId)
  }

  public getCharacter(characterId: number): ZoneCharacter | undefined {
    for (const zone of this.zones.values()) {
      const character = zone.getCharactersInZone().find((char) => char.character.id === characterId)
      if (character) return character
    }
    return undefined
  }

  public removeCharacter(characterId: number): void {
    this.zones.forEach((zone) => zone.removeCharacter(characterId))
  }
}

export default new ZoneManager()