import type { Context } from "hono";
import { z } from "zod";
import { logError } from "@/lib/logger";
import { error as errorResponse, getErrorMessage, success } from "@/lib/response";
import {
  ViewpointImportRepository,
  type BookingFilters,
} from "@/internal/viewpoint-import/viewpoint-import.repo";
import {
  SYNC_BATCH_LIMIT,
  syncBookingsFromViewpoint,
} from "@/internal/viewpoint-import/viewpoint-sync.service";
import {
  VIEWPOINT_FIELDS,
  VIEWPOINT_REPORT_TYPES,
  guessField,
  type ViewpointReportType,
} from "@/internal/viewpoint-import/viewpoint-fields";

function repo(c: Context) {
  return new ViewpointImportRepository(
    c.get("datastore"),
    c.get("memberDatastore"),
  );
}

function isSuperAdmin(c: Context): boolean {
  return c.get("isAdminConsoleSuperAdmin") === true;
}

function forbidden(c: Context) {
  return errorResponse(c, "Not found", 404);
}

const ReportTypeSchema = z.enum(VIEWPOINT_REPORT_TYPES);

const CommitImportSchema = z.object({
  reportType: ReportTypeSchema,
  filename: z.string().min(1).max(255),
  sheetName: z.string().max(255).nullish(),
  sheetColumns: z.array(z.string()).default([]),
  columnMap: z.record(z.string(), z.string()),
  rows: z
    .array(z.record(z.string(), z.unknown()))
    .min(1)
    .max(20000),
});

const BookingQuerySchema = z.object({
  page: z.coerce.number().int().min(1).default(1),
  pageSize: z.coerce.number().int().min(1).max(200).default(50),
  origins: z.array(z.enum(["subito", "viewpoint", "unchecked"])).optional(),
  sources: z.array(z.string()).optional(),
  statuses: z.array(z.string()).optional(),
  from: z.string().optional(),
  to: z.string().optional(),
  membershipNumbers: z.array(z.string()).optional(),
  promoCodes: z.array(z.string()).optional(),
  search: z.string().optional(),
  onlyUnmatched: z.boolean().optional(),
});

const SyncSchema = z.object({
  bookingNumbers: z.array(z.string().min(1)).max(SYNC_BATCH_LIMIT).optional(),
  limit: z.coerce.number().int().min(1).max(SYNC_BATCH_LIMIT).optional(),
});

export const viewpointFieldsHandler = async (c: Context) => {
  try {
    const body = (await c.req.json().catch(() => ({}))) as {
      reportType?: string;
      headers?: string[];
    };
    const parsedType = ReportTypeSchema.safeParse(body.reportType);
    if (!parsedType.success) {
      return errorResponse(c, "Unknown report type", 400);
    }
    const reportType = parsedType.data;
    const headers = Array.isArray(body.headers) ? body.headers : [];

    return success(
      c,
      {
        fields: VIEWPOINT_FIELDS[reportType].map((f) => ({
          key: f.key,
          label: f.label,
          kind: f.kind,
          required: Boolean(f.required),
        })),
        suggested: Object.fromEntries(
          headers
            .map((h) => [h, guessField(h, reportType)] as const)
            .filter(([, key]) => key !== null),
        ),
      },
      "Viewpoint fields fetched successfully",
      200,
    );
  } catch (err) {
    logError(err);
    return errorResponse(c, getErrorMessage(err, "Failed to fetch fields"), 500);
  }
};

