import {
  lookupMembersByNumber,
  membershipNumbersForEmail,
} from "@/internal/repository/event-analytics/member-lookup.repo";
import {
  addToBlacklist,
  listBlacklist,
  removeFromBlacklist,
  setBlacklistActive,
} from "@/internal/repository/event-analytics/blacklist.repo";
import { describeFirestoreError } from "@/lib/firestore/event-tracking";
import { logError } from "@/lib/logger";
import {
  getBlacklistedMembers,
  getExcludeUatEvents,
} from "@/v1/services/admin/event-analytics/event-analytics.config";
import { error as errorResponse, success } from "@/lib/response";
import type { EventRecord } from "@/v1/services/admin/event-analytics/event-analytics.mapper";
import {
  EventFiltersSchema,
  ListEventsSchema,
  ListJourneysSchema,
  MemberAnalyticsSchema,
  AddBlacklistSchema,
} from "@/v1/services/admin/event-analytics/event-analytics.schema";
import {
  EventAnalyticsService,
  type EventFilters,
  type MemberAnalyticsRow,
} from "@/v1/services/admin/event-analytics/event-analytics.service";
import type { Context } from "hono";
import type Redis from "ioredis";
import type { Kysely } from "kysely";

const service = () => EventAnalyticsService.getInstance();

const cache = (c: Context): Redis | undefined =>
  (c.get("redisDB") as Redis | undefined) ?? undefined;

async function attachProfiles(
  memberDb: Kysely<any> | undefined,
  rows: MemberAnalyticsRow[],
): Promise<MemberAnalyticsRow[]> {
  if (!memberDb || !rows.length) return rows;
  try {
    const profiles = await lookupMembersByNumber(
      memberDb,
      rows.map((r) => r.memberId),
    );
    return rows.map((row) => ({
      ...row,
      profile: profiles.get(row.memberId) ?? null,
    }));
  } catch (err) {
    logError(err, "event-analytics: member profile lookup failed");
    return rows;
  }
}

async function attachRecordProfiles(
  memberDb: Kysely<any> | undefined,
  records: EventRecord[],
): Promise<EventRecord[]> {
  if (!memberDb || !records.length) return records;
  try {
    const numbers = records
      .map((r) => r.memberId)
      .filter((id): id is string => Boolean(id));
    if (!numbers.length) return records;

    const profiles = await lookupMembersByNumber(memberDb, numbers);
    return records.map((record) => {
      const profile = record.memberId
        ? profiles.get(record.memberId)
        : undefined;
      if (!profile) return record;
      return {
        ...record,
        memberName: record.memberName ?? profile.fullName,
        memberEmail: record.memberEmail ?? profile.email,
      };
    });
  } catch (err) {
    logError(err, "event-analytics: record member lookup failed");
    return records;
  }
}

const toFilters = (parsed: Record<string, unknown>): EventFilters => ({
  from: parsed.from as string | undefined,
  to: parsed.to as string | undefined,
  eventTypes: parsed.eventTypes as string[] | undefined,
  memberId: parsed.memberId as string | undefined,
  currency: parsed.currency as string | undefined,
  property: parsed.property as string | undefined,
  source: parsed.source as string | undefined,
  utmSource: parsed.utmSource as string | undefined,
  utmMedium: parsed.utmMedium as string | undefined,
  search: parsed.search as string | undefined,
});

const respondWithError = (c: Context, err: unknown, fallback: string) => {
  const described = describeFirestoreError(err);
  logError(err, described ?? fallback);
  return errorResponse(c, fallback, 500);
};

