import { type GameObjectRegister } from "."
import type { Card } from "./Card"
import { type Effect, CardEffects } from "./Effect"
import type { GameObjectNetcode } from "./GameObject"
export interface TurnNetcode extends GameObjectNetcode {
    cards_locked: Array<string>
    effects_availables: Array<string>
    champions_health: { [key: string]: string }
    discard_markers: number
    damage_reserve: number
    gold_reserve: number
}


export type Turn = Omit<TurnNetcode, 'cards_locked' | 'effects_availables' | 'champions_health'> & {
    cards_locked: { [key: string]: Card }
    effects_availables: Array<Effect>
    champions_health: Map<string, number>
    find_effect: (card_effect: CardEffects) => Effect | undefined
}
export function create_turn(input: TurnNetcode, register: GameObjectRegister) {
    const turn = new Proxy<any>(input, {
        get(target: TurnNetcode, prop, reciever) {
            if (prop == "cards_locked") {
                return Object.fromEntries(target.cards_locked.map(e => [e, register.cards.get(e)]))
            }
            if (prop == "effects_availables") {
                return target.effects_availables.map(e => register.effects.get(e))
            }
            if (prop == "champions_health") {
                const healths = new Map()
                for (const c in target.champions_health) {
                    healths.set(register.cards.get(c)?.uuid, target.champions_health[c])
                }
                return healths
            }
            if (prop == "find_effect") {
                return (card_effect: CardEffects) => {
                    return turn.effects_availables.find(e => (e.effect == card_effect) && e.usable)
                }
            }
            return Reflect.get(target, prop, reciever);
        },
        set(target, prop, val, receiver) {
            return Reflect.set(target, prop, val, receiver);
        }
    }) as Turn
    return turn
}