import type { Context } from "hono";
import type { Kysely } from "kysely";
import { z } from "zod";
import { logError } from "@/lib/logger";
import { error as errorResponse, success } from "@/lib/response";
import {
  getReferralInviteAnalytics,
  listReferralInvites,
  type ReferralInviteFilters,
} from "@/internal/repository/member-referrals/referral-invites.repo";

const FiltersSchema = z.object({
  from: z.string().optional(),
  to: z.string().optional(),
  search: z.string().optional(),
  source: z.string().optional(),
  status: z.enum(["registered", "unregistered", "credited"]).optional(),
  referrerMembershipNumber: z.string().optional(),
});

const ListSchema = FiltersSchema.merge(
  z.object({
    page: z.coerce.number().int().min(1).default(1),
    pageSize: z.coerce.number().int().min(1).max(200).default(25),
  }),
);

const toFilters = (parsed: Record<string, unknown>): ReferralInviteFilters => ({
  from: parsed.from as string | undefined,
  to: parsed.to as string | undefined,
  search: parsed.search as string | undefined,
  source: parsed.source as string | undefined,
  status: parsed.status as
    | "registered"
    | "unregistered"
    | "credited"
    | undefined,
  referrerMembershipNumber: parsed.referrerMembershipNumber as string | undefined,
});

function memberDb(c: Context): Kysely<any> | null {
  return (c.get("memberDatastore") as Kysely<any> | undefined) ?? null;
}

export const listReferralInvitesHandler = async (c: Context) => {
  try {
    const parsed = ListSchema.safeParse(c.req.query());
    if (!parsed.success) {
      return errorResponse(c, "Invalid filters", 400, parsed.error);
    }
    const db = memberDb(c);
    if (!db) return errorResponse(c, "Member database is not configured", 503);

    const { page, pageSize } = parsed.data;
    const result = await listReferralInvites(db, {
      ...toFilters(parsed.data),
      page,
      pageSize,
    });

    return success(
      c,
      {
        rows: result.rows,
        total: result.total,
        page,
        pageSize,
        totalPages: Math.max(1, Math.ceil(result.total / pageSize)),
      },
      "Referral captures fetched",
      200,
    );
  } catch (err) {
    logError(err, "member-referrals: listing invites failed");
    return errorResponse(
      c,
      err instanceof Error ? err.message : "Could not fetch referral invites",
      500,
    );
  }
};

export const referralInviteAnalyticsHandler = async (c: Context) => {
  try {
    const parsed = FiltersSchema.safeParse(c.req.query());
    if (!parsed.success) {
      return errorResponse(c, "Invalid filters", 400, parsed.error);
    }
    const db = memberDb(c);
    if (!db) return errorResponse(c, "Member database is not configured", 503);

    const analytics = await getReferralInviteAnalytics(db, toFilters(parsed.data));
    return success(c, analytics, "Referral invite analytics fetched", 200);
  } catch (err) {
    logError(err, "member-referrals: invite analytics failed");
    return errorResponse(
      c,
      err instanceof Error ? err.message : "Could not fetch referral analytics",
      500,
    );
  }
};
