import { Nullable } from '../utils'
import { GenericSeed } from './generic'

export interface MapAccess {
  nextKeySeed<T, K extends Deserialize<T>>(seed: K): Nullable<T>
  nextValueSeed<T, V extends Deserialize<T>>(seed: V): Nullable<T>
  nextEntrySeed<TK, TV, K extends Deserialize<TK>, V extends Deserialize<TV>>(kseed: K, vseed: V): Nullable<[TK, TV]>
  nextKey<T>(): Nullable<T>
  nextValue<T>(): Nullable<T>
  nextEntry<K, V>(): Nullable<[K, V]>
}

export abstract class DefaultMapAccessImpl implements MapAccess {
  abstract nextKeySeed<T, K extends Deserialize<T>>(seed: K): Nullable<T>
  abstract nextValueSeed<T, V extends Deserialize<T>>(seed: V): Nullable<T>

  nextEntrySeed<TK, TV, K extends Deserialize<TK>, V extends Deserialize<TV>>(kseed: K, vseed: V): Nullable<[TK, TV]> {
    const key = this.nextKeySeed(kseed) as Nullable<TK>
    if (key !== undefined) {
      const value = this.nextValueSeed(vseed) as Nullable<TV>

      if (value !== undefined) {
        return [key, value]
      }
    }
  }

  nextKey<T>(): Nullable<T> {
    return this.nextValueSeed(GenericSeed<T>)
  }

  nextValue<T>(): Nullable<T> {
    return this.nextValueSeed(GenericSeed<T>)
  }

  nextEntry<K, V>(): Nullable<[K, V]> {
    return this.nextEntrySeed(GenericSeed<K>, GenericSeed<V>)
  }
}

export interface IterableAccess {
  nextElementSeed<T, I extends Deserialize<T>>(seed: I): Nullable<T>
  nextElement<T>(): Nullable<T>
  sizeHint(): number
}

export abstract class DefaultIterableAccessImpl implements IterableAccess {
  abstract nextElementSeed<T, I extends Deserialize<T>>(seed: I): Nullable<T>

  nextElement<T>(): Nullable<T> {
    return this.nextElementSeed(GenericSeed<T>)
  }

  sizeHint(): number { return 0 }
}

export interface Visitor<T> {
  visitString(value: string): T
  visitNumber(value: number): T
  visitBigInt(value: bigint): T
  visitBoolean(value: boolean): T
  visitSymbol(value: symbol): T
  visitNull(): T
  visitObject(value: MapAccess): T
  visitClass(name: string, value: MapAccess): T
  visitIterable?(value: IterableAccess): T
}

export interface Deserializer {
  deserializeAny<T, V extends Visitor<T>>(visitor: V): T
  deserializeString<T, V extends Visitor<T>>(visitor: V): T
  deserializeNumber<T, V extends Visitor<T>>(visitor: V): T
  deserializeBigInt<T, V extends Visitor<T>>(visitor: V): T
  deserializeBoolean<T, V extends Visitor<T>>(visitor: V): T
  deserializeSymbol<T, V extends Visitor<T>>(visitor: V): T
  deserializeNull<T, V extends Visitor<T>>(visitor: V): T
  deserializeObject<T, V extends Visitor<T>>(visitor: V): T
  deserializeClass<T, V extends Visitor<T>>(name: string, visitor: V): T
  deserializeIterable<T, V extends Visitor<T>>(visitor: V): T
}

export interface Deserialize<T> {
  deserialize<D extends Deserializer>(deserializer: D): T
}