export const commitViewpointImportHandler = async (c: Context) => {
  if (!isSuperAdmin(c)) return forbidden(c);

  try {
    const body = await c.req.json();
    const parsed = CommitImportSchema.safeParse(body);
    if (!parsed.success) {
      return errorResponse(
        c,
        parsed.error.issues[0]?.message ?? "Invalid import payload",
        400,
      );
    }
    const input = parsed.data;
    const reportType = input.reportType as ViewpointReportType;

    const required = VIEWPOINT_FIELDS[reportType].filter((f) => f.required);
    const mapped = new Set(Object.values(input.columnMap));
    const unmappedRequired = required.filter((f) => !mapped.has(f.key));
    if (unmappedRequired.length > 0) {
      return errorResponse(
        c,
        `Map a column to ${unmappedRequired
          .map((f) => f.label)
          .join(", ")} before importing — it identifies the row on re-import.`,
        400,
      );
    }

    const r = repo(c);
    const { prepared, skipped } = r.prepareRows(
      reportType,
      input.columnMap,
      input.rows,
    );

    const importRow = await r.createImport({
      reportType,
      filename: input.filename,
      sheetName: input.sheetName ?? null,
      uploadedBy: String(c.get("adminEmail") ?? "") || null,
      uploadedById: String(c.get("consoleUserId") ?? "") || null,
      sheetColumns: input.sheetColumns,
      columnMap: input.columnMap,
      rowCount: input.rows.length,
    });

    const counts =
      prepared.length > 0
        ? await r.upsertRows(reportType, importRow.id, prepared)
        : { inserted: 0, updated: 0 };

    await r.finishImport(importRow.id, {
      inserted: counts.inserted,
      updated: counts.updated,
      skipped: skipped.length,
    });

    return success(
      c,
      {
        importId: importRow.id,
        rowCount: input.rows.length,
        inserted: counts.inserted,
        updated: counts.updated,
        skippedCount: skipped.length,
        skipped: skipped.slice(0, 50),
      },
      `Imported ${counts.inserted + counts.updated} row${
        counts.inserted + counts.updated === 1 ? "" : "s"
      }`,
      200,
    );
  } catch (err) {
    logError(err);
    const message = getErrorMessage(err, "Failed to import the report");
    if (/value too long/i.test(message)) {
      return errorResponse(
        c,
        "One of the mapped columns contains a value longer than the field allows, so nothing was imported. Leave that column out, or ask for the field to be widened.",
        400,
      );
    }
    return errorResponse(c, message, 500);
  }
};

export const listViewpointImportsHandler = async (c: Context) => {
  try {
    const raw = c.req.query("reportType");
    const parsed = ReportTypeSchema.safeParse(raw);
    const r = repo(c);
    const items = await r.listImports(parsed.success ? parsed.data : undefined);

    const withCounts = await Promise.all(
      items.map(async (item: any) => ({
        ...item,
        storedRows: await r.countRowsForImport(item.report_type, item.id),
      })),
    );

    return success(
      c,
      { items: withCounts },
      "Import history fetched successfully",
      200,
    );
  } catch (err) {
    logError(err);
    return errorResponse(
      c,
      getErrorMessage(err, "Failed to fetch import history"),
      500,
    );
  }
};

function bookingFilters(input: z.infer<typeof BookingQuerySchema>): BookingFilters {
  return {
    origins: input.origins?.length ? input.origins : undefined,
    sources: input.sources?.length ? input.sources : undefined,
    statuses: input.statuses?.length ? input.statuses : undefined,
    from: input.from,
    to: input.to,
    membershipNumbers: input.membershipNumbers?.length
      ? input.membershipNumbers
      : undefined,
    promoCodes: input.promoCodes?.length ? input.promoCodes : undefined,
    search: input.search,
    onlyUnmatched: input.onlyUnmatched,
  };
}

export const listViewpointBookingsHandler = async (c: Context) => {
  try {
    const body = await c.req.json().catch(() => ({}));
    const parsed = BookingQuerySchema.safeParse(body);
    if (!parsed.success) {
      return errorResponse(c, "Invalid booking query", 400);
    }
    const input = parsed.data;
    const result = await repo(c).listBookings({
      ...bookingFilters(input),
      page: input.page,
      pageSize: input.pageSize,
    });
    return success(
      c,
      {
        items: result.items,
        pagination: {
          page: input.page,
          pageSize: input.pageSize,
          total: result.total,
        },
      },
      "Viewpoint bookings fetched successfully",
      200,
    );
  } catch (err) {
    logError(err);
    return errorResponse(
      c,
      getErrorMessage(err, "Failed to fetch Viewpoint bookings"),
      500,
    );
  }
};

