import { SCHEMA_PLAN } from '@shared/pb/schema';
import { PB_ENDPOINT } from '$lib/server/pocketbase';
import { PB_EMAIL, PB_PASSWORD } from '$app/env/private';

let token: string | null = null;

async function auth(): Promise<string> {
	if (token) return token;
	const res = await fetch(`${PB_ENDPOINT}/api/collections/_superusers/auth-with-password`, {
		method: 'POST',
		headers: { 'Content-Type': 'application/json' },
		body: JSON.stringify({ identity: PB_EMAIL, password: PB_PASSWORD })
	});
	const data = await res.json();
	if (!res.ok) throw new Error(`PB auth failed: ${JSON.stringify(data)}`);
	token = data.token;
	return token!;
}

async function getCollection(name: string): Promise<any | null> {
	const t = await auth();
	const res = await fetch(`${PB_ENDPOINT}/api/collections?filter=name='${name}'`, {
		headers: { Authorization: `Bearer ${t}` }
	});
	const data = await res.json();
	return data?.items?.[0] || null;
}

async function createCollection(col: any): Promise<string | null> {
	const t = await auth();
	const res = await fetch(`${PB_ENDPOINT}/api/collections`, {
		method: 'POST',
		headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${t}` },
		body: JSON.stringify(col)
	});
	const data = await res.json();
	if (!res.ok) throw new Error(`Create ${col.name} failed: ${JSON.stringify(data)}`);
	console.log(`  ✓ Created collection: ${col.name}`);
	return data?.id || null;
}

async function updateCollection(id: string, col: any): Promise<void> {
	const t = await auth();
	const res = await fetch(`${PB_ENDPOINT}/api/collections/${id}`, {
		method: 'PATCH',
		headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${t}` },
		body: JSON.stringify(col)
	});
	const data = await res.json();
	if (!res.ok) throw new Error(`Update collection ${id} failed: ${JSON.stringify(data)}`);
	console.log(`  ✓ Updated collection: ${col.name || id}`);
}