export const getEventSummaryHandler = async (c: Context) => {
  try {
    const parsed = EventFiltersSchema.safeParse(c.req.query());
    if (!parsed.success) {
      logError(parsed.error, "Invalid event-analytics filters");
      return errorResponse(c, "Invalid filters", 400);
    }
    await service().loadBlacklist(c.get("datastore") as Kysely<any>);
    const aggregate = await service().computeAggregates(
      toFilters(parsed.data),
      cache(c),
    );
    return success(
      c,
      {
        summary: aggregate.summary,
        availableEventTypes: aggregate.availableEventTypes,
        availableCurrencies: aggregate.availableCurrencies,
        availableProperties: aggregate.availableProperties,
        availableSources: aggregate.availableSources,
        availableUtmSources: aggregate.availableUtmSources,
        availableUtmMediums: aggregate.availableUtmMediums,
        exclusions: {
          uatEvents: getExcludeUatEvents(),
          blacklistedMembers:
            getBlacklistedMembers().size + service().blacklistSize(),
        },
        byDay: aggregate.byDay,
        byProperty: aggregate.byProperty,
        bySource: aggregate.bySource,
        funnel: aggregate.funnel,
        funnelByUtmSource: aggregate.funnelByUtmSource,
        funnelByUtmMedium: aggregate.funnelByUtmMedium,
        funnelBySection: aggregate.funnelBySection,
      },
      "Event summary fetched",
      200,
    );
  } catch (err) {
    return respondWithError(c, err, "Could not fetch the event summary");
  }
};

export const getMemberAnalyticsHandler = async (c: Context) => {
  try {
    await service().loadBlacklist(c.get("datastore") as Kysely<any>);
    const parsed = MemberAnalyticsSchema.safeParse(c.req.query());
    if (!parsed.success) {
      logError(parsed.error, "Invalid event-analytics filters");
      return errorResponse(c, "Invalid filters", 400);
    }
    const { page, pageSize, sortBy, sortDir, memberSearch } = parsed.data;
    const aggregate = await service().computeAggregates(
      toFilters(parsed.data),
      cache(c),
    );

    const needle = memberSearch?.trim().toLowerCase();
    const matching = needle
      ? aggregate.members.filter((m) =>
          m.memberId.toLowerCase().includes(needle),
        )
      : aggregate.members;

    const sorted = sortMembers(matching, sortBy, sortDir);
    const start = (page - 1) * pageSize;
    const rows = await attachProfiles(
      c.get("memberDatastore") as Kysely<any> | undefined,
      sorted.slice(start, start + pageSize),
    );

    return success(
      c,
      {
        rows,
        total: sorted.length,
        page,
        pageSize,
        totalPages: Math.max(1, Math.ceil(sorted.length / pageSize)),
        truncated: aggregate.summary.truncated,
      },
      "Member analytics fetched",
      200,
    );
  } catch (err) {
    return respondWithError(c, err, "Could not fetch member analytics");
  }
};

export const getEventTypeAnalyticsHandler = async (c: Context) => {
  try {
    await service().loadBlacklist(c.get("datastore") as Kysely<any>);
    const parsed = EventFiltersSchema.safeParse(c.req.query());
    if (!parsed.success) {
      logError(parsed.error, "Invalid event-analytics filters");
      return errorResponse(c, "Invalid filters", 400);
    }
    const aggregate = await service().computeAggregates(
      toFilters(parsed.data),
      cache(c),
    );
    return success(
      c,
      {
        rows: aggregate.eventTypes,
        total: aggregate.eventTypes.length,
        truncated: aggregate.summary.truncated,
      },
      "Event analytics fetched",
      200,
    );
  } catch (err) {
    return respondWithError(c, err, "Could not fetch event analytics");
  }
};

export const listEventRecordsHandler = async (c: Context) => {
  try {
    await service().loadBlacklist(c.get("datastore") as Kysely<any>);
    const parsed = ListEventsSchema.safeParse(c.req.query());
    if (!parsed.success) {
      logError(parsed.error, "Invalid event-analytics filters");
      return errorResponse(c, "Invalid filters", 400);
    }
    const { pageSize, cursor } = parsed.data;
    const filters = toFilters(parsed.data);

    const page = await service().listEvents({ filters, pageSize, cursor });
    const total =
      page.total !== undefined
        ? page.total
        : await service().countEvents(filters);

    const records = await attachRecordProfiles(
      c.get("memberDatastore") as Kysely<any> | undefined,
      page.records,
    );

    return success(
      c,
      {
        records,
        nextCursor: page.nextCursor,
        hasMore: page.hasMore,
        truncated: page.truncated ?? false,
        total,
      },
      "Event records fetched",
      200,
    );
  } catch (err) {
    return respondWithError(c, err, "Could not fetch event records");
  }
};

