import {
  ActionGroup,
  Button,
  Chip,
  ChipGroup,
  DescriptionList,
  DescriptionListDescription,
  DescriptionListGroup,
  DescriptionListTerm,
  Divider,
  Dropdown,
  DropdownToggle,
  Flex,
  FlexItem,
  Form,
  FormGroup,
  PageSection,
  Select,
  SelectOption,
  SelectVariant,
  Tab,
  TabTitleText,
  TextInput,
  Tooltip,
} from "@patternfly/react-core";
import { CheckCircleIcon, WarningTriangleIcon } from "@patternfly/react-icons";
import { cellWidth, expandable } from "@patternfly/react-table";
import type EventRepresentation from "keycloak-admin/lib/defs/eventRepresentation";
import type EventType from "keycloak-admin/lib/defs/eventTypes";
import type { RealmEventsConfigRepresentation } from "keycloak-admin/lib/defs/realmEventsConfigRepresentation";
import { pickBy } from "lodash";
import moment from "moment";
import React, { useState } from "react";
import { Controller, useForm } from "react-hook-form";
import { Trans, useTranslation } from "react-i18next";
import { Link } from "react-router-dom";
import { KeycloakTabs } from "../components/keycloak-tabs/KeycloakTabs";
import { ListEmptyState } from "../components/list-empty-state/ListEmptyState";
import { KeycloakDataTable } from "../components/table-toolbar/KeycloakDataTable";
import { ViewHeader } from "../components/view-header/ViewHeader";
import { useAdminClient, useFetch } from "../context/auth/AdminClient";
import { useRealm } from "../context/realm-context/RealmContext";
import { toRealmSettings } from "../realm-settings/routes/RealmSettings";
import { toUser } from "../user/routes/User";
import { AdminEvents } from "./AdminEvents";
import "./events-section.css";

type UserEventSearchForm = {
  client: string;
  dateFrom: string;
  dateTo: string;
  user: string;
  type: EventType[];
};

const defaultValues: UserEventSearchForm = {
  client: "",
  dateFrom: "",
  dateTo: "",
  user: "",
  type: [],
};

const StatusRow = (event: EventRepresentation) =>
  !event.error ? (
    <span>
      <CheckCircleIcon color="green" /> {event.type}
    </span>
  ) : (
    <Tooltip content={event.error}>
      <span>
        <WarningTriangleIcon color="orange" /> {event.type}
      </span>
    </Tooltip>
  );

const DetailCell = (event: EventRepresentation) => (
  <DescriptionList isHorizontal className="keycloak_eventsection_details">
    {Object.entries(event.details!).map(([key, value]) => (
      <DescriptionListGroup key={key}>
        <DescriptionListTerm>{key}</DescriptionListTerm>
        <DescriptionListDescription>{value}</DescriptionListDescription>
      </DescriptionListGroup>
    ))}
  </DescriptionList>
);