async function createRecord(collection: string, data: any): Promise<void> {
	const t = await auth();
	const res = await fetch(`${PB_ENDPOINT}/api/collections/${collection}/records`, {
		method: 'POST',
		headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${t}` },
		body: JSON.stringify(data)
	});
	if (!res.ok) {
		const d = await res.json();
		throw new Error(`Create record ${collection} failed: ${JSON.stringify(d)}`);
	}
}

// Seed two default seasons (Term + Holidays) per family so the family-admin
// season picker always has options from day one and they can tick either on/off.
// Only seeds when a family has zero seasons, so user deletions stick (a deleted
// default never comes back on boot as long as at least one season remains).
async function ensureDefaultSeasons(): Promise<void> {
	const famsCol = await getCollection('fams');
	if (!famsCol) return;
	const t = await auth();
	const famsRes = await fetch(`${PB_ENDPOINT}/api/collections/fams/records?perPage=200`, {
		headers: { Authorization: `Bearer ${t}` }
	});
	const fams = (await famsRes.json()).items || [];
	const defaults = [
		{ name: 'Term', color: '#6366f1', active: true },
		{ name: 'Holidays', color: '#f59e0b', active: true }
	];
	for (const fam of fams) {
		const sRes = await fetch(
			`${PB_ENDPOINT}/api/collections/seasons/records?filter=(famId='${fam.id}')&fields=name&perPage=200`,
			{ headers: { Authorization: `Bearer ${t}` } }
		);
		const have = ((await sRes.json()).items || []) as any[];
		// Only seed defaults for families that have no seasons at all. Seeding
		// per-name (idempotent) forced a deleted default (e.g. "Term time") back
		// on every boot; now a user who removes one keeps it removed as long as
		// at least one season remains.
		if (have.length === 0) {
			for (const d of defaults) {
				await createRecord('seasons', { famId: fam.id, ...d });
				console.log(`  ✓ Seeded season ${d.name} for fam ${fam.id}`);
			}
		}
	}
}

// Apply the custom fields + rules the app relies on to PB's native `users`
// auth collection (created automatically on first serve). Children live here as
// role='child'; username is a password-auth identity so the server can
// authWithPassword(derivedPassword) at OTP join time.
async function ensureUsers(ids: Record<string, string>): Promise<void> {
	const usersCol = await getCollection('users');
	if (!usersCol) throw new Error('users collection not found');
	const famsId = ids.fams || (await getCollection('fams'))?.id;
	if (!famsId) throw new Error('fams collection not found');

	const has = (n: string) => usersCol.fields.some((f: any) => f.name === n);
	let changed = false;

	const emailField = usersCol.fields.find((f: any) => f.name === 'email');
	if (emailField && emailField.required) {
		emailField.required = false;
		changed = true;
	}
	if (!has('famId')) {
		usersCol.fields.push({
			name: 'famId',
			type: 'relation',
			required: false,
			collectionId: famsId,
			maxSelect: 1,
			cascadeDelete: false
		});
		changed = true;
	}
	if (!has('role')) {
		usersCol.fields.push({
			name: 'role',
			type: 'select',
			required: false,
			values: ['parent', 'child'],
			maxSelect: 1
		});
		changed = true;
	}
	if (!has('username')) {
		usersCol.fields.push({ name: 'username', type: 'text', required: true });
		changed = true;
	}
	if (!has('color')) {
		usersCol.fields.push({ name: 'color', type: 'text', required: false });
		changed = true;
	}
	if (!has('passwordResetToken')) {
		usersCol.fields.push({ name: 'passwordResetToken', type: 'text', required: false });
		changed = true;
	}
	if (!has('passwordResetExpiry')) {
		usersCol.fields.push({ name: 'passwordResetExpiry', type: 'text', required: false });
		changed = true;
	}

	let indexes = usersCol.indexes || [];
	if (!indexes.some((i: string) => /username/i.test(i))) {
		indexes = [
			...indexes,
			"CREATE UNIQUE INDEX `idx_username__users` ON `users` (`username`) WHERE `username` != ''"
		];
		changed = true;
	}

	const pwAuth = usersCol.passwordAuth || { enabled: true, identityFields: ['email'] };
	const identityFields = Array.isArray(pwAuth.identityFields) ? pwAuth.identityFields : ['email'];
	if (!identityFields.includes('username')) {
		identityFields.push('username');
		changed = true;
	}

	const listRule = 'famId = @request.auth.famId';
	const parentWrite = "famId = @request.auth.famId && @request.auth.role = 'parent'";
	// Members can edit their own record (name/colour); parents can edit any
	// family member. Delete stays parent-only.
	const selfOrParentWrite =
		"@request.auth.id = id || (famId = @request.auth.famId && @request.auth.role = 'parent')";
	if (
		usersCol.listRule !== listRule ||
		usersCol.viewRule !== listRule ||
		usersCol.updateRule !== selfOrParentWrite ||
		usersCol.deleteRule !== parentWrite
	) {
		changed = true;
	}

	if (changed) {
		await updateCollection(usersCol.id, {
			name: 'users',
			type: 'auth',
			listRule,
			viewRule: listRule,
			createRule: usersCol.createRule || '',
			updateRule: selfOrParentWrite,
			deleteRule: parentWrite,
			fields: usersCol.fields,
			indexes,
			passwordAuth: { enabled: true, identityFields }
		});
	}
}

// Superuser-only OTP store for the child join gate. Holds the rotating code and
// its issue timestamp (20-min window). Not public — read/written via the
// superuser client only.
async function ensureOtp(ids: Record<string, string>): Promise<void> {
	if (await getCollection('otp')) return;
	const famsId = ids.fams || (await getCollection('fams'))?.id;
	const usersId = ids.users || (await getCollection('users'))?.id;
	if (!famsId || !usersId) throw new Error('fams/users collection not found');
	await createCollection({
		name: 'otp',
		type: 'base',
		listRule: null,
		viewRule: null,
		createRule: null,
		updateRule: null,
		deleteRule: null,
		fields: [
			{
				name: 'famId',
				type: 'relation',
				required: true,
				collectionId: famsId,
				maxSelect: 1,
				cascadeDelete: false
			},
			{
				name: 'userId',
				type: 'relation',
				required: true,
				collectionId: usersId,
				maxSelect: 1,
				cascadeDelete: false
			},
			{ name: 'otp', type: 'text', required: false },
			{ name: 'updatedAt', type: 'text', required: false }
		]
	});
}

// Platform access codes — the codes that enable access to the platform. They're
// global (not fam-scoped) and managed via the platform admin page (superuser
// only), so all rules are null like `otp`. A code grants a family a subscription
// for `duration` months (0 = continuous); `expiry` is months-after-createdAt
// (0 = never expires); `active` is a failsafe toggle. Entered at create-family
// and in admin settings.
async function ensureAccessCodes(): Promise<void> {
	if (await getCollection('accesscodes')) {
		await ensureAccessCodeFields();
		await seedAccessCodes();
		return;
	}
	await createCollection({
		name: 'accesscodes',
		type: 'base',
		listRule: null,
		viewRule: null,
		createRule: null,
		updateRule: null,
		deleteRule: null,
		fields: [
			{ name: 'value', type: 'text', required: true, unique: true },
			{ name: 'name', type: 'text', required: true },
			{ name: 'duration', type: 'number', required: false },
			{ name: 'expiry', type: 'number', required: false },
			{ name: 'active', type: 'bool', required: false },
			// When set (>0) this code is a TRIAL code: maps to Stripe
			// trial_period_days at checkout instead of platform access.
			{ name: 'trialDays', type: 'number', required: false },
			{ name: 'createdAt', type: 'date', required: false }
		]
	});
	await seedAccessCodes();
}

// Idempotent field-add for installs where accesscodes predates a field.
async function ensureAccessCodeFields(): Promise<void> {
	const col = await getCollection('accesscodes');
	if (!col) return;
	const has = (n: string) => col.fields.some((f: any) => f.name === n);
	if (!has('trialDays')) {
		await updateCollection(col.id, {
			...col,
			fields: [...col.fields, { name: 'trialDays', type: 'number', required: false }]
		});
	}
}

// Idempotent seeds — developer code + an example trial code.
async function seedAccessCodes(): Promise<void> {
	const t = await auth();
	const seeds = [
		{ value: 'dev123', name: 'developer', duration: 0, expiry: 0, active: true, trialDays: null },
		{
			value: 'FAM3MONTHS',
			name: '3-month trial',
			duration: null,
			expiry: null,
			active: true,
			trialDays: 90
		}
	];
	for (const seed of seeds) {
		const res = await fetch(
			`${PB_ENDPOINT}/api/collections/accesscodes/records?filter=value='${seed.value}'`,
			{ headers: { Authorization: `Bearer ${t}` } }
		);
		const data = await res.json();
		if (data?.items?.length) continue;
		const created = await fetch(`${PB_ENDPOINT}/api/collections/accesscodes/records`, {
			method: 'POST',
			headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${t}` },
			body: JSON.stringify({ ...seed, createdAt: new Date().toISOString() })
		});
		const c = await created.json();
		if (!created.ok) throw new Error(`Seed accesscode failed: ${JSON.stringify(c)}`);
		console.log(`  ✓ Seeded access code: ${seed.name} (${seed.value})`);
	}
}

