import { randomBytes } from "node:crypto";

import { and, desc, eq, isNull, or, sql } from "drizzle-orm";

import { z } from "zod";

import {

  cities,

  classes,

  comments,

  djs,

  eventPhotos,

  events,

  flags,

  instructors,

  orders,

  proAccounts,

  promoters,

  sponsors,

  steppingGroups,

  ticketTypes,

  tickets,

  travelPlaces,

  vendors,

  videos,

} from "@stepping/db";

import {

  EVENT_TYPE,

  SUBJECT_TYPE,

  TRAVEL_CATEGORY,

  VIDEO_PLATFORM,

} from "@stepping/types";

import {

  adminProcedure,

  protectedProcedure,

  publicProcedure,

  router,

} from "./trpc";

const uuid = z.string().uuid();

const links = z

  .array(z.object({ label: z.string().min(1), url: z.string().url() }))

  .optional();

const uploadUrl = z.string().regex(/^\/api\/uploads\/[a-f0-9]{32}\.[a-z0-9]{3,4}$/);

export const appRouter = router({

  city: router({

    listLaunched: publicProcedure.query(({ ctx }) =>

      ctx.db.select().from(cities).where(eq(cities.isLaunched, true)),

    ),

    bySlug: publicProcedure.input(z.object({ slug: z.string() })).query(

      async ({ ctx, input }) => {

        const [row] = await ctx.db

          .select()

          .from(cities)

          .where(eq(cities.slug, input.slug));

        return row ?? null;

      },

    ),

  }),

  event: router({

    list: publicProcedure

      .input(z.object({ cityId: uuid, type: z.enum(EVENT_TYPE).optional() }))

      .query(({ ctx, input }) =>

        ctx.db

          .select()

          .from(events)

          .where(

            and(

              eq(events.cityId, input.cityId),

              eq(events.status, "active"),

              input.type ? eq(events.type, input.type) : undefined,

            ),

          )

          .orderBy(desc(events.startsAt)),

      ),

    byId: publicProcedure.input(z.object({ id: uuid })).query(

      async ({ ctx, input }) => {

        const [row] = await ctx.db

          .select()

          .from(events)

          .where(eq(events.id, input.id));

        return row ?? null;

      },

    ),

    create: protectedProcedure

      .input(

        z.object({

          cityId: uuid,

          title: z.string().min(1),

          type: z.enum(EVENT_TYPE),

          description: z.string().optional(),

          startsAt: z.coerce.date().optional(),

          endsAt: z.coerce.date().optional(),

          venueId: uuid.optional(),

          externalUrl: z.string().url().optional(),

          ticketUrl: z.string().url().optional(),

          isFree: z.boolean().optional(),

          isPromoted: z.boolean().optional(),

        }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .insert(events)

          .values({ ...input, ownerId: ctx.user.id })

          .returning();

        return row;

      }),

    setLive: protectedProcedure

      .input(

        z.object({

          id: uuid,

          isLive: z.boolean(),

          liveUrl: z.string().url().optional(),

        }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .update(events)

          .set({ isLive: input.isLive, liveUrl: input.liveUrl ?? null })

          .where(eq(events.id, input.id))

          .returning();

        return row;

      }),

    boost: protectedProcedure

      .input(z.object({ id: uuid, days: z.number().int().min(1).max(60).default(14) }))

      .mutation(async ({ ctx, input }) => {

        const until = new Date(Date.now() + input.days * 86_400_000);

        const [row] = await ctx.db

          .update(events)

          .set({ isPromoted: true, boostedUntil: until })

          .where(eq(events.id, input.id))

          .returning();

        await ctx.db.insert(orders).values({

          purpose: "boost",

          buyerId: ctx.user.id,

          eventId: input.id,

          amountCents: 0,

          status: "reserved",

          meta: { days: input.days },

        });

        return row;

      }),

    setFlyer: adminProcedure

      .input(z.object({ id: uuid, flyerUrl: uploadUrl.nullable() }))

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .update(events)

          .set({ flyerUrl: input.flyerUrl })

          .where(eq(events.id, input.id))

          .returning();

        return row;

      }),

    setProgram: adminProcedure

      .input(z.object({ id: uuid, programUrl: uploadUrl.nullable() }))

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .update(events)

          .set({ programUrl: input.programUrl })

          .where(eq(events.id, input.id))

          .returning();

        return row;

      }),

  }),

  eventPhoto: router({

    list: publicProcedure.input(z.object({ eventId: uuid })).query(({ ctx, input }) =>

      ctx.db

        .select()

        .from(eventPhotos)

        .where(and(eq(eventPhotos.eventId, input.eventId), eq(eventPhotos.status, "active")))

        .orderBy(desc(eventPhotos.createdAt)),

    ),

    submit: protectedProcedure

      .input(

        z.object({

          eventId: uuid,

          url: uploadUrl,

          caption: z.string().max(200).optional(),

        }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .insert(eventPhotos)

          .values({ ...input, ownerId: ctx.user.id, status: "pending" })

          .returning();

        return row;

      }),

    adminPending: adminProcedure.query(({ ctx }) =>

      ctx.db

        .select({

          id: eventPhotos.id,

          url: eventPhotos.url,

          caption: eventPhotos.caption,

          createdAt: eventPhotos.createdAt,

          eventId: eventPhotos.eventId,

          eventTitle: events.title,

        })

        .from(eventPhotos)

        .innerJoin(events, eq(events.id, eventPhotos.eventId))

        .where(eq(eventPhotos.status, "pending"))

        .orderBy(desc(eventPhotos.createdAt))

        .limit(100),

    ),

    adminReview: adminProcedure

      .input(z.object({ id: uuid, approve: z.boolean() }))

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .update(eventPhotos)

          .set(

            input.approve

              ? { status: "active", verifiedAt: new Date() }

              : { status: "removed", hiddenAt: new Date() },

          )

          .where(eq(eventPhotos.id, input.id))

          .returning();

        return row;

      }),

  }),

  vendor: router({

    listForEvent: publicProcedure

      .input(z.object({ cityId: uuid, eventId: uuid }))

      .query(({ ctx, input }) =>

        ctx.db

          .select()

          .from(vendors)

          .where(

            and(

              eq(vendors.status, "active"),

              or(

                eq(vendors.eventId, input.eventId),

                and(eq(vendors.cityId, input.cityId), isNull(vendors.eventId)),

              ),

            ),

          )

          .orderBy(vendors.name),

      ),

    listByCity: publicProcedure.input(z.object({ cityId: uuid })).query(({ ctx, input }) =>

      ctx.db

        .select()

        .from(vendors)

        .where(and(eq(vendors.cityId, input.cityId), eq(vendors.status, "active")))

        .orderBy(vendors.name),

    ),

    adminList: adminProcedure.query(({ ctx }) =>

      ctx.db.select().from(vendors).orderBy(desc(vendors.createdAt)).limit(100),

    ),

    adminCreate: adminProcedure

      .input(

        z.object({

          cityId: uuid,

          eventId: uuid.optional(),

          name: z.string().min(1).max(120),

          description: z.string().max(500).optional(),

          category: z.string().max(60).optional(),

          linkUrl: z.string().url().optional(),

        }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .insert(vendors)

          .values({ ...input, ownerId: ctx.user.id })

          .returning();

        return row;

      }),

    adminSetStatus: adminProcedure

      .input(z.object({ id: uuid, status: z.enum(["active", "hidden"]) }))

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .update(vendors)

          .set(

            input.status === "hidden"

              ? { status: "hidden", hiddenAt: new Date() }

              : { status: "active", hiddenAt: null },

          )

          .where(eq(vendors.id, input.id))

          .returning();

        return row;

      }),

  }),

  ticketType: router({

    list: publicProcedure.input(z.object({ eventId: uuid })).query(({ ctx, input }) =>

      ctx.db

        .select()

        .from(ticketTypes)

        .where(and(eq(ticketTypes.eventId, input.eventId), eq(ticketTypes.isActive, true)))

        .orderBy(ticketTypes.priceCents),

    ),

    create: protectedProcedure

      .input(

        z.object({

          eventId: uuid,

          name: z.string().min(1),

          priceCents: z.number().int().min(0).max(1_000_000),

          capacity: z.number().int().min(1).max(100_000).optional(),

        }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .insert(ticketTypes)

          .values({ ...input, ownerId: ctx.user.id })

          .returning();

        return row;

      }),

  }),

  ticket: router({

    reserve: protectedProcedure

      .input(z.object({ ticketTypeId: uuid, quantity: z.number().int().min(1).max(10).default(1) }))

      .mutation(async ({ ctx, input }) => {

        const [tt] = await ctx.db

          .select()

          .from(ticketTypes)

          .where(and(eq(ticketTypes.id, input.ticketTypeId), eq(ticketTypes.isActive, true)));

        if (!tt) throw new Error("Ticket type not available.");

        if (tt.capacity != null && tt.sold + input.quantity > tt.capacity) {

          throw new Error("Not enough tickets left.");

        }

        const [order] = await ctx.db

          .insert(orders)

          .values({

            purpose: "ticket",

            buyerId: ctx.user.id,

            eventId: tt.eventId,

            ticketTypeId: tt.id,

            quantity: input.quantity,

            amountCents: tt.priceCents * input.quantity,

            status: "reserved",

          })

          .returning();

        if (!order) throw new Error("Could not create order.");

        const rows = Array.from({ length: input.quantity }, () => ({

          orderId: order.id,

          eventId: tt.eventId,

          ticketTypeId: tt.id,

          holderId: ctx.user.id,

          code: randomBytes(5).toString("hex").toUpperCase(),

        }));

        const issued = await ctx.db.insert(tickets).values(rows).returning();

        await ctx.db

          .update(ticketTypes)

          .set({ sold: sql`${ticketTypes.sold} + ${input.quantity}` })

          .where(eq(ticketTypes.id, tt.id));

        return { orderId: order.id, tickets: issued };

      }),

    mine: protectedProcedure.query(({ ctx }) =>

      ctx.db

        .select({

          id: tickets.id,

          code: tickets.code,

          status: tickets.status,

          createdAt: tickets.createdAt,

          eventId: tickets.eventId,

          eventTitle: events.title,

          startsAt: events.startsAt,

          typeName: ticketTypes.name,

        })

        .from(tickets)

        .innerJoin(events, eq(events.id, tickets.eventId))

        .leftJoin(ticketTypes, eq(ticketTypes.id, tickets.ticketTypeId))

        .where(eq(tickets.holderId, ctx.user.id))

        .orderBy(desc(tickets.createdAt)),

    ),

  }),

  sponsor: router({

    listActive: publicProcedure.input(z.object({ cityId: uuid })).query(({ ctx, input }) =>

      ctx.db

        .select()

        .from(sponsors)

        .where(and(eq(sponsors.cityId, input.cityId), eq(sponsors.status, "active")))

        .orderBy(desc(sponsors.createdAt)),

    ),

    adminList: adminProcedure.query(({ ctx }) =>

      ctx.db.select().from(sponsors).orderBy(desc(sponsors.createdAt)).limit(100),

    ),

    adminCreate: adminProcedure

      .input(

        z.object({

          cityId: uuid,

          name: z.string().min(1),

          blurb: z.string().optional(),

          linkUrl: z.string().url().optional(),

          status: z.enum(["pending", "active", "ended"]).default("active"),

        }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .insert(sponsors)

          .values({ ...input, ownerId: ctx.user.id })

          .returning();

        return row;

      }),

    adminSetStatus: adminProcedure

      .input(z.object({ id: uuid, status: z.enum(["pending", "active", "ended"]) }))

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .update(sponsors)

          .set({ status: input.status })

          .where(eq(sponsors.id, input.id))

          .returning();

        return row;

      }),

  }),

  proAccount: router({

    adminList: adminProcedure.query(({ ctx }) =>

      ctx.db.select().from(proAccounts).orderBy(desc(proAccounts.createdAt)).limit(100),

    ),

    adminSetStatus: adminProcedure

      .input(

        z.object({

          id: uuid,

          status: z.enum(["pending", "active", "expired", "cancelled"]),

        }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .update(proAccounts)

          .set({

            status: input.status,

            startedAt: input.status === "active" ? new Date() : undefined,

          })

          .where(eq(proAccounts.id, input.id))

          .returning();

        return row;

      }),

  }),

  order: router({

    adminRecent: adminProcedure.query(({ ctx }) =>

      ctx.db.select().from(orders).orderBy(desc(orders.createdAt)).limit(50),

    ),

  }),

  video: router({

    list: publicProcedure.input(z.object({ cityId: uuid })).query(({ ctx, input }) =>

      ctx.db

        .select()

        .from(videos)

        .where(and(eq(videos.cityId, input.cityId), eq(videos.status, "active")))

        .orderBy(desc(videos.createdAt)),

    ),

    create: protectedProcedure

      .input(

        z.object({

          cityId: uuid,

          title: z.string().min(1),

          embedUrl: z.string().url(),

          platform: z.enum(VIDEO_PLATFORM).default("other"),

        }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .insert(videos)

          .values({ ...input, ownerId: ctx.user.id })

          .returning();

        return row;

      }),

  }),

  comment: router({

    list: publicProcedure

      .input(z.object({ subjectType: z.enum(SUBJECT_TYPE), subjectId: uuid }))

      .query(({ ctx, input }) =>

        ctx.db

          .select()

          .from(comments)

          .where(

            and(

              eq(comments.subjectType, input.subjectType),

              eq(comments.subjectId, input.subjectId),

              eq(comments.status, "active"),

            ),

          )

          .orderBy(desc(comments.createdAt)),

      ),

    create: protectedProcedure

      .input(

        z.object({

          subjectType: z.enum(SUBJECT_TYPE),

          subjectId: uuid,

          body: z.string().min(1).max(2000),

        }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .insert(comments)

          .values({ ...input, ownerId: ctx.user.id })

          .returning();

        return row;

      }),

  }),

  flag: router({

    create: protectedProcedure

      .input(

        z.object({

          subjectType: z.enum(SUBJECT_TYPE),

          subjectId: uuid,

          reason: z.string().max(500).optional(),

        }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .insert(flags)

          .values({ ...input, reporterId: ctx.user.id })

          .returning();

        return row;

      }),

    adminOpen: adminProcedure.query(({ ctx }) =>

      ctx.db

        .select()

        .from(flags)

        .where(eq(flags.status, "open"))

        .orderBy(desc(flags.createdAt))

        .limit(100),

    ),

    adminResolve: adminProcedure

      .input(z.object({ id: uuid, status: z.enum(["reviewed", "actioned", "dismissed"]) }))

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .update(flags)

          .set({ status: input.status })

          .where(eq(flags.id, input.id))

          .returning();

        return row;

      }),

  }),

  promoter: router({

    list: publicProcedure.input(z.object({ cityId: uuid })).query(({ ctx, input }) =>

      ctx.db

        .select()

        .from(promoters)

        .where(and(eq(promoters.cityId, input.cityId), eq(promoters.status, "active"))),

    ),

    byId: publicProcedure.input(z.object({ id: uuid })).query(async ({ ctx, input }) => {

      const [row] = await ctx.db.select().from(promoters).where(eq(promoters.id, input.id));

      return row ?? null;

    }),

    create: protectedProcedure

      .input(

        z.object({ cityId: uuid, name: z.string().min(1), bio: z.string().optional(), links }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .insert(promoters)

          .values({ ...input, ownerId: ctx.user.id })

          .returning();

        return row;

      }),

  }),

  dj: router({

    list: publicProcedure.input(z.object({ cityId: uuid })).query(({ ctx, input }) =>

      ctx.db

        .select()

        .from(djs)

        .where(and(eq(djs.cityId, input.cityId), eq(djs.status, "active"))),

    ),

    byId: publicProcedure.input(z.object({ id: uuid })).query(async ({ ctx, input }) => {

      const [row] = await ctx.db.select().from(djs).where(eq(djs.id, input.id));

      return row ?? null;

    }),

    create: protectedProcedure

      .input(

        z.object({ cityId: uuid, name: z.string().min(1), bio: z.string().optional(), links }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .insert(djs)

          .values({ ...input, ownerId: ctx.user.id })

          .returning();

        return row;

      }),

  }),

  instructor: router({

    list: publicProcedure.input(z.object({ cityId: uuid })).query(({ ctx, input }) =>

      ctx.db

        .select()

        .from(instructors)

        .where(and(eq(instructors.cityId, input.cityId), eq(instructors.status, "active"))),

    ),

    byId: publicProcedure.input(z.object({ id: uuid })).query(async ({ ctx, input }) => {

      const [row] = await ctx.db.select().from(instructors).where(eq(instructors.id, input.id));

      return row ?? null;

    }),

    create: protectedProcedure

      .input(

        z.object({ cityId: uuid, name: z.string().min(1), bio: z.string().optional(), links }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .insert(instructors)

          .values({ ...input, ownerId: ctx.user.id })

          .returning();

        return row;

      }),

  }),

  steppingGroup: router({

    list: publicProcedure.input(z.object({ cityId: uuid })).query(({ ctx, input }) =>

      ctx.db

        .select()

        .from(steppingGroups)

        .where(

          and(eq(steppingGroups.cityId, input.cityId), eq(steppingGroups.status, "active")),

        ),

    ),

    byId: publicProcedure.input(z.object({ id: uuid })).query(async ({ ctx, input }) => {

      const [row] = await ctx.db

        .select()

        .from(steppingGroups)

        .where(eq(steppingGroups.id, input.id));

      return row ?? null;

    }),

    create: protectedProcedure

      .input(

        z.object({

          cityId: uuid,

          name: z.string().min(1),

          bio: z.string().optional(),

          links,

        }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .insert(steppingGroups)

          .values({ ...input, ownerId: ctx.user.id })

          .returning();

        return row;

      }),

  }),

  class: router({

    list: publicProcedure.input(z.object({ cityId: uuid })).query(({ ctx, input }) =>

      ctx.db

        .select()

        .from(classes)

        .where(and(eq(classes.cityId, input.cityId), eq(classes.status, "active"))),

    ),

    byId: publicProcedure.input(z.object({ id: uuid })).query(async ({ ctx, input }) => {

      const [row] = await ctx.db.select().from(classes).where(eq(classes.id, input.id));

      return row ?? null;

    }),

    create: protectedProcedure

      .input(

        z.object({

          cityId: uuid,

          title: z.string().min(1),

          instructor: z.string().optional(),

          schedule: z.string().optional(),

          venueId: uuid.optional(),

          priceText: z.string().optional(),

          isFree: z.boolean().optional(),

        }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .insert(classes)

          .values({ ...input, ownerId: ctx.user.id })

          .returning();

        return row;

      }),

  }),

  travelPlace: router({

    list: publicProcedure

      .input(z.object({ cityId: uuid, category: z.enum(TRAVEL_CATEGORY).optional() }))

      .query(({ ctx, input }) =>

        ctx.db

          .select()

          .from(travelPlaces)

          .where(

            and(

              eq(travelPlaces.cityId, input.cityId),

              eq(travelPlaces.status, "active"),

              input.category ? eq(travelPlaces.category, input.category) : undefined,

            ),

          ),

      ),

    create: protectedProcedure

      .input(

        z.object({

          cityId: uuid,

          category: z.enum(TRAVEL_CATEGORY),

          name: z.string().min(1),

          address: z.string().optional(),

        }),

      )

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db.insert(travelPlaces).values(input).returning();

        return row;

      }),

  }),

  moderation: router({

    recentEvents: adminProcedure.query(({ ctx }) =>

      ctx.db.select().from(events).orderBy(desc(events.createdAt)).limit(50),

    ),

    hideEvent: adminProcedure

      .input(z.object({ id: uuid }))

      .mutation(async ({ ctx, input }) => {

        const [row] = await ctx.db

          .update(events)

          .set({ status: "hidden", hiddenAt: new Date() })

          .where(eq(events.id, input.id))

          .returning();

        return row;

      }),

  }),

});

export type AppRouter = typeof appRouter;