Serialization hazards.

export function defaultDateRoundTrip(date: Date) {
	const wire = JSON.stringify({ checkIn: date });
	return { wire, after: JSON.parse(wire).checkIn } as const;
}

export function defaultMapRoundTrip(notes: Map<string, string>) {
	const wire = JSON.stringify({ notes });
	return { wire, after: JSON.parse(wire).notes } as const;
}

export function defaultBigIntRoundTrip(amount: bigint) {
	try {
		return { wire: JSON.stringify({ depositCents: amount }), after: 'unreachable' } as const;
	} catch (error) {
		return {
			wire: null,
			after: error instanceof TypeError ? 'BigInt cannot be serialized' : 'unknown failure'
		} as const;
	}
}

export function encodeCoupon(coupon: BookingSnapshot['coupon']): CouponWire {
	if (coupon === undefined) return { kind: 'missing' };
	if (coupon === null) return { kind: 'none' };
	return { kind: 'value', value: coupon };
}

// Notes travel as [key, value] pairs sorted by key, so every encoder writes the same bytes.
export function encodeBooking(snapshot: BookingSnapshot): BookingWire {
	return {
		id: snapshot.id,
		checkIn: snapshot.checkIn.toISOString(),
		depositCents: snapshot.depositCents.toString(),
		notes: [...snapshot.notes.entries()].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),
		coupon: encodeCoupon(snapshot.coupon)
	};
}

// The wire format is exactly what toISOString writes, so a real date survives the round trip
// and a lookalike such as "2026-13-45T00:00:00.000Z" does not.
function decodeCheckIn(text: string): Date {
	const date = new Date(text);
	if (Number.isNaN(date.valueOf()) || date.toISOString() !== text) {
		throw new Error('invalid check-in');
	}
	return date;
}

export function decodeBooking(wire: BookingWire): BookingSnapshot {
	const checkIn = decodeCheckIn(wire.checkIn);
	if (!/^\d+$/.test(wire.depositCents)) throw new Error('invalid deposit');
	const coupon =
		wire.coupon.kind === 'missing'
			? undefined
			: wire.coupon.kind === 'none'
				? null
				: wire.coupon.value;
	return {
		id: wire.id,
		checkIn,
		depositCents: BigInt(wire.depositCents),
		notes: new Map(wire.notes),
		coupon
	};
}

func encodeCoupon(coupon Coupon) CouponWire {
	switch coupon.State {
	case CouponNone:
		return CouponWire{Kind: "none"}
	case CouponValue:
		return CouponWire{Kind: "value", Value: coupon.Code}
	default:
		return CouponWire{Kind: "missing"}
	}
}

// Notes travel as [key, value] pairs sorted by key, so every encoder writes the same bytes.
func encodeBooking(snapshot BookingSnapshot) BookingWire {
	keys := make([]string, 0, len(snapshot.Notes))
	for key := range snapshot.Notes {
		keys = append(keys, key)
	}
	sort.Strings(keys)
	notes := make([][2]string, 0, len(keys))
	for _, key := range keys {
		notes = append(notes, [2]string{key, snapshot.Notes[key]})
	}
	return BookingWire{
		ID:           snapshot.ID,
		CheckIn:      snapshot.CheckIn.UTC().Format(checkInLayout),
		DepositCents: fmt.Sprintf("%d", snapshot.DepositCents),
		Notes:        notes,
		Coupon:       encodeCoupon(snapshot.Coupon),
	}
}

func decodeCoupon(wire CouponWire) (Coupon, error) {
	switch wire.Kind {
	case "missing":
		return Coupon{State: CouponMissing}, nil
	case "none":
		return Coupon{State: CouponNone}, nil
	case "value":
		return Coupon{State: CouponValue, Code: wire.Value}, nil
	}
	return Coupon{}, fmt.Errorf("unknown coupon kind %q", wire.Kind)
}

func decodeBooking(wire BookingWire) (BookingSnapshot, error) {
	checkIn, err := time.Parse(checkInLayout, wire.CheckIn)
	if err != nil || checkIn.Format(checkInLayout) != wire.CheckIn {
		return BookingSnapshot{}, fmt.Errorf("invalid check-in %q", wire.CheckIn)
	}
	var deposit int64
	if _, err := fmt.Sscanf(wire.DepositCents, "%d", &deposit); err != nil {
		return BookingSnapshot{}, err
	}
	notes := make(map[string]string, len(wire.Notes))
	for _, note := range wire.Notes {
		notes[note[0]] = note[1]
	}
	coupon, err := decodeCoupon(wire.Coupon)
	if err != nil {
		return BookingSnapshot{}, err
	}
	return BookingSnapshot{ID: wire.ID, CheckIn: checkIn, DepositCents: deposit, Notes: notes, Coupon: coupon}, nil
}