import { Handlers } from '$fresh/server.ts'
import { Task, TaskModel } from '@homeman/models.ts'
import { db, kv } from '@homeman/db.ts'
import { ulid } from 'https://deno.land/x/ulid@v0.3.0/mod.ts'
import { z } from 'https://deno.land/x/zod@v3.21.4/mod.ts'

const TaskPayload = TaskModel.partial({ id: true })
type TaskPayload = z.infer<typeof TaskPayload>

async function createOrUpdate(task: TaskPayload) {
	if (!task.id || task.id === '') {
		const newTask: Task = {
			...task,
			id: ulid(),
		}
		const result = await db.tasks.create({ data: newTask })
		await kv.set(['last_task_updated'], newTask.id)
		return result
	} else {
		const result = await db.tasks.update({ where: { id: task.id }, data: task })
		await kv.set(['last_task_updated'], task.id)
		return result
	}
}

export const handler: Handlers<Task | null> = {
	async POST(req, _ctx) {
		if (req.headers.get('content-type')?.includes('json')) {
			const result = await createOrUpdate(
				TaskPayload.parse(await req.json()),
			)
			return new Response(JSON.stringify(result))
		} else {
			const form = await req.formData()
			const id = form.get('id')?.toString() || undefined

			const doneAt = form.get('doneAt')
			console.log('task POST doneAt:', doneAt)

			const task = TaskPayload.parse({
				id: id,
				emoji: form.get('emoji')?.toString() || null,
				doneAt: form.get('doneAt')?.toString() || null,
				description: form.get('description')?.toString(),
				assigneeUserId: form.get('assigneeUserId')?.toString() || null,
			})

			if (!id) {
				delete task.id
			}

			if (!task.assigneeUserId) {
				delete task.id
			}

			await createOrUpdate(task)

			const url = new URL(req.url)
			url.pathname = '/'
			return Response.redirect(url, 303)
		}
	},
	async DELETE(req, _ctx) {
		// task: form or query params or json
		let data
		if (req.headers.get('content-type')?.includes('json')) {
			data = await req.json()
		} else {
			data = { id: new URL(req.url).searchParams.get('id') }
		}
		console.log('delete task data:', data)
		const taskData = TaskModel.pick({ id: true }).parse(data)
		const result = await db.tasks.delete({ where: taskData })
		await kv.set(['last_task_updated'], taskData.id)
		return new Response(JSON.stringify(result))
	},
	async GET(req, ctx) {
		// task: json or query params
		const accept = req.headers.get('accept')
		if (accept === 'text/event-stream') {
			console.log('Request for task event stream')
			let skipFirst = true
			const stream = kv.watch([['last_task_updated']]).getReader()
			const body = new ReadableStream({
				async start(controller) {
					console.log(
						`Streaming task updates to ${JSON.stringify(ctx.remoteAddr)}...`,
					)
					while (true) {
						try {
							const entries = await stream.read()
							for (const entry of entries.value || []) {
								if (skipFirst) {
									skipFirst = false
									continue
								}
								if (typeof entry.value !== 'string') {
									continue
								}

								const task = await db.tasks.findFirst({
									where: { id: entry.value },
								})
								const chunk = `data: ${
									JSON.stringify({
										id: entry.value,
										versionstamp: entry.versionstamp,
										value: task,
									})
								}\n\n`
								console.log('task event chunk:', chunk)
								controller.enqueue(new TextEncoder().encode(chunk))
							}
							if (entries.done) {
								return
							}
						} catch (e) {
							console.error(`Error refreshing task:`, e)
						}
					}
				},
				cancel() {
					stream.cancel()
					console.log(
						`Closed task updates stream to ${JSON.stringify(ctx.remoteAddr)}`,
					)
				},
			})
			return new Response(body, {
				headers: {
					'content-type': 'text/event-stream',
				},
			})
		}
		const data = await req.json().catch(() => {})
		const taskData = TaskModel.pick({ id: true }).safeParse(data)
		if (taskData.success) {
			return new Response(
				JSON.stringify(await db.tasks.findFirst({ where: taskData.data })),
			)
		} else {
			return new Response(JSON.stringify(await db.tasks.findMany({})))
		}
	},
}