/**
 * This function is a wrapper for Svelte writables, a very useful construct in Svelte code to share state between components and page routes.
 * Writables can also be reactive, triggering a re-render when the value changes. While developing Open Web UI desktop, I found it necessary
 * to also share state between windows, like the main window and the chat bar. The cross window writable effectively solves this problem by
 * using an existing code to share state, tauri-plugin-store, but without exposing complicated update-and-subscribe logic to the developer.
 *
 * I also uploaded this as gist because I think it might be useful to others, and could easily be modified to support IPC, shared memory, etc.
 *
 * @param name Name of the key in the backing JSON store file
 * @param initialValue Initial value of the writable, replaced by the value from the store (upon load) if it exists
 * @param persist Persist this value after application restarts
 * @returns Writable object for both updating and subscribing
 */
export function crossWindowWritable<T>(name: string, initialValue?: T, persist: boolean = false): Writable<T> {
  console.debug("Creating cross window store for", name)
  const wrappedStore = writable<T>(initialValue)
  let currentValue = get(wrappedStore)
  let storePromise: Promise<Store | null>

  // Initialize store connection async because writables must be returned sync
  storePromise = (async () => {
    try {
      // Load the store from cache, or load from disk with options.
      const store = (await getStore(APP_STORE_FILE)) || (await load(APP_STORE_FILE, { autoSave: false, createNew: false }))

      // Set the writable to the value from the store if it exists, otherwise set the store to the initial value
      const stored = await store.get(name)
      if (stored !== undefined) {
        currentValue = stored as T
        console.debug("currentValue from store for", name, "is", currentValue)
        wrappedStore.set(currentValue)
      } else if (initialValue !== undefined) {
        console.debug("currentValue from initialValue for", name, "is", currentValue)
        await store.set(name, initialValue)
        await store.save()
      }

      // Subscribe to changes from other windows
      const unlistener = await store.onKeyChange(name, async (newValue: T | undefined) => {
        console.debug(name, "onKeyChange event", await store.entries())

        // Do not update writable if the value is undefined or equal.
        if (newValue === undefined) {
          console.warn(`Store value changed to undefined for ${name}, skipping update`)
          return
        } else if (equal(newValue, currentValue)) {
          console.debug(`Store value idempotent change for ${name}, skipping update`)
          return
        } else if (newValue === null) {
          // Null is okay
          console.warn(`Store value changed to null for ${name}`)
        }

        console.debug(`${name} value changed from`, currentValue, "to", newValue)
        currentValue = newValue
        wrappedStore.set(newValue)
      })

      // Unsubscribe on window close, to prevent leaks
      getCurrentWindow().once("tauri://close-requested", unlistener)

      return store
    } catch (e) {
      // Throwing does not properly propagate the error but subscribing to this invalid writable will
      console.error(`Failed to initialize store for ${name}:`, e)
      return null
    }
  })()

  // Return an object with the same interface as Writable
  return {
    set: (value: T) => {
      // Do not update writable if the value is undefined or equal
      if (!equal(currentValue, value)) {
        if (value === undefined) {
          console.warn("Store for", name, "set to undefined, skipping update")
          return
        } else if (value === null) {
          // Null is okay
          console.warn("Store for", name, "set to null")
        }

        // Track our current value and update the underlying writable
        currentValue = value
        wrappedStore.set(value)

        // Update the backing store
        storePromise.then(async (store) => {
          if (store) {
            await store.set(name, value)
            await store.save()
          } else {
            console.error("Store failed to initialized")
          }
        })
      }
    },
    // Subscribe functionality does not have to change
    subscribe: wrappedStore.subscribe,
    update: (updater: (value: T) => T) => {
      const newValue = updater(currentValue)
      // Do not update writable if the value is undefined or equal
      if (!equal(currentValue, newValue)) {
        if (newValue === undefined) {
          console.warn("Store for", name, "set to undefined, skipping update")
          return
        } else if (newValue === null) {
          // Null is okay
          console.warn("Store for", name, "set to null")
        }

        // Track our current value and update the underlying writable
        currentValue = newValue
        wrappedStore.set(newValue)

        // Update the backing store
        storePromise.then(async (store) => {
          if (store) {
            await store.set(name, newValue)
            await store.save()
          } else {
            console.error("Store failed to initialized")
          }
        })
      }
    },
  }
}