"use client";

import {
  Badge,
  Button,
  Card,
  Group,
  Loader,
  Modal,
  MultiSelect,
  Select,
  Stack,
  Table,
  TagsInput,
  Text,
  Textarea,
  TextInput,
  Title,
} from "@mantine/core";
import { useForm } from "@mantine/form";
import { useDebouncedValue } from "@mantine/hooks";
import { notifications } from "@mantine/notifications";
import {
  IconArchive,
  IconCheck,
  IconPencil,
  IconPlus,
  IconSearch,
} from "@tabler/icons-react";
import { useCallback, useEffect, useState } from "react";
import { listKnowledge } from "@/lib/features/kevo/query";
import {
  approveKnowledge,
  createKnowledge,
  retireKnowledge,
  updateKnowledge,
} from "@/lib/features/kevo/action";
import type { KevoKnowledgeEntry } from "@/lib/features/kevo/types";
import type { AccessScope } from "@/lib/features/types";
import {
  ENTRY_STATUS_COLOR,
  formatDate,
  KARMA,
} from "../_components/kevo.constants";

const STATUS_OPTIONS = ["DRAFT", "APPROVED", "PUBLISHED", "RETIRED"].map(
  (v) => ({ value: v, label: v.charAt(0) + v.slice(1).toLowerCase() }),
);

