import asyncio
import copy
import time
from random import random
from deepmerge import always_merger, Merger

STATE = {"initialized": 0, "generation": "invalid"}

ON_INPUT_CALLBACKS = []
ON_CHANGE_CALLBACKS = []

def register_on_change_callback(callback):
    global ON_CHANGE_CALLBACKS
    ON_CHANGE_CALLBACKS = ON_CHANGE_CALLBACKS + [callback]

def unregister_on_change_callback(callback):
    ON_CHANGE_CALLBACK = [ x for x in ON_CHANGE_CALLBACKS if x != callback ]

def register_on_input_callback(callback):
    global ON_INPUT_CALLBACKS
    ON_INPUT_CALLBACKS = ON_INPUT_CALLBACKS + [callback]

def unregister_on_input_callback(callback):
    ON_INPUT_CALLBACK = [ x for x in ON_INPUT_CALLBACKS if x != callback ]

# TODO: FIX ENTRIES HERE BY UNIQUE EFFECT ID OR SOMETHING
async def mutate(delta):
    global STATE
    my_merger = Merger(
        [
        (list, ["override"]),
        (dict, ["merge"])
        ],
        ["override"],
        ["override"]
    )

    old_state = copy.deepcopy(STATE)
    STATE = my_merger.merge(STATE, delta)
    STATE["generation"] = calculate_checksum()
    for callback in ON_CHANGE_CALLBACKS:
        await callback(old_state, STATE)

async def propagate(delta):
    global STATE
    old_state = copy.deepcopy(STATE)
    for callback in ON_INPUT_CALLBACKS:
        await callback(old_state, delta)

def get_data():
    global STATE
    return STATE

def calculate_checksum():
    return f"{time.time()}-${random()}"

async def inc_initialized():
    global STATE
    await mutate({"initialized": STATE["initialized"]+1 })