export const viewpointBookingAnalyticsHandler = async (c: Context) => {
  try {
    const body = await c.req.json().catch(() => ({}));
    const parsed = BookingQuerySchema.safeParse(body);
    if (!parsed.success) {
      return errorResponse(c, "Invalid booking query", 400);
    }
    const r = repo(c);
    const [aggregates, options, origin, createdOrigin, byPromoCode, dimensions] =
      await Promise.all([
      r.bookingAggregates(bookingFilters(parsed.data)),
      r.bookingFilterOptions(),
      r.originBreakdown(),
      r.createdOriginMatrix({ statuses: parsed.data.statuses }),
      r.bookingsByPromoCode(undefined, { statuses: parsed.data.statuses }),
      r.bookingDimensions(bookingFilters(parsed.data)),
    ]);
    return success(
      c,
      { ...aggregates, options, origin, createdOrigin, byPromoCode, ...dimensions },
      "Viewpoint booking analytics fetched successfully",
      200,
    );
  } catch (err) {
    logError(err);
    return errorResponse(
      c,
      getErrorMessage(err, "Failed to fetch Viewpoint booking analytics"),
      500,
    );
  }
};

export const listViewpointMemberContactsHandler = async (c: Context) => {
  try {
    const body = (await c.req.json().catch(() => ({}))) as Record<
      string,
      unknown
    >;
    const parsed = z
      .object({
        page: z.coerce.number().int().min(1).default(1),
        pageSize: z.coerce.number().int().min(1).max(200).default(50),
        search: z.string().optional(),
        onlyUnmatched: z.boolean().optional(),
      })
      .safeParse(body);
    if (!parsed.success) {
      return errorResponse(c, "Invalid contact query", 400);
    }
    const result = await repo(c).listMemberContacts(parsed.data);
    return success(
      c,
      {
        items: result.items,
        pagination: {
          page: parsed.data.page,
          pageSize: parsed.data.pageSize,
          total: result.total,
        },
      },
      "Viewpoint member contacts fetched successfully",
      200,
    );
  } catch (err) {
    logError(err);
    return errorResponse(
      c,
      getErrorMessage(err, "Failed to fetch Viewpoint member contacts"),
      500,
    );
  }
};

export const viewpointDirectByPromoCodeHandler = async (c: Context) => {
  try {
    const items = await repo(c).viewpointDirectByPromoCode();
    return success(
      c,
      {
        items,
        total: items.reduce((sum, r) => sum + r.bookings, 0),
      },
      "Viewpoint-direct bookings fetched successfully",
      200,
    );
  } catch (err) {
    logError(err);
    return errorResponse(
      c,
      getErrorMessage(err, "Failed to fetch Viewpoint-direct bookings"),
      500,
    );
  }
};

export const syncViewpointFromCoreHandler = async (c: Context) => {
  try {
    const outcome = await repo(c).matchAgainstCore();
    return success(
      c,
      outcome,
      outcome.checked === 0
        ? "Nothing imported yet, so there was nothing to reconcile."
        : `Checked ${outcome.checked} booking${outcome.checked === 1 ? "" : "s"}: ${outcome.matched} also in core, ${outcome.unmatched} only in Viewpoint.`,
      200,
    );
  } catch (err) {
    logError(err);
    return errorResponse(
      c,
      getErrorMessage(err, "Failed to reconcile against core"),
      500,
    );
  }
};

export const countViewpointBookingsHandler = async (c: Context) => {
  try {
    const body = await c.req.json().catch(() => ({}));
    const parsed = BookingQuerySchema.safeParse(body);
    if (!parsed.success) {
      return errorResponse(c, "Invalid booking query", 400);
    }
    const total = await repo(c).countBookingsByFilters(
      bookingFilters(parsed.data),
    );
    return success(c, { total }, "Counted successfully", 200);
  } catch (err) {
    logError(err);
    return errorResponse(c, getErrorMessage(err, "Failed to count bookings"), 500);
  }
};

