function defined(obj: any): boolean {
  return !!obj
}

/** Key和Value的双向映射 */
export class BidirectionalMap<K, V> {
  private readonly _kMapV: Map<K, V>
  private readonly _vMapK: Map<V, K>

  constructor(source?: BidirectionalMap<K, V>) {
    if (source) {
      this._kMapV = new Map<K, V>(source._kMapV)
      this._vMapK = new Map<V, K>(source._vMapK)
    } else {
      this._kMapV = new Map<K, V>()
      this._vMapK = new Map<V, K>()
    }
  }

  get entries(): IterableIterator<[K, V]> {
    return this._kMapV.entries()
  }

  get keys(): IterableIterator<K> {
    return this._kMapV.keys()
  }

  get size(): number {
    return this._kMapV.size
  }

  get values(): IterableIterator<V> {
    return this._kMapV.values()
  }

  /**
   * 清空数据
   */
  clear(): void {
    this._kMapV.clear()
    this._vMapK.clear()
  }

  clone(): BidirectionalMap<K, V> {
    return new BidirectionalMap<K, V>(this)
  }

  delete(k: K, v: V): void {
    this._kMapV.delete(k)
    this._vMapK.delete(v)
  }

  /**
   * 根据给定的key删除数据，删除成功返回true，否则返回false
   */
  deleteByKey(k: K): boolean {
    const v = this.getValue(k)
    this._kMapV.delete(k)
    if (defined(v)) {
      this._vMapK.delete(v!)
      return true
    }
    return false
  }

  /**
   * 根据给定的value删除数据，删除成功返回true，否则返回false
   */
  deleteByValue(v: V): boolean {
    const k = this.getKey(v)
    this._vMapK.delete(v)
    if (defined(k)) {
      this._kMapV.delete(k!)
      return true
    }
    return false
  }

  /**
   * 返回value对应的key
   */
  getKey(v: V): K | undefined {
    return this._vMapK.get(v)
  }

  /**
   * 返回key对应的value
   */
  getValue(k: K): V | undefined {
    return this._kMapV.get(k)
  }

  hasKey(k: K): boolean {
    return this._kMapV.has(k)
  }

  hasValue(v: V): boolean {
    return this._vMapK.has(v)
  }

  /**
   * 当成功添加key和value时返回true，否则返回false
   */
  set(k: K, v: V): boolean {
    if (defined(this.getValue(k))) return false
    if (defined(this.getKey(v))) return false
    this._kMapV.set(k, v)
    this._vMapK.set(v, k)
    return true
  }
}