export const getMemberDetailHandler = async (c: Context) => {
  try {
    await service().loadBlacklist(c.get("datastore") as Kysely<any>);
    const memberId = c.req.param("memberId");
    if (!memberId) return errorResponse(c, "Member number is required", 400);

    const parsed = EventFiltersSchema.safeParse(c.req.query());
    if (!parsed.success) {
      logError(parsed.error, "Invalid event-analytics filters");
      return errorResponse(c, "Invalid filters", 400);
    }

    const filters: EventFilters = { ...toFilters(parsed.data), memberId };

    const [aggregate, breakdown] = await Promise.all([
      service().computeAggregates(filters, cache(c)),
      service().getMemberBreakdown(filters),
    ]);

    const memberDb = c.get("memberDatastore") as Kysely<any> | undefined;
    const [row] = await attachProfiles(
      memberDb,
      aggregate.members.filter((m) => m.memberId === memberId),
    );

    const profile =
      row?.profile ??
      (memberDb
        ? ((
            await lookupMembersByNumber(memberDb, [memberId]).catch(() => null)
          )?.get(memberId) ?? null)
        : null);

    return success(
      c,
      {
        memberId,
        profile,
        member: row ?? null,
        summary: aggregate.summary,
        eventTypes: aggregate.eventTypes,
        records: breakdown.records,
        recordsTruncated: breakdown.truncated,
        byDay: breakdown.byDay,
        byProperty: breakdown.byProperty,
        bySource: breakdown.bySource,
      },
      "Member detail fetched",
      200,
    );
  } catch (err) {
    return respondWithError(c, err, "Could not fetch the member detail");
  }
};

export const listJourneysHandler = async (c: Context) => {
  try {
    await service().loadBlacklist(c.get("datastore") as Kysely<any>);
    const parsed = ListJourneysSchema.safeParse(c.req.query());
    if (!parsed.success) {
      logError(parsed.error, "Invalid event-analytics filters");
      return errorResponse(c, "Invalid filters", 400);
    }
    const { page, pageSize, outcome } = parsed.data;
    const result = await service().listJourneys({
      filters: toFilters(parsed.data),
      page,
      pageSize,
      outcome,
    });

    const memberDb = c.get("memberDatastore") as Kysely<any> | undefined;
    let rows = result.rows;
    if (memberDb) {
      try {
        const numbers = rows
          .map((r) => r.memberId)
          .filter((id): id is string => Boolean(id));
        const profiles = numbers.length
          ? await lookupMembersByNumber(memberDb, numbers)
          : new Map();
        rows = rows.map((row) => ({
          ...row,
          memberName: row.memberId
            ? (profiles.get(row.memberId)?.fullName ?? null)
            : null,
        }));
      } catch (err) {
        logError(err, "event-analytics: journey member lookup failed");
      }
    }

    return success(
      c,
      {
        rows,
        total: result.total,
        page,
        pageSize,
        totalPages: Math.max(1, Math.ceil(result.total / pageSize)),
        truncated: result.truncated,
      },
      "Journeys fetched",
      200,
    );
  } catch (err) {
    return respondWithError(c, err, "Could not fetch journeys");
  }
};

function sortMembers(
  rows: MemberAnalyticsRow[],
  sortBy: "events" | "revenue" | "points" | "lastSeen" | "member",
  sortDir: "asc" | "desc",
): MemberAnalyticsRow[] {
  const dir = sortDir === "asc" ? 1 : -1;
  const topRevenue = (r: MemberAnalyticsRow) =>
    r.revenueByCurrency.reduce((max, x) => Math.max(max, x.revenue), 0);

  return [...rows].sort((a, b) => {
    switch (sortBy) {
      case "revenue":
        return (topRevenue(a) - topRevenue(b)) * dir;
      case "points":
        return (a.points - b.points) * dir;
      case "lastSeen":
        return ((a.lastSeen ?? "") < (b.lastSeen ?? "") ? -1 : 1) * dir;
      case "member":
        return (
          (a.memberName ?? a.memberId).localeCompare(
            b.memberName ?? b.memberId,
          ) * dir
        );
      default:
        return (a.events - b.events) * dir;
    }
  });
}

