import {
  MemberDataTable,
  type MemberColumn,
} from "@/routes/members/_components/MemberDataTable";
import { TableFilterDrawer } from "@/routes/members/_components/TableFilterDrawer";
import type { CoreMemberActivityLog } from "@/lib/features/members/types";
import { Badge, Code, Flex, Group, Modal, Stack, Text } from "@mantine/core";
import moment from "moment";
import { useMemo, useState } from "react";
import {
  outcomeTone,
  recordStateTone,
} from "@/routes/members/_components/statusColors";

const MemberLogsTable: React.FC<{ memberLogs: CoreMemberActivityLog[] }> = ({
  memberLogs,
}) => {
  const [selectedLog, setSelectedLog] = useState<CoreMemberActivityLog | null>(
    null,
  );
  const [search, setSearch] = useState("");
  const [actorTypes, setActorTypes] = useState<string[]>([]);
  const [statuses, setStatuses] = useState<string[]>([]);

  const statusOptions = useMemo(
    () =>
      Array.from(
        new Set(memberLogs.map((log) => log.status).filter(Boolean)),
      ).map((status) => ({
        value: String(status),
        label: String(status).toLowerCase(),
      })),
    [memberLogs],
  );

  const filtered = useMemo(() => {
    const term = search.trim().toLowerCase();
    return memberLogs.filter((log) => {
      if (actorTypes.length && !actorTypes.includes(log.actor_type))
        return false;
      if (statuses.length && !statuses.includes(String(log.status)))
        return false;
      if (!term) return true;
      return [
        log.action,
        log.entity_type,
        log.entity_id,
        log.userDetails?.name,
        log.ip_address,
      ]
        .filter(Boolean)
        .some((value) => String(value).toLowerCase().includes(term));
    });
  }, [memberLogs, search, actorTypes, statuses]);

  return (
    <Flex direction={"column"} gap={12}>
      <Group justify="space-between" align="center">
        <Text fz={13} fw={600}>
          Activity Logs
        </Text>
        <TableFilterDrawer
          title="Filter Activity"
          search={search}
          onSearchChange={setSearch}
          searchDescription="Action, entity, user or IP"
          filters={[
            {
              key: "actorType",
              label: "Actor",
              data: [
                { value: "member", label: "Member" },
                { value: "console_user", label: "Console User" },
              ],
              value: actorTypes,
              onChange: setActorTypes,
            },
            {
              key: "status",
              label: "Status",
              data: statusOptions,
              value: statuses,
              onChange: setStatuses,
            },
          ]}
        />
      </Group>
      <MemberDataTable
        rows={filtered}
        columns={columns}
        minWidth={1100}
        rowKey={(row, index) => `${row.id ?? index}`}
        onRowClick={setSelectedLog}
        emptyMessage="No Logs Found"
      />

      <Modal
        opened={Boolean(selectedLog)}
        onClose={() => setSelectedLog(null)}
        title="Member Activity Log"
        size="lg"
      >
        {selectedLog ? (
          <Stack gap={"xs"}>
            <Text fz={13} fw={500} tt="capitalize">
              {selectedLog.action?.replaceAll("_", " ")} ·{" "}
              {selectedLog.entity_type?.replaceAll("_", " ")}
            </Text>
            <Text fz={12} c={"dimmed"}>
              {selectedLog.userDetails?.name || selectedLog.actor_id} ·{" "}
              {moment(selectedLog.created_at).format("YYYY-MM-DD HH:mm:ss")}
              {selectedLog.ip_address ? ` · ${selectedLog.ip_address}` : ""}
            </Text>
            {selectedLog.error_message ? (
              <Text fz={12} c={"red"}>
                {selectedLog.error_message}
              </Text>
            ) : null}
            <Code block>
              {JSON.stringify(
                {
                  delta: selectedLog.delta,
                  before: selectedLog.before_state,
                  after: selectedLog.after_state,
                  metadata: selectedLog.metadata,
                },
                null,
                2,
              )}
            </Code>
          </Stack>
        ) : null}
      </Modal>
    </Flex>
  );
};

export default MemberLogsTable;

const columns: MemberColumn<CoreMemberActivityLog>[] = [
  {
    key: "actorType",
    header: "Actor Type",
    render: (row) => (
      <Badge
        {...recordStateTone(row.actor_type === "member")}
        size="sm"
        radius={4}
        tt="capitalize"
      >
        {row.actor_type?.replaceAll("_", " ") || "NA"}
      </Badge>
    ),
  },
  {
    key: "user",
    header: "User",
    render: (row) => row.userDetails?.name || "NA",
  },
  {
    key: "action",
    header: "Action",
    render: (row) => (
      <Text fz={11.5} tt="capitalize">
        {row.entity_type?.replaceAll("_", " ") || "NA"}
      </Text>
    ),
  },
  {
    key: "status",
    header: "Status",
    render: (row) => (
      <Badge {...outcomeTone(row.status)} tt="capitalize">
        {row.status?.toLowerCase() || "NA"}
      </Badge>
    ),
  },
  {
    key: "createdAt",
    header: "Created At",
    render: (row) => moment(row.created_at).format("YYYY-MM-DD HH:mm:ss"),
  },
];