export default function KevoKnowledgeClientPage({
  accessScope,
}: {
  accessScope: AccessScope;
}) {
  const [entries, setEntries] = useState<KevoKnowledgeEntry[]>([]);
  const [loading, setLoading] = useState(true);
  const [statuses, setStatuses] = useState<string[]>([]);
  const [search, setSearch] = useState("");
  const [debouncedSearch] = useDebouncedValue(search, 350);
  const [editing, setEditing] = useState<KevoKnowledgeEntry | "new" | null>(
    null,
  );

  const canWrite = accessScope.create || accessScope.superAdmin;
  const canReview = accessScope.update || accessScope.superAdmin;
  const canRetire = accessScope.delete || accessScope.superAdmin;

  const load = useCallback(async () => {
    setLoading(true);
    const res = await listKnowledge({
      statuses: statuses.length ? statuses : undefined,
      search: debouncedSearch || undefined,
    });
    if (res.success) setEntries(res.data);
    setLoading(false);
  }, [statuses, debouncedSearch]);

  useEffect(() => {
    void load();
  }, [load]);

  const form = useForm({
    initialValues: {
      entity: "",
      aliases: [] as string[],
      property: "",
      category: "correction",
      verified_text: "",
    },
    validate: {
      entity: (v) => (v.trim() ? null : "Entity is required"),
      verified_text: (v) => (v.trim() ? null : "Write the verified statement"),
    },
  });

  const openEditor = (entry: KevoKnowledgeEntry | "new") => {
    if (entry === "new") {
      form.setValues({
        entity: "",
        aliases: [],
        property: "",
        category: "correction",
        verified_text: "",
      });
    } else {
      form.setValues({
        entity: entry.entity,
        aliases: entry.aliases ?? [],
        property: entry.property ?? "",
        category: entry.category,
        verified_text: entry.verified_text,
      });
    }
    setEditing(entry);
  };

  const submit = form.onSubmit(async (values) => {
    const payload = {
      entity: values.entity.trim(),
      aliases: values.aliases,
      property: values.property.trim() || undefined,
      category: values.category,
      verified_text: values.verified_text.trim(),
    };
    const res =
      editing === "new"
        ? await createKnowledge(payload)
        : await updateKnowledge((editing as KevoKnowledgeEntry).id, payload);
    notifications.show({
      message: res.message,
      color: res.success ? "teal" : "red",
    });
    if (res.success) {
      setEditing(null);
      await load();
    }
  });

  const act = async (fn: () => Promise<{ success: boolean; message: string }>) => {
    const res = await fn();
    notifications.show({
      message: res.message,
      color: res.success ? "teal" : "red",
    });
    if (res.success) await load();
  };

  return (
    <Stack gap="lg">
      <Group justify="space-between" wrap="wrap">
        <div>
          <Title order={2}>Verified knowledge</Title>
          <Text c="dimmed" size="sm">
            Approved facts that get published into Kevo's knowledge base.
          </Text>
        </div>
        {canWrite && (
          <Button
            leftSection={<IconPlus size={16} />}
            color={KARMA.black}
            onClick={() => openEditor("new")}
          >
            New entry
          </Button>
        )}
      </Group>

      <Group wrap="wrap">
        <TextInput
          placeholder="Search entity or statement…"
          leftSection={<IconSearch size={16} />}
          value={search}
          onChange={(e) => setSearch(e.currentTarget.value)}
          w={{ base: "100%", sm: 320 }}
          radius="xl"
        />
        <MultiSelect
          data={STATUS_OPTIONS}
          value={statuses}
          onChange={setStatuses}
          placeholder="All statuses"
          clearable
          w={{ base: "100%", sm: 260 }}
        />
      </Group>

      <Card radius="lg" withBorder p={0}>
        {loading ? (
          <Group justify="center" py={60}>
            <Loader size="sm" color={KARMA.bronze} />
          </Group>
        ) : entries.length === 0 ? (
          <Stack align="center" py={60} gap={4}>
            <Text fw={600}>No knowledge entries yet</Text>
            <Text c="dimmed" size="sm">
              Corrections written from flags appear here.
            </Text>
          </Stack>
        ) : (
          <Table.ScrollContainer minWidth={720}>
            <Table highlightOnHover verticalSpacing="sm">
              <Table.Thead>
                <Table.Tr>
                  <Table.Th>Entity</Table.Th>
                  <Table.Th>Property</Table.Th>
                  <Table.Th>Statement</Table.Th>
                  <Table.Th>Status</Table.Th>
                  <Table.Th>Updated</Table.Th>
                  <Table.Th />
                </Table.Tr>
              </Table.Thead>
              <Table.Tbody>
                {entries.map((entry) => (
                  <Table.Tr key={entry.id}>
                    <Table.Td>
                      <Text size="sm" fw={600}>
                        {entry.entity}
                      </Text>
                      {entry.aliases?.length > 0 && (
                        <Text size="xs" c="dimmed" lineClamp={1}>
                          aka {entry.aliases.join(", ")}
                        </Text>
                      )}
                    </Table.Td>
                    <Table.Td>
                      <Text size="sm">{entry.property ?? "General"}</Text>
                    </Table.Td>
                    <Table.Td maw={360}>
                      <Text size="sm" lineClamp={2}>
                        {entry.verified_text}
                      </Text>
                    </Table.Td>
                    <Table.Td>
                      <Badge
                        color={ENTRY_STATUS_COLOR[entry.status]}
                        variant="filled"
                        radius="xl"
                        size="sm"
                      >
                        {entry.status.toLowerCase()}
                      </Badge>
                    </Table.Td>
                    <Table.Td>
                      <Text size="xs" c="dimmed">
                        {formatDate(entry.updated_at ?? entry.created_at)} · v
                        {entry.version}
                      </Text>
                    </Table.Td>
                    <Table.Td>
                      <Group gap={4} justify="flex-end" wrap="nowrap">
                        {canWrite && entry.status !== "RETIRED" && (
                          <Button
                            variant="subtle"
                            size="compact-xs"
                            leftSection={<IconPencil size={13} />}
                            onClick={() => openEditor(entry)}
                          >
                            Edit
                          </Button>
                        )}
                        {canReview && entry.status === "DRAFT" && (
                          <Button
                            variant="subtle"
                            size="compact-xs"
                            color="teal"
                            leftSection={<IconCheck size={13} />}
                            onClick={() =>
                              void act(() => approveKnowledge(entry.id))
                            }
                          >
                            Approve
                          </Button>
                        )}
                        {canRetire && entry.status !== "RETIRED" && (
                          <Button
                            variant="subtle"
                            size="compact-xs"
                            color="gray"
                            leftSection={<IconArchive size={13} />}
                            onClick={() =>
                              void act(() => retireKnowledge(entry.id))
                            }
                          >
                            Retire
                          </Button>
                        )}
                      </Group>
                    </Table.Td>
                  </Table.Tr>
                ))}
              </Table.Tbody>
            </Table>
          </Table.ScrollContainer>
        )}
      </Card>

      <Modal
        opened={editing !== null}
        onClose={() => setEditing(null)}
        title={<Text fw={700}>{editing === "new" ? "New entry" : "Edit entry"}</Text>}
        size="lg"
      >
        <form onSubmit={submit}>
          <Stack gap="sm">
            <TextInput
              label="Entity"
              required
              {...form.getInputProps("entity")}
            />
            <TagsInput
              label="Aliases"
              placeholder="Type and press Enter"
              {...form.getInputProps("aliases")}
            />
            <TextInput
              label="Property"
              description="Leave empty for general facts"
              {...form.getInputProps("property")}
            />
            <Select
              label="Type"
              data={[
                { value: "amenity", label: "Amenity" },
                { value: "policy", label: "Policy" },
                { value: "faq", label: "FAQ" },
                { value: "correction", label: "Correction" },
              ]}
              {...form.getInputProps("category")}
            />
            <Textarea
              label="Verified statement"
              autosize
              minRows={3}
              required
              {...form.getInputProps("verified_text")}
            />
            <Group justify="flex-end">
              <Button variant="default" onClick={() => setEditing(null)}>
                Cancel
              </Button>
              <Button type="submit" color={KARMA.black}>
                Save
              </Button>
            </Group>
          </Stack>
        </form>
      </Modal>
    </Stack>
  );
}
