import type { Static, TObject } from '@sinclair/typebox'
import type { EntityID } from '@wovin/core/applog'
import type { Thread } from '@wovin/core/thread'
import type { ConstructorType } from '@wovin/core/types'
import type { TypeMapKeys, TypeMapValueTB, VMap, VMstatic } from './utils-typemap'
import { TypeCompiler } from '@sinclair/typebox/compiler'
import { dateNowIso, EntityID_LENGTH, getHashID } from '@wovin/core/applog'
import { lastWriteWins } from '@wovin/core/query'
import { rollingFilter } from '@wovin/core/thread'
import { Logger } from 'besonders-logger'
import { useEntityAt, useRawThread, withDS } from '../../ui/reactive'
import { insertApplogs } from '../ApplogDB'
import { ObjectBuilder } from './builder'
import { KnownAttrs, UniVMaps } from './utils-typemap'

const { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO, { prefix: '[VMfactory]' }) // eslint-disable-line unused-imports/no-unused-vars

export function getInitializedMap<VMT, VMnameT extends TypeMapKeys>(VMname: VMnameT, thread: Thread) {
	let mapForThread = UniVMaps.get(thread)
	if (!mapForThread) {
		mapForThread = new Map() // empty map for the actual VMs
		DEBUG('created new map for thread', thread)
		UniVMaps.set(thread, mapForThread)
	}
	if (mapForThread.get(VMname)) {
		VERBOSE('using existing map', VMname, { UniVMaps, thread })
	} else {
		mapForThread.set(VMname, new Map())
		DEBUG('created new map for VM', VMname, { UniVMaps, thread })
	}
	return mapForThread as VMap<VMT>
}

