import "jasmine";
import {MapStore} from "../../../src/Stores/Utils/MapStore";
import type {Readable, Writable} from "svelte/store";
import {get, writable} from "svelte/store";

describe("Main store", () => {
    it("Set / delete / clear triggers main store updates", () => {
        const mapStore = new MapStore<string, string>();

        let triggered = false;

        mapStore.subscribe((map) => {
            triggered = true;
            expect(map).toBe(mapStore);
        })

        expect(triggered).toBeTrue();
        triggered = false;
        mapStore.set('foo', 'bar');
        expect(triggered).toBeTrue();

        triggered = false;
        mapStore.delete('baz');
        expect(triggered).toBe(false);
        mapStore.delete('foo');
        expect(triggered).toBe(true);

        triggered = false;
        mapStore.clear();
        expect(triggered).toBe(true);
    });

    it("generates stores for keys with getStore", () => {

        const mapStore = new MapStore<string, string>();

        let valueReceivedInStoreForFoo: string|undefined;
        let valueReceivedInStoreForBar: string|undefined;

        mapStore.set('foo', 'someValue');

        mapStore.getStore('foo').subscribe((value) => {
            valueReceivedInStoreForFoo = value;
        });
        const unsubscribeBar = mapStore.getStore('bar').subscribe((value) => {
            valueReceivedInStoreForBar = value;
        });

        expect(valueReceivedInStoreForFoo).toBe('someValue');
        expect(valueReceivedInStoreForBar).toBe(undefined);
        mapStore.set('foo', 'someOtherValue');
        expect(valueReceivedInStoreForFoo).toBe('someOtherValue');
        mapStore.delete('foo');
        expect(valueReceivedInStoreForFoo).toBe(undefined);
        mapStore.set('bar', 'baz');
        expect(valueReceivedInStoreForBar).toBe('baz');
        mapStore.clear();
        expect(valueReceivedInStoreForBar).toBe(undefined);
        unsubscribeBar();
        mapStore.set('bar', 'fiz');
        expect(valueReceivedInStoreForBar).toBe(undefined);
    });

    it("generates stores with getStoreByAccessor", () => {
        const mapStore = new MapStore<string, {
            foo: string,
            store: Writable<string>
        }>();

        const fooStore = mapStore.getNestedStore('foo', (value) => {
            return value.store;
        });

        mapStore.set('foo', {
            foo: 'bar',
            store: writable('init')
        });

        expect(get(fooStore)).toBe('init');

        mapStore.get('foo')?.store.set('newVal');

        expect(get(fooStore)).toBe('newVal');

        mapStore.set('foo', {
            foo: 'bar',
            store: writable('anotherVal')
        });

        expect(get(fooStore)).toBe('anotherVal');

        mapStore.delete('foo');

        expect(get(fooStore)).toBeUndefined();

    });
});