export const deleteViewpointDataHandler = async (c: Context) => {
  if (!isSuperAdmin(c)) return forbidden(c);

  try {
    const body = await c.req.json().catch(() => ({}));
    const parsed = z
      .object({
        reportType: ReportTypeSchema,
        importId: z.string().uuid().optional(),
        bookingNumbers: z.array(z.string().min(1)).max(500).optional(),
        filters: BookingQuerySchema.partial().optional(),
        confirmAll: z.boolean().optional(),
      })
      .safeParse(body);
    if (!parsed.success) {
      return errorResponse(c, "Invalid delete request", 400);
    }
    const { reportType, importId, bookingNumbers, filters, confirmAll } =
      parsed.data;
    const r = repo(c);

    if (bookingNumbers?.length) {
      if (reportType !== "bookings") {
        return errorResponse(
          c,
          "Deleting by booking number is only available for bookings.",
          400,
        );
      }
      const deleted = await r.deleteBookingsByNumbers(bookingNumbers);
      return success(
        c,
        { deleted, scope: "rows" as const, viewpointUnchanged: true },
        `Removed ${deleted} booking${deleted === 1 ? "" : "s"} from console2. Viewpoint is unchanged.`,
        200,
      );
    }

    const narrowing = filters
      ? Boolean(
          filters.origins?.length ||
            filters.sources?.length ||
            filters.statuses?.length ||
            filters.membershipNumbers?.length ||
            filters.search?.trim() ||
            filters.from ||
            filters.to ||
            filters.onlyUnmatched,
        )
      : false;

    if (filters && narrowing) {
      if (reportType !== "bookings") {
        return errorResponse(
          c,
          "Filtered delete is only available for bookings.",
          400,
        );
      }
      const scoped = bookingFilters({
        ...filters,
        page: 1,
        pageSize: 1,
      } as any);
      const deleted = await r.deleteBookingsByFilters(scoped);
      return success(
        c,
        { deleted, scope: "filtered" as const, viewpointUnchanged: true },
        `Removed ${deleted} matching row${deleted === 1 ? "" : "s"} from console2. Viewpoint is unchanged.`,
        200,
      );
    }

    if (importId) {
      const deleted = await r.deleteRowsForImport(reportType, importId);
      return success(
        c,
        { deleted, scope: "import" as const, viewpointUnchanged: true },
        `Removed ${deleted} row${deleted === 1 ? "" : "s"} from console2. Viewpoint is unchanged.`,
        200,
      );
    }

    if (confirmAll !== true) {
      return errorResponse(
        c,
        "Deleting every imported row requires confirmAll: true.",
        400,
      );
    }

    const deleted = await r.deleteAllRows(reportType);
    return success(
      c,
      { deleted, scope: "all" as const, viewpointUnchanged: true },
      `Removed all ${deleted} imported row${deleted === 1 ? "" : "s"} from console2. Viewpoint is unchanged.`,
      200,
    );
  } catch (err) {
    logError(err);
    return errorResponse(
      c,
      getErrorMessage(err, "Failed to remove imported rows"),
      500,
    );
  }
};

export const syncViewpointBookingsHandler = async (c: Context) => {
  if (!isSuperAdmin(c)) return forbidden(c);

  try {
    const body = await c.req.json().catch(() => ({}));
    const parsed = SyncSchema.safeParse(body);
    if (!parsed.success) {
      return errorResponse(c, "Invalid sync request", 400);
    }
    const outcome = await syncBookingsFromViewpoint(repo(c), parsed.data);

    const wholeBatchFailed =
      outcome.attempted > 0 && outcome.failed === outcome.attempted;
    return success(
      c,
      outcome,
      wholeBatchFailed
        ? `Sync failed for all ${outcome.attempted} bookings — ${
            outcome.errors[0]?.message ?? "Viewpoint request failed"
          }`
        : `Synced ${outcome.updated} of ${outcome.attempted} booking${
            outcome.attempted === 1 ? "" : "s"
          }`,
      200,
    );
  } catch (err) {
    logError(err);
    return errorResponse(
      c,
      getErrorMessage(err, "Failed to sync bookings from Viewpoint"),
      500,
    );
  }
};