export function getBaseVMtoExtend<TBtype extends TObject>(
	VMname: string,
	VMtype: TBtype,
	skipGetters: string[] = [],
) {
	// const attrs = VMtype.properties
	const attrs = KnownAttrs[VMname]
	const lowerCaseAttrNamespace = VMname.toLowerCase()

	const getMappedVM = (en, thread) => {
		const thisVMap = getVMap(thread)
		if (!thisVMap) {
			throw ERROR('missing VMap for', { thisVMap, thread })
		}
		return thisVMap.get(en)
	}
	const getVMap = <T>(thread: Thread) => {
		const mapForThread = getInitializedMap<T, typeof VMname>(VMname, thread)
		const thisVMap = mapForThread.get(VMname)
		VERBOSE('get VMap', VMname, { thread, UniVMaps, thisVMap })
		return thisVMap
	}

	VERBOSE('getBaseVMtoExtend', { VMname, VMtype, attrs })
	const compiledChecker = TypeCompiler.Compile(VMtype)
	type VMtypeT = Static<typeof VMtype>

	type VMtypeI = {
		[P in keyof VMtypeT]: string
	}
	class BaseVM {
		static get<T extends typeof BaseVM>(this: T, en: EntityID, thread: Thread) /* : InstanceType<T> */ {
			VERBOSE(`[getVM<${VMname}>]`, en, this, thread)

			const thisVMap = getVMap<T>(thread)
			const existing = getMappedVM(en, thread)
			if (existing) {
				const dummyThis = new this(null, null, 'imsure')
				!!(typeof existing !== typeof dummyThis) && WARN('type mismatch in VMap', { existing, dummyThis }) // HACK: type "check"
				return existing as InstanceType<T> // HACK: type assumption
			}

			const newVM = new this(en, thread, 'imsure') as InstanceType<T>
			VERBOSE(`[getVM<${VMname}>] newVM:`, { newVM, hasInit: (newVM as any).initialize })
			if ((newVM as any).initialize) {
				;(newVM as any).initialize(newVM, thread)
			}
			thisVMap.set(en, newVM)
			return newVM
		}

		setDeleted(thread = this.thread) {
			insertApplogs(thread, [{ en: this.en, at: 'isDeleted', vl: true }])
		}

		get isDeleted() {
			// HACK: lastWriteWins
			return withDS(lastWriteWins(this.thread, { tolerateAlreadyFiltered: true }), () => useEntityAt<boolean>(this.en, `isDeleted`)[0]())
		}

		/*
	// TODO consider generic isDeleted setter
	set isDeleted(deleted:boolean) {
		useEntityAt<boolean>(this.en, `isDeleted`)[1](true)
	}
	 */
		constructor(
			public en,
			public thread: Thread,
			deprecationWarning: 'imsure',
		) {
			if (deprecationWarning !== 'imsure') {
				const existing = getMappedVM(en, thread)
				if (existing) {
					throw ERROR('deprecated: use getVM instead of constructor')
				}
			}
			if (this.en === null && this.thread === null) {
				VERBOSE('returning dummy instance for typechecking never to be initialized')
				return
			}
			DEBUG('initalizing', VMname, en, { skipGetters, thread, VMtype, selff: self, thiss: this, init: (this as any).initialize })

			// add getters and setters for eachKnownAttr of the VMtype
			for (const eachAttr of attrs) {
				if (eachAttr === 'en' || skipGetters.includes(eachAttr)) {
					continue
				}
				const [getter, setter] = withDS(
					lastWriteWins(this.thread, { tolerateAlreadyFiltered: true }), // HACK: lastWriteWins
					() => useEntityAt<string>(this.en, `${lowerCaseAttrNamespace}/${eachAttr.toString()}`),
				)
				Object.defineProperty(this, eachAttr.toString(), {
					get: getter, // () { return getter }, // warning this was not reactive when useEntityAt returned a memo
					set: setter,
					enumerable: true,
					configurable: true,
				})

				// ? also add {at}PvVl and {at}PvCID ?
				VERBOSE('added getter and setter for', { eachAttr, instance: this })
			}
			// // @ts-expect-error
			// return existing as VMstatic<whichVM> & ReturnType<this>
			// type ReturnT = BaseVM & VMtypeT
			// // type ReturnT = ReturnType<BaseVM> & VMTypeT
			// return this as ReturnT
		}

		get entityThread() {
			return rollingFilter(this.thread, { en: this.en })
		}

		get description() {
			return `I am an instance of ${this.constructor.name} with en=${this.en}`
		}

		static buildNew(init: Partial<VMtypeT> = {}, en?: EntityID) {
			return ObjectBuilder.create<VMtypeT>(init, en, VMname)
		}

		/**
		 * @param init
		 * @returns ObjectBuilder for the given type
		 */
		buildUpdate(init: Partial<VMtypeT> = {}) {
			return ObjectBuilder.create<VMtypeT>(init, this.en, VMname)
		}

		check = compiledChecker // TODO try it out
		get typeErrors() {
			return [...this.check.Errors(this)]
		}
	}
	// type ConstructorType<T> = new(...args: any[]) => T

	type ReturnT = ConstructorType<BaseVM, typeof BaseVM> & ConstructorType<VMtypeT>
	return BaseVM as unknown as ReturnT
}

export function getUseFx<
	entityVM extends ReturnType<typeof getBaseVMtoExtend<TypeMapValueTB<entityT>>>,
	entityT extends TypeMapKeys = TypeMapKeys,
>(
	VMname: entityT,
	VMclass: entityVM,
	// Bclass: entityB,
) {
	return function use(prop: string | Partial<VMstatic<entityT>>, ds?: Thread) {
		if (!prop) {
			return null // HACK: wrongly makes TS think the result is never empty
		}
		let en: string, initUp: Omit<Partial<VMstatic<entityT>>, 'en'>
		if (typeof prop === 'string') {
			en = prop
			initUp = {}
		} else {
			;({ en, ...initUp } = prop as Partial<VMstatic<entityT>>)
		}
		if (!en) {
			const init = { ...initUp, ts: dateNowIso() }
			en = getHashID(init, EntityID_LENGTH)
			DEBUG('creating new', { en, init })
		}
		ds = ds ?? useRawThread()
		VERBOSE('use', VMname, en, VMclass)
		const instanceVM = VMclass.get(en, ds) // if new, this RelVM will have no data, but should react to relB.commit()
		// const instanceB = Bclass.create(initUp, en, VMname) as InstanceType<entityB> // the "restProps" will be already on the Builder
		// const returnArray = [instanceVM, instanceB] as const
		VERBOSE('deprecating use with the array nonesense')
		return instanceVM as InstanceType<typeof VMclass>
	}
}
export function getObjectBuilderFor<whichVM extends TypeMapKeys = TypeMapKeys>() {
}