import { describe, expect, test } from 'bun:test'
import { expandSubfs, expandSubfsEffect, SubfsExpansionError } from '@wispplace/atproto-utils'
import {
	type SafeFetchByteBudget,
	type SafeFetchOptions,
	safeFetchJson,
	safeFetchJsonEffect,
} from '@wispplace/safe-fetch'
import { Cause, Effect, Exit, Schema } from 'effect'
import { parseLexiconJson } from '../packages/@wispplace/lexicons/src/public-json'
import type { Record as FsRecord } from '../packages/@wispplace/lexicons/src/types/place/wisp/fs'

const owner = 'did:plc:aaaaaaaaaaaaaaaaaaaaaaaa'
const subject = `at://${owner}/place.wisp.subfs/shared`
const decodeRecordResponse = Schema.decodeUnknownEffect(Schema.Struct({ value: Schema.Unknown }))
const record = {
	$type: 'place.wisp.subfs',
	createdAt: '2026-01-01T00:00:00.000Z',
	root: {
		type: 'directory',
		entries: [
			{
				name: '雪.txt',
				node: {
					$type: 'place.wisp.subfs#file',
					type: 'file',
					blob: {
						$type: 'blob',
						ref: { $link: 'bafkreie56uer6qjm7mqckb52xtd3mecy77t5axnumzdcnhjzpcwiin6zue' },
						mimeType: 'text/plain',
						size: 1,
					},
				},
			},
		],
	},
}
const root = parseLexiconJson<FsRecord>({
	$type: 'place.wisp.fs',
	site: 'integration',
	createdAt: record.createdAt,
	root: {
		type: 'directory',
		entries: ['left', 'right'].map((name) => ({
			name,
			node: { $type: 'place.wisp.fs#subfs', type: 'subfs', subject, flat: false },
		})),
	},
}).root

function fixtureTransport(payload: unknown, byteBudget?: SafeFetchByteBudget) {
	let requests = 0
	let closed = 0
	const options: SafeFetchOptions = {
		byteBudget,
		resolver: async () => [{ address: '93.184.216.34', family: 4 }],
		transportResource: () => {
			requests++
			let finish = () => {}
			const completion = new Promise<void>((resolve) => {
				finish = resolve
			})
			return {
				response: Promise.resolve(Response.json(payload)),
				completion,
				close: () => {
					closed++
					finish()
				},
			}
		},
	}
	return { options, requests: () => requests, closed: () => closed }
}

const endpoint = 'https://pds.example/xrpc/com.atproto.repo.getRecord'

describe('Effect migration cross-package contracts', () => {
	test('native fetch/decoder/SubFS share one UTF-8 transfer charge and one request lifetime', async () => {
		const payload = { value: record }
		const expectedBytes = new TextEncoder().encode(JSON.stringify(payload)).byteLength
		let charged = 0
		const transfer = fixtureTransport(payload, {
			consume: (bytes) => {
				charged += bytes
				if (charged > expectedBytes) throw new Error('Transfer budget exceeded')
			},
		})
		const expanded = await Effect.runPromise(
			expandSubfsEffect(root, {
				rootOwnerDid: owner,
				fetchSubfsRecord: () =>
					safeFetchJsonEffect(endpoint, transfer.options).pipe(
						Effect.flatMap(decodeRecordResponse),
						Effect.map((response) => response.value),
					),
			}),
		)
		expect([...expanded.ownerDidByFilePath]).toEqual([
			['left/雪.txt', owner],
			['right/雪.txt', owner],
		])
		expect(charged).toBe(expectedBytes)
		expect(transfer.requests()).toBe(1)
		expect(transfer.closed()).toBe(1)
	})

	test('legacy fetch/SubFS facades use the same single-charge engine', async () => {
		const payload = { value: record }
		let charged = 0
		const transfer = fixtureTransport(payload, { consume: (bytes) => (charged += bytes) })
		const expanded = await expandSubfs(root, {
			rootOwnerDid: owner,
			fetchSubfsRecord: async () => {
				const response = await safeFetchJson(endpoint, transfer.options)
				return (await Effect.runPromise(decodeRecordResponse(response))).value
			},
		})
		expect(expanded.root.entries.map((entry) => entry.name)).toEqual(['left', 'right'])
		expect(charged).toBe(new TextEncoder().encode(JSON.stringify(payload)).byteLength)
		expect(transfer.requests()).toBe(1)
		expect(transfer.closed()).toBe(1)
	})

	test('malformed XRPC ingress fails the whole native expansion without leaking its payload', async () => {
		const secret = 'remote-secret-must-not-survive'
		const transfer = fixtureTransport({ credential: secret })
		const exit = await Effect.runPromiseExit(
			expandSubfsEffect(root, {
				rootOwnerDid: owner,
				fetchSubfsRecord: () =>
					safeFetchJsonEffect(endpoint, transfer.options).pipe(
						Effect.flatMap(decodeRecordResponse),
						Effect.map((response) => response.value),
					),
			}),
		)
		expect(Exit.isFailure(exit)).toBe(true)
		if (Exit.isSuccess(exit)) throw new Error('Expected expansion failure')
		const error = Cause.squash(exit.cause)
		expect(error).toBeInstanceOf(SubfsExpansionError)
		expect(error).toMatchObject({ code: 'FETCH_FAILED' })
		expect(JSON.stringify(error)).not.toContain(secret)
		expect(String(error)).not.toContain(endpoint)
		expect(transfer.requests()).toBe(1)
		expect(transfer.closed()).toBe(1)
	})
})