import { isFunction, Primitive, ToString } from "../utils"

export interface ObjectSerializer<T = void> {
  serializeKey<U extends Serializable>(key: U): T
  serializeValue<U extends Serializable>(value: U): T
  end(): T
}

export interface IterableSerializer<T = void> {
  serializeElement<U extends Serializable>(element: U): T
  end(): T
}

const TypeSerializerMethods = [
  'serializeString',
  'serializeNumber',
  'serializeBigInt',
  'serializeBoolean',
  'serializeSymbol',
  //'serializeMap',
  'serializeIterable',
  'serializeNull',
  'serializeObject',
  //'serializeClass',
] as const

interface TypeSerializer<T> {
  serializeString(value: string): T
  serializeNumber(value: number): T
  serializeBigInt(value: bigint): T
  serializeBoolean(value: boolean): T
  serializeSymbol(value: Symbol): T
  serializeNull(): T
  serializeObject(): ObjectSerializer<T>
  // serializeMap?(): ObjectSerializer<T>
  serializeIterable?(): IterableSerializer<T>
  //serializeClass(name: PropertyKey): ObjectSerializer<T>
}

const AnySerializerMethods = ['serializeAny']

interface AnySerializer<T> {
  serializeAny?(value?: any): T
}

export function isGenericSerializer(value: any): boolean {
  return AnySerializerMethods.every(k => isFunction(value[k])) &&
    TypeSerializerMethods.every(k => !isFunction(value[k]))
}

export type Serializer<T> = Partial<TypeSerializer<T>> & Partial<AnySerializer<T>>

export type Serializable = Primitive | ToString | Serialize

export interface Serialize {
  serialize<T, S extends Serializer<T>>(serializer: S): T
}