//class helper {
//  Revive<T>(t:string, _type:string):string {
//    return t
//  }
//  Revive<T>(t:string, _type:string[]):string[]{
//    return t.split(",")
//  }
//  Revive<T>(t:string, _type:number):number {
//    return Number(t)
//  }
//  Revive<T>(t:string, _type:number[]):number[]{
//    return t.split(",").map(Number)
//  }
//}

import { ColumnSet } from "./table"
import { TricksterAccount, TricksterCharacter, TricksterInventory } from "./trickster"

export const ARRAY_SEPERATOR = ","

let as =  ARRAY_SEPERATOR

export interface Reviver<T> {
  Murder(t:T):string
  Revive(s:string):T
}

export const StoreStr= {
  Murder: (s:string):string=>s,
  Revive: (s:string):string=>s
}

export const StoreNum = {
  Murder: (s:number):string=>s.toString(),
  Revive: (s:string):number=>Number(s)
}

export const StoreStrSet = {
  Murder: (s:Set<string>):string=>Array.from(s).join(as),
  Revive: (s:string):Set<string>=>new Set(s.split(as))
}

export const StoreColSet = {
  Murder: (s:ColumnSet):string=>Array.from(s.s.values()).join(as),
  Revive: (s:string):ColumnSet=>new ColumnSet(s.split(as) as any)
}
export const StoreChars = {
  Murder: (s:Map<string,TricksterCharacter>):string=>{
    let o = JSON.stringify(Array.from(s.entries()))
    return o
  },
  Revive: (s:string):Map<string,TricksterCharacter>=>new Map(JSON.parse(s)),
}
export const StoreAccounts = {
  Murder: (s:Map<string,TricksterAccount>):string=>{
    let o = JSON.stringify(Array.from(s.entries()))
    return o
  },
  Revive: (s:string):Map<string,TricksterAccount>=>new Map(JSON.parse(s)),
}

export const StoreJsonable = {
  Murder: <T>(s:T):string=>JSON.stringify(Object.entries(s)),
  Revive: <T>(s:string):T=>JSON.parse(s),
}

export interface Serializable<T> {
  parse(s:any):T
}

export const StoreSerializable = <T extends Serializable<T>>(n:(new ()=>T))=>{
  return {
    Murder: (s:T):string=>JSON.stringify(s),
    Revive: (s:string):T=>new n().parse(JSON.parse(s))
  }
}