// Platform settings — a single global record holding the platform feature
// flags (replaces the per-fam fams.featureFlags). Publicly readable (empty
// list/view rules) so every client can deduce flags on app load; writes stay
// superuser-only (null rules), so like otp/accesscodes this lives in
// migrate.ts rather than SCHEMA_PLAN.
async function ensurePlatform(): Promise<void> {
	if (!(await getCollection('platform'))) {
		await createCollection({
			name: 'platform',
			type: 'base',
			listRule: '',
			viewRule: '',
			createRule: null,
			updateRule: null,
			deleteRule: null,
			fields: [
				{ name: 'label', type: 'text', required: true },
				{ name: 'flags', type: 'json', required: false }
			]
		});
	}
	await seedPlatform();
}

// Idempotent seed — create the singleton 'global' settings record if missing.
async function seedPlatform(): Promise<void> {
	const t = await auth();
	const res = await fetch(`${PB_ENDPOINT}/api/collections/platform/records?filter=label='global'`, {
		headers: { Authorization: `Bearer ${t}` }
	});
	const data = await res.json();
	if (data?.items?.length) return;
	const created = await fetch(`${PB_ENDPOINT}/api/collections/platform/records`, {
		method: 'POST',
		headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${t}` },
		body: JSON.stringify({ label: 'global', flags: { debug: false } })
	});
	const c = await created.json();
	if (!created.ok) throw new Error(`Seed platform failed: ${JSON.stringify(c)}`);
	console.log('  ✓ Seeded platform settings (global)');
}

// Bootstrap the full schema on a fresh/wiped PocketBase. Idempotent — skips if
// `fams` already exists (data is disposable; there is no incremental migration
// history).
async function ensureSchema(): Promise<void> {
	if (await getCollection('fams')) {
		console.log('[migrate] Schema already present — skipping bootstrap.');
		return;
	}
	console.log('[migrate] Bootstrapping schema on fresh PocketBase...');

	const ids: Record<string, string> = {};
	const nativeUsers = await getCollection('users');
	if (nativeUsers) ids.users = nativeUsers.id;
	for (const entry of SCHEMA_PLAN) {
		const createdId = await createCollection(entry.build(ids));
		if (createdId) ids[entry.name] = createdId;
	}

	await ensureUsers(ids);
	await ensureOtp(ids);
	console.log('[migrate] Schema bootstrapped.');
}

// Add the access-gating fields to `fams` on installs where it already exists
// (fresh installs get them via SCHEMA_PLAN). Idempotent — only adds missing
// fields.
async function ensureFamFields(): Promise<void> {
	const famsCol = await getCollection('fams');
	if (!famsCol) return;
	const has = (n: string) => famsCol.fields.some((f: any) => f.name === n);
	const needed: any[] = [];
	if (!has('active')) {
		needed.push({ name: 'active', type: 'bool', required: false });
	}
	if (!has('paymentMode')) {
		needed.push({
			name: 'paymentMode',
			type: 'select',
			required: false,
			values: ['none', 'code', 'sub', 'canceled'],
			maxSelect: 1
		});
	}
	if (!has('accessCodeId')) {
		needed.push({ name: 'accessCodeId', type: 'text', required: false });
	}
	if (!has('accessCodeEnteredAt')) {
		needed.push({ name: 'accessCodeEnteredAt', type: 'date', required: false });
	}
	if (needed.length) {
		await updateCollection(famsCol.id, { ...famsCol, fields: [...famsCol.fields, ...needed] });
	}
}

export async function migrate(): Promise<void> {
	console.log('[migrate] Checking PB collection schemas...');
	await ensureSchema();
	// Runs even when the schema already exists (unlike ensureSchema's early
	// return) so new platform collections/fields/seed land on existing installs.
	await ensureFamFields();
	await ensureBonusFields();
	await ensureTemplateFields();
	await ensureAssignedChoreFields();
	await ensureAccessCodes();
	await ensurePlatform();
	await ensureDefaultSeasons();
	console.log('[migrate] Done');
}

// Add colour / icon / description to `assigned_chores` on existing installs so
// family-admins can override a template's look per assignment. Idempotent.
async function ensureAssignedChoreFields(): Promise<void> {
	const col = await getCollection('assigned_chores');
	if (!col) return;
	const has = (n: string) => col.fields.some((f: any) => f.name === n);
	const needed: any[] = [];
	if (!has('description')) needed.push({ name: 'description', type: 'text', required: false });
	if (!has('icon')) needed.push({ name: 'icon', type: 'text', required: false });
	if (!has('color')) needed.push({ name: 'color', type: 'text', required: false });
	if (!has('emoji')) needed.push({ name: 'emoji', type: 'text', required: false });
	// Shared chores: memberId becomes optional, shared boolean tracks original mode
	if (!has('shared')) needed.push({ name: 'shared', type: 'bool', required: false });
	// Todos can be celebration-only (emoji) as well as points/money.
	let changed = !!needed.length;
	const typeField = col.fields.find((f: any) => f.name === 'type');
	if (typeField && Array.isArray(typeField.values) && !typeField.values.includes('emoji')) {
		typeField.values = [...typeField.values, 'emoji'];
		changed = true;
	}
	// Direct todos (created by a parent, not from a template) have no templateId.
	const tplField = col.fields.find((f: any) => f.name === 'templateId');
	if (tplField && tplField.required) {
		tplField.required = false;
		changed = true;
	}
	// memberId must be optional for shared chores (null = shared with all members)
	const memberField = col.fields.find((f: any) => f.name === 'memberId');
	if (memberField && memberField.required) {
		memberField.required = false;
		changed = true;
	}
	if (changed) {
		await updateCollection(col.id, { ...col, fields: [...col.fields] });
	}
	const comp = await getCollection('completions');
	if (comp && !comp.fields.some((f: any) => f.name === 'rewardId')) {
		await updateCollection(comp.id, {
			...comp,
			fields: [...comp.fields, { name: 'rewardId', type: 'text', required: false }]
		});
	}
}

// Add the pocket-money fields to bonus collections on existing installs, and
// backfill a default pocket-money droplet (£10 / 50% chores) for any child that
// doesn't yet have one. Idempotent.
async function ensureBonusFields(): Promise<void> {
	for (const name of ['bonus_templates', 'bonus_configs']) {
		const col = await getCollection(name);
		if (!col) continue;
		const has = (n: string) => col.fields.some((f: any) => f.name === n);
		let changed = false;
		const fields = [...col.fields];
		if (!has('thresholdType')) {
			fields.push({
				name: 'thresholdType',
				type: 'select',
				required: false,
				values: ['points', 'percent'],
				maxSelect: 1
			});
			changed = true;
		}
		if (!has('isPocketMoney')) {
			fields.push({ name: 'isPocketMoney', type: 'bool', required: false });
			changed = true;
		}
		// Standalone-reward progress window (bonus_configs only): how far progress
		// counts (`completeBy`) and the window's start/custom-end dates.
		if (name === 'bonus_configs') {
			if (!has('completeBy')) {
				fields.push({
					name: 'completeBy',
					type: 'select',
					required: false,
					values: ['unlimited', 'week', 'custom'],
					maxSelect: 1
				});
				changed = true;
			}
			if (!has('startDate')) {
				fields.push({ name: 'startDate', type: 'text', required: false });
				changed = true;
			}
			if (!has('completeByDate')) {
				fields.push({ name: 'completeByDate', type: 'text', required: false });
				changed = true;
			}
		}
		if (name === 'bonus_configs' && !has('targetChoreId')) {
			fields.push({ name: 'targetChoreId', type: 'text', required: false });
			changed = true;
		}
		// rewardValue must be optional so an unset pocket-money droplet can exist.
		const rv = fields.find((f: any) => f.name === 'rewardValue');
		if (rv && rv.required) {
			rv.required = false;
			changed = true;
		}
		if (changed) await updateCollection(col.id, { ...col, fields });
	}
	await backfillPocketMoney();
}

async function backfillPocketMoney(): Promise<void> {
	const t = await auth();
	// Flag legacy pocket-money configs that predate the isPocketMoney field so
	// the dashboard recognises them (and we don't create duplicates below).
	const legacyRes = await fetch(
		`${PB_ENDPOINT}/api/collections/bonus_configs/records?filter=${encodeURIComponent(
			"isPocketMoney!=true && name~'pocket' && thresholdType='percent'"
		)}&perPage=500`,
		{ headers: { Authorization: `Bearer ${t}` } }
	);
	for (const rec of (await legacyRes.json())?.items || []) {
		await fetch(`${PB_ENDPOINT}/api/collections/bonus_configs/records/${rec.id}`, {
			method: 'PATCH',
			headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${t}` },
			body: JSON.stringify({ isPocketMoney: true })
		}).catch(() => {});
	}
	const childrenRes = await fetch(
		`${PB_ENDPOINT}/api/collections/users/records?filter=role='child'&perPage=500`,
		{ headers: { Authorization: `Bearer ${t}` } }
	);
	const children: any[] = (await childrenRes.json())?.items || [];
	for (const c of children) {
		const existingRes = await fetch(
			`${PB_ENDPOINT}/api/collections/bonus_configs/records?filter=famId='${c.famId}' && memberId='${c.id}' && isPocketMoney=true`,
			{ headers: { Authorization: `Bearer ${t}` } }
		);
		if ((await existingRes.json())?.items?.length) continue;
		await fetch(`${PB_ENDPOINT}/api/collections/bonus_configs/records`, {
			method: 'POST',
			headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${t}` },
			body: JSON.stringify({
				famId: c.famId,
				name: 'Pocket Money',
				target: 'individual',
				type: 'threshold',
				thresholdType: 'percent',
				occurrence: 'recurring',
				rewardType: 'cash',
				rewardValue: 10,
				criteriaValue: 50,
				memberId: c.id,
				period: 'weekly',
				status: 'active',
				isPocketMoney: true
			})
		}).catch(() => {});
	}
	console.log('[migrate] Pocket-money droplets ensured.');
}

// Promote chore_templates / bonus_templates to platform-owned: add global/icon/
// color fields, make famId optional, and relax read rules so any family can see
// global (platform) templates as assignable droplets. Idempotent. Seeds a
// starter set of global templates on first run for out-of-the-box usage.
async function ensureTemplateFields(): Promise<void> {
	const readRule = 'global = true || famId = @request.auth.famId';
	for (const name of ['chore_templates', 'bonus_templates']) {
		const col = await getCollection(name);
		if (!col) continue;
		const has = (n: string) => col.fields.some((f: any) => f.name === n);
		let changed = false;
		const fields = [...col.fields];
		for (const f of [
			{ name: 'global', type: 'bool', required: false },
			{ name: 'icon', type: 'text', required: false },
			{ name: 'color', type: 'text', required: false }
		]) {
			if (!has(f.name)) {
				fields.push(f);
				changed = true;
			}
		}
		const famId = fields.find((f: any) => f.name === 'famId');
		if (famId && famId.required) {
			famId.required = false;
			changed = true;
		}
		if (col.listRule !== readRule || col.viewRule !== readRule) {
			col.listRule = readRule;
			col.viewRule = readRule;
			changed = true;
		}
		if (changed) await updateCollection(col.id, { ...col, fields });
	}
	await seedGlobalTemplates();
}

const GLOBAL_TEMPLATE_ICONS = [
	'Bed',
	'Sparkles',
	'BookOpen',
	'Utensils',
	'Wallet',
	'Trophy',
	'Star',
	'Moon',
	'Sun',
	'Apple',
	'Car',
	'Gamepad2',
	'Music',
	'Shirt',
	'Leaf',
	'Heart',
	'Gift',
	'Timer'
];

async function seedGlobalTemplates(): Promise<void> {
	const t = await auth();
	const countGlobal = async (name: string) => {
		const res = await fetch(
			`${PB_ENDPOINT}/api/collections/${name}/records?filter=global=true&perPage=1`,
			{ headers: { Authorization: `Bearer ${t}` } }
		);
		return (await res.json())?.items?.length || 0;
	};
	if ((await countGlobal('chore_templates')) > 0 || (await countGlobal('bonus_templates')) > 0) {
		console.log('[migrate] Global templates already present — skipping seed.');
		return;
	}

	const choreSeeds = [
		{
			name: 'Make Bed',
			defaultFrequency: 'daily',
			defaultType: 'points',
			defaultValue: 2,
			icon: 'Bed',
			color: '#6366f1'
		},
		{
			name: 'Tidy Room',
			defaultFrequency: 'weekly',
			defaultType: 'points',
			defaultValue: 10,
			icon: 'Sparkles',
			color: '#8b5cf6'
		},
		{
			name: 'Homework',
			defaultFrequency: 'daily',
			defaultType: 'points',
			defaultValue: 5,
			icon: 'BookOpen',
			color: '#0ea5e9'
		},
		{
			name: 'Set Table',
			defaultFrequency: 'daily',
			defaultType: 'money',
			defaultValue: 1,
			icon: 'Utensils',
			color: '#10b981'
		}
	];
	const bonusSeeds = [
		{
			name: 'Pocket Money',
			target: 'individual',
			type: 'threshold',
			thresholdType: 'percent',
			occurrence: 'recurring',
			rewardType: 'cash',
			rewardValue: '',
			criteriaValue: 50,
			period: 'weekly',
			isPocketMoney: true,
			icon: 'Wallet',
			color: '#22c55e'
		},
		{
			name: 'Reading Bonus',
			target: 'individual',
			type: 'count',
			occurrence: 'recurring',
			rewardType: 'points',
			rewardValue: '50',
			criteriaValue: 5,
			period: 'weekly',
			icon: 'BookOpen',
			color: '#f59e0b'
		},
		{
			name: 'Star of the Week',
			target: 'competitive',
			type: 'threshold',
			thresholdType: 'points',
			occurrence: 'weekly',
			rewardType: 'prize',
			rewardValue: 'Treat',
			criteriaValue: 100,
			period: 'weekly',
			icon: 'Trophy',
			color: '#ef4444'
		}
	];

	for (const s of choreSeeds) {
		await fetch(`${PB_ENDPOINT}/api/collections/chore_templates/records`, {
			method: 'POST',
			headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${t}` },
			body: JSON.stringify({ ...s, global: true })
		}).catch(() => {});
	}
	for (const s of bonusSeeds) {
		await fetch(`${PB_ENDPOINT}/api/collections/bonus_templates/records`, {
			method: 'POST',
			headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${t}` },
			body: JSON.stringify({ ...s, global: true })
		}).catch(() => {});
	}
	console.log('[migrate] Seeded global templates.');
}

export { GLOBAL_TEMPLATE_ICONS };