export const EventsSection = () => {
  const { t } = useTranslation("events");
  const adminClient = useAdminClient();
  const { realm } = useRealm();
  const [key, setKey] = useState(0);
  const [searchDropdownOpen, setSearchDropdownOpen] = useState(false);
  const [selectOpen, setSelectOpen] = useState(false);
  const [events, setEvents] = useState<RealmEventsConfigRepresentation>();
  const [activeFilters, setActiveFilters] = useState<
    Partial<UserEventSearchForm>
  >({});

  const filterLabels: Record<keyof UserEventSearchForm, string> = {
    client: t("client"),
    dateFrom: t("dateFrom"),
    dateTo: t("dateTo"),
    user: t("userId"),
    type: t("eventType"),
  };

  const {
    getValues,
    register,
    reset,
    formState: { isDirty },
    control,
  } = useForm<UserEventSearchForm>({
    shouldUnregister: false,
    mode: "onChange",
    defaultValues,
  });

  useFetch(
    () => adminClient.realms.getConfigEvents({ realm }),
    (events) => setEvents(events),
    []
  );

  function loader(first?: number, max?: number) {
    return adminClient.realms.findEvents({
      // The admin client wants 'dateFrom' and 'dateTo' to be Date objects, however it cannot actually handle them so we need to cast to any.
      ...(activeFilters as any),
      realm,
      first,
      max,
    });
  }

  function submitSearch() {
    setSearchDropdownOpen(false);
    commitFilters();
  }

  function removeFilter(key: keyof UserEventSearchForm) {
    const formValues: UserEventSearchForm = { ...getValues() };
    delete formValues[key];

    reset({ ...defaultValues, ...formValues });
    commitFilters();
  }

  function removeFilterValue(
    key: keyof UserEventSearchForm,
    valueToRemove: EventType
  ) {
    const formValues = getValues();
    const fieldValue = formValues[key];
    const newFieldValue = Array.isArray(fieldValue)
      ? fieldValue.filter((val) => val !== valueToRemove)
      : fieldValue;

    reset({ ...formValues, [key]: newFieldValue });
    commitFilters();
  }

  function commitFilters() {
    const newFilters: Partial<UserEventSearchForm> = pickBy(
      getValues(),
      (value) => value !== "" || (Array.isArray(value) && value.length > 0)
    );

    setActiveFilters(newFilters);
    setKey(key + 1);
  }

  const UserDetailLink = (event: EventRepresentation) => (
    <Link
      key={`link-${event.time}-${event.type}`}
      to={toUser({ realm, id: event.userId!, tab: "settings" })}
    >
      {event.userId}
    </Link>
  );

  return (
    <>
      <ViewHeader
        titleKey="events:title"
        subKey={
          <Trans i18nKey="events:eventExplain">
            If you want to configure user events, Admin events or Event
            listeners, please enter
            <Link to={toRealmSettings({ realm, tab: "events" })}>
              {t("eventConfig")}
            </Link>
            page realm settings to configure.
          </Trans>
        }
        divider={false}
      />
      <PageSection variant="light" className="pf-u-p-0">
        <KeycloakTabs isBox>
          <Tab
            eventKey="userEvents"
            title={<TabTitleText>{t("userEvents")}</TabTitleText>}
          >
            <Flex>
              <FlexItem>
                <Dropdown
                  id="user-events-search-select"
                  data-testid="UserEventsSearchSelector"
                  className="pf-u-mt-md pf-u-ml-md pf-u-mb-md"
                  toggle={
                    <DropdownToggle
                      data-testid="userEventsSearchSelectorToggle"
                      onToggle={(isOpen) => setSearchDropdownOpen(isOpen)}
                      className="keycloak__user_events_search_selector_dropdown__toggle"
                    >
                      {t("searchForEvent")}
                    </DropdownToggle>
                  }
                  isOpen={searchDropdownOpen}
                >
                  <Form
                    isHorizontal
                    className="keycloak__user_events_search__form"
                    data-testid="searchForm"
                  >
                    <FormGroup
                      label={t("userId")}
                      fieldId="kc-userId"
                      className="keycloak__user_events_search__form_label"
                    >
                      <TextInput
                        ref={register()}
                        type="text"
                        id="kc-userId"
                        name="user"
                        data-testid="userId-searchField"
                      />
                    </FormGroup>
                    <FormGroup
                      label={t("eventType")}
                      fieldId="kc-eventType"
                      className="keycloak__user_events_search__form_label"
                    >
                      <Controller
                        name="type"
                        control={control}
                        render={({
                          onChange,
                          value,
                        }: {
                          onChange: (newValue: EventType[]) => void;
                          value: EventType[];
                        }) => (
                          <Select
                            className="keycloak__user_events_search__event_type_select"
                            name="eventType"
                            data-testid="event-type-searchField"
                            chipGroupProps={{
                              numChips: 1,
                              expandedText: "Hide",
                              collapsedText: "Show ${remaining}",
                            }}
                            variant={SelectVariant.typeaheadMulti}
                            typeAheadAriaLabel="Select"
                            onToggle={(isOpen) => setSelectOpen(isOpen)}
                            selections={value}
                            onSelect={(_, selectedValue) => {
                              const option =
                                selectedValue.toString() as EventType;
                              const changedValue = value.includes(option)
                                ? value.filter((item) => item !== option)
                                : [...value, option];

                              onChange(changedValue);
                            }}
                            onClear={(event) => {
                              event.stopPropagation();
                              onChange([]);
                            }}
                            isOpen={selectOpen}
                            aria-labelledby={"eventType"}
                            chipGroupComponent={
                              <ChipGroup>
                                {value.map((chip) => (
                                  <Chip
                                    key={chip}
                                    onClick={(event) => {
                                      event.stopPropagation();

                                      onChange(
                                        value.filter((val) => val !== chip)
                                      );
                                    }}
                                  >
                                    {chip}
                                  </Chip>
                                ))}
                              </ChipGroup>
                            }
                          >
                            {events?.enabledEventTypes?.map((option) => (
                              <SelectOption key={option} value={option} />
                            ))}
                          </Select>
                        )}
                      />
                    </FormGroup>
                    <FormGroup
                      label={t("client")}
                      fieldId="kc-client"
                      className="keycloak__user_events_search__form_label"
                    >
                      <TextInput
                        ref={register()}
                        type="text"
                        id="kc-client"
                        name="client"
                        data-testid="client-searchField"
                      />
                    </FormGroup>
                    <FormGroup
                      label={t("dateFrom")}
                      fieldId="kc-dateFrom"
                      className="keycloak__user_events_search__form_label"
                    >
                      <TextInput
                        ref={register()}
                        type="text"
                        id="kc-dateFrom"
                        name="dateFrom"
                        className="pf-c-form-control pf-m-icon pf-m-calendar"
                        placeholder="yyyy-MM-dd"
                        data-testid="dateFrom-searchField"
                      />
                    </FormGroup>
                    <FormGroup
                      label={t("dateTo")}
                      fieldId="kc-dateTo"
                      className="keycloak__user_events_search__form_label"
                    >
                      <TextInput
                        ref={register()}
                        type="text"
                        id="kc-dateTo"
                        name="dateTo"
                        className="pf-c-form-control pf-m-icon pf-m-calendar"
                        placeholder="yyyy-MM-dd"
                        data-testid="dateTo-searchField"
                      />
                    </FormGroup>
                    <ActionGroup>
                      <Button
                        className="keycloak__user_events_search__form_btn"
                        variant={"primary"}
                        onClick={submitSearch}
                        data-testid="search-events-btn"
                        isDisabled={!isDirty}
                      >
                        {t("searchBtn")}
                      </Button>
                    </ActionGroup>
                  </Form>
                </Dropdown>
              </FlexItem>
            </Flex>
            {Object.entries(activeFilters).length > 0 && (
              <div className="keycloak__searchChips pf-u-ml-md">
                {Object.entries(activeFilters).map((filter) => {
                  const [key, value] = filter as [
                    keyof UserEventSearchForm,
                    string | EventType[]
                  ];

                  return (
                    <ChipGroup
                      className="pf-u-mr-md pf-u-mb-md"
                      key={key}
                      categoryName={filterLabels[key]}
                      isClosable
                      onClick={() => removeFilter(key)}
                    >
                      {typeof value === "string" ? (
                        <Chip isReadOnly>{value}</Chip>
                      ) : (
                        value.map((entry) => (
                          <Chip
                            key={entry}
                            onClick={() => removeFilterValue(key, entry)}
                          >
                            {entry}
                          </Chip>
                        ))
                      )}
                    </ChipGroup>
                  );
                })}
              </div>
            )}
            <div className="keycloak__events_table">
              <KeycloakDataTable
                key={key}
                loader={loader}
                detailColumns={[
                  {
                    name: "details",
                    enabled: (event) => event.details !== undefined,
                    cellRenderer: DetailCell,
                  },
                ]}
                isPaginated
                ariaLabelKey="events:title"
                columns={[
                  {
                    name: "time",
                    displayKey: "events:time",
                    cellRenderer: (row) => moment(row.time).format("LLL"),
                    cellFormatters: [expandable],
                  },
                  {
                    name: "userId",
                    displayKey: "events:user",
                    cellRenderer: UserDetailLink,
                  },
                  {
                    name: "type",
                    displayKey: "events:eventType",
                    cellRenderer: StatusRow,
                  },
                  {
                    name: "ipAddress",
                    displayKey: "events:ipAddress",
                    transforms: [cellWidth(10)],
                  },
                  {
                    name: "clientId",
                    displayKey: "events:client",
                  },
                ]}
                emptyState={
                  <div className="pf-u-mt-md">
                    <Divider className="keycloak__events_empty_state_divider" />
                    <ListEmptyState
                      message={t("emptyEvents")}
                      instructions={t("emptyEventsInstructions")}
                    />
                  </div>
                }
              />
            </div>
          </Tab>
          <Tab
            eventKey="adminEvents"
            title={<TabTitleText>{t("adminEvents")}</TabTitleText>}
          >
            <AdminEvents />
          </Tab>
        </KeycloakTabs>
      </PageSection>
    </>
  );
};