/* ── blacklist ───────────────────────────────────────────────────────────── */

export async function listBlacklistHandler(c: Context) {
  try {
    const start = Number(c.req.query("start") ?? "0") || 0;
    const pageSize = Math.min(
      Number(c.req.query("pageSize") ?? "10") || 10,
      100,
    );
    const search = c.req.query("search") ?? undefined;
    const result = await listBlacklist(c.get("datastore") as Kysely<any>, {
      start,
      pageSize,
      search,
    });
    return success(c, result);
  } catch (err) {
    logError(err, "event-analytics: blacklist list failed");
    return errorResponse(c, "Could not read the blacklist", 500);
  }
}

export async function addToBlacklistHandler(c: Context) {
  const body = await c.req.json().catch(() => ({}));
  const parsed = AddBlacklistSchema.safeParse(body);
  if (!parsed.success) {
    return errorResponse(c, "Provide a membership number or an email address", 400);
  }

  const { memberNumber, email, reason, label } = parsed.data;
  const db = c.get("datastore") as Kysely<any>;
  const memberDb = c.get("memberDatastore") as Kysely<any> | undefined;

  let numbers: string[] = memberNumber ? [memberNumber] : [];
  if (!numbers.length && email) {
    if (!memberDb) {
      return errorResponse(
        c,
        "Member lookup is unavailable; add by membership number",
        503,
      );
    }
    try {
      numbers = await membershipNumbersForEmail(memberDb, email);
    } catch (err) {
      logError(err, "event-analytics: blacklist email lookup failed");
      return errorResponse(c, "Could not look up that email address", 500);
    }
    if (!numbers.length) {
      return errorResponse(c, `No membership found for ${email}`, 404);
    }
  }

  try {
    const entries = [];
    for (const number of numbers) {
      entries.push(
        await addToBlacklist(db, {
          memberNumber: number,
          email: email ?? null,
          label: label ?? null,
          reason: reason ?? null,
          createdBy: (c.get("consoleUser") as { email?: string } | undefined)?.email ?? null,
        }),
      );
    }
    service().invalidateBlacklist();
    return success(c, { entries });
  } catch (err) {
    logError(err, "event-analytics: blacklist add failed");
    return errorResponse(c, "Could not add that account", 500);
  }
}

export async function toggleBlacklistHandler(c: Context) {
  const id = c.req.param("id");
  if (!id) return errorResponse(c, "No such entry", 404);
  const body = await c.req.json().catch(() => ({}));
  const isActive = Boolean(body?.isActive);
  try {
    const updated = await setBlacklistActive(
      c.get("datastore") as Kysely<any>,
      id,
      isActive,
      (c.get("consoleUser") as { email?: string } | undefined)?.email ?? null,
    );
    if (!updated) return errorResponse(c, "No such entry", 404);
    service().invalidateBlacklist();
    return success(c, { id, isActive });
  } catch (err) {
    logError(err, "event-analytics: blacklist toggle failed");
    return errorResponse(c, "Could not update that account", 500);
  }
}

export async function removeFromBlacklistHandler(c: Context) {
  const id = c.req.param("id");
  if (!id) return errorResponse(c, "No such entry", 404);
  try {
    const removed = await removeFromBlacklist(c.get("datastore") as Kysely<any>, id);
    if (!removed) return errorResponse(c, "No such entry", 404);
    service().invalidateBlacklist();
    return success(c, { id });
  } catch (err) {
    logError(err, "event-analytics: blacklist remove failed");
    return errorResponse(c, "Could not remove that account", 500);
  }
}
