import {
	electrobun,
	type XrpTxEntry,
	type XrpWalletInfo,
} from '$lib/electrobun'
import { tryCatch } from '@koins/utils'

export const xrpNetwork = {
	id: 'xrp',
	name: 'XRP Ledger',
	symbol: 'XRP',
	explorerUrl: 'https://xrpscan.com/tx/',
	explorerAddressUrl: 'https://xrpscan.com/account/',
} as const

export const createXrpWallet = () => {
	let accountType = $state<'xrp' | null>(null)
	let ready = $state(false)
	let biometricAvailable = $state(false)
	let seed = $state('')
	let address = $state('')
	let balance = $state('0')
	let funded = $state(true)
	let price = $state<string | null>(null)
	let fee = $state<string | null>(null)
	let transactions = $state<XrpTxEntry[]>([])
	let loadingBalance = $state(false)
	let loadingTransactions = $state(false)
	let loading = $state(false)
	let error = $state('')
	let wallets = $state<XrpWalletInfo[]>([])
	let balances = $state<Record<string, { balance: number; funded: boolean }>>({})
	let balancesLoading = $state(false)
	let fetchBalancesInFlight = false
	let currentWalletId = $state<string | null>(null)
	let currentPasswordHash = $state<string | null>(null)

	async function hashPassword(
		password: string,
		salt?: string,
	): Promise<{ salt: string; hash: string }> {
		const s =
			salt ??
			Array.from(crypto.getRandomValues(new Uint8Array(16)), (b) =>
				b.toString(16).padStart(2, '0'),
			).join('')
		const enc = new TextEncoder()
		const key = await crypto.subtle.importKey(
			'raw',
			enc.encode(password + s),
			'PBKDF2',
			false,
			['deriveBits'],
		)
		const bits = await crypto.subtle.deriveBits(
			{
				name: 'PBKDF2',
				salt: enc.encode(s),
				iterations: 100_000,
				hash: 'SHA-256',
			},
			key,
			256,
		)
		const hash = Array.from(new Uint8Array(bits), (b) =>
			b.toString(16).padStart(2, '0'),
		).join('')
		return { salt: s, hash }
	}

	const checkBiometric = async () => {
		if (!electrobun.rpc) return
		const [ok] = await tryCatch(
			electrobun.rpc.request.biometricCanAuth({}),
		)
		biometricAvailable = ok === true
	}

	let initPromise: Promise<void> | null = null
	const init = async () => {
		if (initPromise) return initPromise
		initPromise = (async () => {
			if (!electrobun.rpc) return
			const [walletList] = await tryCatch(
				electrobun.rpc.request.xrpListWallets({}),
			)
			if (walletList) {
				wallets = walletList
				if (walletList.length > 0 && !currentWalletId) {
					currentWalletId = walletList[0].id
				}
			}
			await checkBiometric()
			ready = true
		})()
		return initPromise
	}

	const login = async () => {
		accountType = 'xrp'
		if (seed) await refresh()
	}

	const logout = async () => {
		accountType = null
		clearWallet()
	}

	const clearWallet = () => {
		seed = ''
		address = ''
		balance = '0'
		funded = true
		transactions = []
		error = ''
		currentPasswordHash = null
	}

	const loadSeedForWallet = async (walletId: string) => {
		if (!electrobun.rpc) return false
		const wallet = wallets.find((w) => w.id === walletId)
		if (!wallet) return false
		const [vaultSeed] = await tryCatch(
			electrobun.rpc.request.xrpGetSeed({
				vaultKey: wallet.vaultKey,
			}),
		)
		if (!vaultSeed) return false
		seed = vaultSeed
		address = wallet.address
		await refresh()
		return true
	}

	const unlockWithBiometrics = async () => {
		if (!electrobun.rpc) return false
		const [authed] = await tryCatch(
			electrobun.rpc.request.biometricAuth({
				reason: 'Unlock wallet',
			}),
		)
		if (!authed) return false
		if (!currentWalletId) return false
		return loadSeedForWallet(currentWalletId)
	}

	const unlockWithPassword = async (password: string) => {
		if (!currentPasswordHash || !currentWalletId) return false
		try {
			const { salt, hash } = JSON.parse(currentPasswordHash)
			const { hash: check } = await hashPassword(password, salt)
			if (check !== hash) return false
			return loadSeedForWallet(currentWalletId)
		} catch {
			return false
		}
	}

	const selectWallet = async (walletId: string) => {
		currentWalletId = walletId
		clearWallet()
		const wallet = wallets.find((w) => w.id === walletId)
		if (!wallet) return
		if (wallet.hasPassword && electrobun.rpc) {
			const [ph] = await tryCatch(
				electrobun.rpc.request.getSecret({
					service: 'koins',
					name: `xrp_auth_${walletId}`,
				}),
			)
			if (ph) {
				currentPasswordHash = ph
			}
		} else {
			currentPasswordHash = null
		}
	}

	const selectAndUnlockWallet = async (walletId: string) => {
		await selectWallet(walletId)
		if (!currentPasswordHash && biometricAvailable) {
			return unlockWithBiometrics()
		}
		if (!currentPasswordHash) {
			return loadSeedForWallet(walletId)
		}
		return false
	}

	const autoUnlock = async (walletId?: string) => {
		const id = walletId ?? currentWalletId ?? wallets[0]?.id
		if (!id) return false
		currentWalletId = id
		const wallet = wallets.find((w) => w.id === id)
		if (!wallet) return false
		if (electrobun.rpc && wallet.hasPassword) {
			const [ph] = await tryCatch(
				electrobun.rpc.request.getSecret({
					service: 'koins',
					name: `xrp_auth_${id}`,
				}),
			)
			if (ph) currentPasswordHash = ph
		} else {
			currentPasswordHash = null
		}
		const ok = await loadSeedForWallet(id)
		if (ok) accountType = 'xrp'
		return ok
	}

	const saveWallet = async (
		kind: 'create' | 'import',
		name: string,
		secret: string | undefined,
		password?: string,
	) => {
		loading = true
		error = ''
		try {
			if (!electrobun.rpc) throw new Error('RPC not available')
			let passwordHash: string | undefined
			if (password) {
				const ph = await hashPassword(password)
				passwordHash = JSON.stringify(ph)
			}
			const result: {
				id: string
				address: string
				createdAt: string
				seed?: string
			} =
				kind === 'create'
					? await electrobun.rpc.request.xrpCreateWallet({
							name,
							hasPassword: !!passwordHash,
						})
					: await electrobun.rpc.request.xrpImportWallet({
							name,
							secret: secret!,
							hasPassword: !!passwordHash,
						})

			if (passwordHash) {
				await electrobun.rpc.request.setSecret({
					service: 'koins',
					name: `xrp_auth_${result.id}`,
					value: passwordHash,
				})
			}

			const newWallet: XrpWalletInfo = {
				id: result.id,
				name,
				address: result.address,
				hasPassword: !!passwordHash,
				vaultKey: `xrp_seed_${result.id}`,
				createdAt: result.createdAt,
			}
			wallets = [...wallets, newWallet]
			currentWalletId = result.id
			if (passwordHash) currentPasswordHash = passwordHash
			seed = result.seed ?? secret!
			address = result.address
			await refresh()
			return result.seed
		} catch (e) {
			error = e instanceof Error ? e.message : 'Failed to save wallet'
			throw e
		} finally {
			loading = false
		}
	}

	const createWallet = async (name: string, password?: string) => {
		return saveWallet('create', name, undefined, password)
	}

	const importWallet = async (
		name: string,
		secret: string,
		password?: string,
	) => {
		return saveWallet('import', name, secret, password)
	}

	const deleteWallet = async (walletId: string) => {
		await electrobun.rpc?.request.xrpDeleteWallet({ id: walletId })
		wallets = wallets.filter((w) => w.id !== walletId)
		if (currentWalletId === walletId) {
			clearWallet()
			currentWalletId = wallets.length > 0 ? wallets[0].id : null
		}
	}

	const clearSelection = () => {
		clearWallet()
		currentWalletId = null
	}

	const refresh = async () => {
		if (!address || !electrobun.rpc) return
		const rpc = electrobun.rpc
		loadingBalance = true
		loadingTransactions = true
		error = ''
		;(async () => {
			const [bal] = await tryCatch(
				rpc.request.xrpGetBalance({ address }),
			)
			if (bal) {
				balance = bal.balance
				funded = bal.funded
			}
			const [p] = await tryCatch(rpc.request.fetchXrpPrice({}))
			if (p) price = p.usd
			const [f] = await tryCatch(rpc.request.xrpGetFee({}))
			if (f) fee = f.fee
			loadingBalance = false
		})()
		;(async () => {
			const [txs] = await tryCatch(
				rpc.request.xrpGetTransactions({ address }),
			)
			if (txs) transactions = txs
			loadingTransactions = false
		})()
	}

	const fetchBalances = async () => {
		const rpc = electrobun.rpc
		if (!rpc || fetchBalancesInFlight) return
		if (wallets.length === 0) return
		fetchBalancesInFlight = true
		balancesLoading = true
		try {
			const [p] = await tryCatch(rpc.request.fetchXrpPrice({}))
			if (p) price = p.usd
			await Promise.allSettled(
				wallets.map(async (w) => {
					const [res] = await tryCatch(
						rpc.request.xrpGetBalance({ address: w.address }),
					)
					if (res) {
						balances[w.address] = {
							balance: parseFloat(res.balance),
							funded: res.funded,
						}
					}
				}),
			)
		} finally {
			balancesLoading = false
			fetchBalancesInFlight = false
		}
	}

	const send = async (
		to: string,
		amount: string,
		destinationTag?: number,
	) => {
		if (!electrobun.rpc || !seed) throw new Error('Wallet not unlocked')
		const result = await electrobun.rpc.request.xrpSend({
			secret: seed,
			to,
			amount,
			destinationTag,
		})
		await refresh()
		return result
	}

	const lock = () => {
		clearWallet()
	}

	const reset = () => {
		clearWallet()
		wallets = []
		currentWalletId = null
	}

	const resetApp = async () => {
		if (!electrobun.rpc) return false
		const [ok] = await tryCatch(electrobun.rpc.request.resetApp({}))
		if (!ok) return false
		reset()
		return true
	}

	return {
		get accountType() {
			return accountType
		},
		get ready() {
			return ready
		},
		get biometricAvailable() {
			return biometricAvailable
		},
		get seed() {
			return seed
		},
		get address() {
			return address
		},
		get balance() {
			return balance
		},
		get funded() {
			return funded
		},
		get price() {
			return price
		},
		get fee() {
			return fee
		},
		get transactions() {
			return transactions
		},
		get loading() {
			return loading || loadingBalance || loadingTransactions
		},
		get loadingBalance() {
			return loadingBalance
		},
		get loadingTransactions() {
			return loadingTransactions
		},
		get error() {
			return error
		},
		get wallets() {
			return wallets
		},
		get balances() {
			return balances
		},
		get balancesLoading() {
			return balancesLoading
		},
		get currentWalletId() {
			return currentWalletId
		},
		get currentWallet() {
			return wallets.find((w) => w.id === currentWalletId) ?? null
		},
		get isLocked() {
			return !!currentWalletId && !seed
		},
		get hasWallets() {
			return wallets.length > 0
		},
		get currentPasswordHash() {
			return currentPasswordHash
		},
		get explorerAddressUrl() {
			return address ? `${xrpNetwork.explorerAddressUrl}${address}` : ''
		},
		set error(v: string) {
			error = v
		},
		init,
		login,
		logout,
		refresh,
		fetchBalances,
		createWallet,
		importWallet,
		lock,
		reset,
		resetApp,
		unlockWithBiometrics,
		unlockWithPassword,
		hashPassword,
		selectWallet,
		selectAndUnlockWallet,
		autoUnlock,
		loadSeedForWallet,
		deleteWallet,
		clearSelection,
		send,
	}
}

// Singleton: calling XrpWallet() always returns the same instance, so no
// component can ever create a second, disconnected wallet state.
type XrpWalletStore = ReturnType<typeof createXrpWallet>

let xrpWalletInstance: XrpWalletStore | null = null

export const XrpWallet = (): XrpWalletStore => {
	if (!xrpWalletInstance) xrpWalletInstance = createXrpWallet()
	return xrpWalletInstance
}

export const xrpWallet = XrpWallet()