import { FC, useState } from "react";
import { IAction, Table } from "venice-ui";
import { useStoreActions, useStoreState } from "../../store";
import { IDemoOrganizations } from "../../store/interface/demo";
import { dictionary } from "../../untils/dictionary";
import { t } from "../../helpers/userHelper";
import { apiCall } from "../../untils/apiCall";
import {
  AssingUserToDemoOrganizationModal,
  DeleteOrganiaztionModal,
  FinishTestsModal,
  InfoModal,
} from "../Modals";

export const DemoOrganizations: FC = () => {
  const organizations = useStoreState((state) => state.demo.organizations);
  const { uid } = useStoreState((state) => state.user.userDetails);
  const removeInvitationFromDemoOrganization = useStoreActions(
    (actions) => actions.demo.removeInvitationFromDemoOrganization,
  );
  const [infoBox, setInfoBox] = useState({
    isOpen: false ,
    content: "",
  });
  const [organizationToAssign, setOrganizationToAssign] =
    useState<IDemoOrganizations | null>(null);
  const [organizationToFinish, setOrganizationToFinish] = useState<{
    orgID?: string;
    userID?: string;
  } | null>(null);
  const [organizationToRemove, setOrganizationToRemove] =
    useState<IDemoOrganizations | null>(null);

  const tableOrganizations = organizations.map((organization) => ({
    ...organization,
    id: organization.id || organization.orgID,
    orgName:
      (organization as typeof organization & { orgName?: string }).orgName ||
      organization.orgID,
    demoUserName:
      (organization as typeof organization & { demoUserName?: string })
        .demoUserName || organization.demoUsers,
    invitationDate:
      organization.invitationDate === 0 || organization.invitationDate === null
        ? undefined
        : organization.invitationDate,
  }));

  const getOrganization = (id?: string): IDemoOrganizations | undefined =>
    organizations.find(
      (organization) => (organization.id || organization.orgID) === id,
    );

  const removeOrganization = (id?: string) => {
    const organization = getOrganization(id);
    if (organization) {
      setOrganizationToRemove(organization);
    }
  };

  const assignUser = (id?: string) => {
    const organization = getOrganization(id);
    if (organization) {
      setOrganizationToAssign(organization);
    }
  };

  const finishTests = (id?: string) => {
    const organization = getOrganization(id);
    if (
      organization &&
      (organization.status === "busy" ||
        organization.status === "pending" ||
        organization.demoUsers)
    ) {
      setOrganizationToFinish({
        orgID: organization.orgID,
        userID: organization.demoUsers,
      });
    } else {
      setInfoBox({
        isOpen: true,
        content: t(dictionary.organizationNoTests),
      });
    }
  };

  const removeInvitation = async (id?: string) => {
    const organization = getOrganization(id);
    const isPending =
      typeof organization?.status === "string" &&
      organization.status.trim().toLowerCase() === "pending";

    if (!isPending) {
      setInfoBox({
        isOpen: true,
        content: t(dictionary.organizationNoInvitation),
      });
      return;
    }

    const userID = organization.demoUsers;

    if (!uid || !organization.orgID || !userID) {
      setInfoBox({
        isOpen: true,
        content: t(dictionary.organizationNoInvitation),
      });
      return;
    }

    try {
      await apiCall(
        "demoManagment/removeInvitationFromDemoOrganization",
        {
          uid,
          orgID: organization.orgID,
          userID,
        },
        () => {
          removeInvitationFromDemoOrganization({
            orgID: organization.orgID,
            userID,
          });
        },
      );
    } catch (error) {
      setInfoBox({
        isOpen: true,
        content: t(dictionary.organizationNoInvitation),
      });
    }
  };


  const moreActions: IAction[] = [
    
    {
      label: t(dictionary.assignDemoUserAction),
      action: assignUser,
    },
    {
      label: t(dictionary.removeInvitationAction),
      action: removeInvitation,
    },
     {
      label: t(dictionary.finishTestAction),
      action: finishTests,
    },
    {
      label: t(dictionary.removeOrganizationAction),
      action: removeOrganization,
    },
  ];

  const headers = [
    { name: t(dictionary.name), valueSource: "orgName", filterType: "text" as const },
    { name: t(dictionary.status), valueSource: "status", filterType: "select" as const },
    {
      name: t(dictionary.user),
      valueSource: "demoUserName",
      filterType: "text" as const,
    },
    {
      name: t(dictionary.createdDate),
      valueSource: "createdDate",
      date: true,
      filterType: "date" as const,
    },
    {
      name: t(dictionary.invitationDate),
      valueSource: "invitationDate",
      date: true,
      filterType: "date" as const,
    },
  ];

  return (
    <>
      <Table
        headers={headers}
        elements={tableOrganizations}
        pagination
        pageSize={10}
        searchable
        sortable
        filtrable
        selectable={false}
        moreActions={moreActions}
        filterLabels={{
          title: t(dictionary.filters),
          close: t(dictionary.close),
          confirm: t(dictionary.confirm),
          trigger: t(dictionary.filters),
          clearAll: t(dictionary.resetFilters),
          clear: t(dictionary.clear),
        }}
        emptyStateText={t(dictionary.noDemoOrganizations)}
      />
      {organizationToRemove && (
        <DeleteOrganiaztionModal
          isOpen={organizationToRemove !== null}
          organization={organizationToRemove}
          onClose={() => setOrganizationToRemove(null)}
        />
      )}
      {organizationToAssign && (
        <AssingUserToDemoOrganizationModal
          isOpen={organizationToAssign !== null}
          onClose={() => setOrganizationToAssign(null)}
          organization={organizationToAssign}
        />
      )}
      {infoBox.isOpen && (
        <InfoModal
          isOpen={infoBox.isOpen}
          onClose={() => setInfoBox({ isOpen: false, content: "" })}
          content={infoBox.content}
        />
      )}
      {organizationToFinish && (
        <FinishTestsModal
          isOpen={organizationToFinish !== null}
          onClose={() => setOrganizationToFinish(null)}
          orgID={organizationToFinish.orgID}
          userID={organizationToFinish.userID}
          label={organizationToFinish?.orgID || organizationToFinish?.userID}
        />
      )}
    </>
  );
};