import { Schema as S } from "@effect/schema"
import { ServerTime } from "@todo-tests/common/data"
import { TRPCError } from "@trpc/server"
import { observable } from "@trpc/server/observable"
import { Data, Effect, Fiber, Schedule } from "effect"
import { TRPCBuilder } from "../../trpc/TRPCBuilder"
import { RPCProcedureBuilder } from "../procedures/RPCProcedureBuilder"
import { todoRouter } from "./todo"


const encodeServerTime = S.encode(ServerTime)


export const indexRouter = Effect.gen(function*() {
    const t         = yield* TRPCBuilder
    const procedure = yield* RPCProcedureBuilder

    return t.router({
        ping: procedure.query(({ ctx }) => ctx.run(
            Effect.succeed("pong")
        )),

        serverTime: procedure
            .subscription(({ ctx }) =>
                observable<typeof ServerTime.Encoded>(emit => {
                    const emitter = ctx.fork(
                        Effect.sync(() => new Date()).pipe(
                            Effect.flatMap(encodeServerTime),
                            Effect.map(emit.next),
                            Effect.repeat(Schedule.fixed("1 second")),
                        )
                    )

                    return () => ctx.fork(
                        Fiber.interrupt(emitter)
                    )
                })
            ),


        fail1: procedure.query(({ ctx }) => ctx.run(
            Effect.fail(new AnError({ aValue: "A value" }))
        )),
        fail2: procedure.query(({ ctx }) => ctx.run(
            Effect.fail(new TRPCError({ code: "NOT_IMPLEMENTED" }))
        )),

        todo: yield* todoRouter,
    })
})

class AnError extends Data.TaggedError("AnError")<{
    aValue: string
}> {}