import { TOAST_TYPE, setToast } from "@buzzwaretech/propel/toast";
import type {
    ISearchIssueResponse,
    TIssue,
    TIssueServiceType,
    TWorkItemWidgets,
} from "@buzzwaretech/types";
import { observer } from "mobx-react";
// components
import { ExistingIssuesListModal } from "@/components/core/modals/existing-issues-list-modal";
// hooks
import { useIssueDetail } from "@/hooks/store/use-issue-detail";
// buzzwareTech web imports
import { WorkItemAdditionalWidgetModals } from "@/buzzwareTech-web/components/issues/issue-detail-widgets/modals";
// local imports
import { IssueLinkCreateUpdateModal } from "../issue-detail/links/create-update-link-modal";
// helpers
import { CreateUpdateIssueModal } from "../issue-modal/modal";
import { useLinkOperations } from "./links/helper";
import { useSubIssueOperations } from "./sub-issues/helper";

type Props = {
  workspaceSlug: string;
  projectId: string;
  issueId: string;
  issueServiceType: TIssueServiceType;
  hideWidgets?: TWorkItemWidgets[];
};

export const IssueDetailWidgetModals = observer(
  function IssueDetailWidgetModals(props: Props) {
    const { workspaceSlug, projectId, issueId, issueServiceType, hideWidgets } =
      props;
    // store hooks
    const {
      isIssueLinkModalOpen,
      toggleIssueLinkModal: toggleIssueLinkModalStore,
      setIssueLinkData,
      isCreateIssueModalOpen,
      toggleCreateIssueModal,
      isSubIssuesModalOpen,
      toggleSubIssuesModal,
      relationKey,
      isRelationModalOpen,
      setRelationKey,
      setLastWidgetAction,
      toggleRelationModal,
      createRelation,
      issueCrudOperationState,
      setIssueCrudOperationState,
    } = useIssueDetail(issueServiceType);

    // helper hooks
    const subIssueOperations = useSubIssueOperations(issueServiceType);
    const handleLinkOperations = useLinkOperations(
      workspaceSlug,
      projectId,
      issueId,
      issueServiceType,
    );

    // handlers
    const handleIssueCrudState = (
      key: "create" | "existing",
      _parentIssueId: string | null,
      issue: TIssue | null = null,
    ) => {
      setIssueCrudOperationState({
        ...issueCrudOperationState,
        [key]: {
          toggle: !issueCrudOperationState[key].toggle,
          parentIssueId: _parentIssueId,
          issue: issue,
        },
      });
    };

    const handleExistingIssuesModalClose = () => {
      handleIssueCrudState("existing", null, null);
      setLastWidgetAction("sub-work-items");
      toggleSubIssuesModal(null);
    };

    const handleExistingIssuesModalOnSubmit = async (
      _issue: ISearchIssueResponse[],
    ) =>
      subIssueOperations.addSubIssue(
        workspaceSlug,
        projectId,
        issueId,
        _issue.map((issue) => issue.id),
      );

    const handleCreateUpdateModalClose = () => {
      handleIssueCrudState("create", null, null);
      toggleCreateIssueModal(false);
      setLastWidgetAction("sub-work-items");
    };

    const handleCreateUpdateModalOnSubmit = async (_issue: TIssue) => {
      if (_issue.parent_id) {
        await subIssueOperations.addSubIssue(
          workspaceSlug,
          projectId,
          _issue.parent_id,
          [_issue.id],
        );
      }
    };

    const handleIssueLinkModalOnClose = () => {
      toggleIssueLinkModalStore(false);
      setLastWidgetAction("links");
      setIssueLinkData(null);
    };

    const handleRelationOnClose = () => {
      setRelationKey(null);
      toggleRelationModal(null, null);
      setLastWidgetAction("relations");
    };

    const handleExistingIssueModalOnSubmit = async (
      data: ISearchIssueResponse[],
    ) => {
      if (!relationKey) return;
      if (data.length === 0) {
        setToast({
          type: TOAST_TYPE.ERROR,
          title: "Error!",
          message: "Please select at least one work item.",
        });
        return;
      }

      await createRelation(
        workspaceSlug,
        projectId,
        issueId,
        relationKey,
        data.map((i) => i.id),
      );

      toggleRelationModal(null, null);
    };

    // helpers
    const createUpdateModalData: Partial<TIssue> = {
      parent_id: issueCrudOperationState?.create?.parentIssueId,
      project_id: projectId,
    };

    const existingIssuesModalSearchParams = {
      sub_issue: true,
      issue_id: issueCrudOperationState?.existing?.parentIssueId,
    };

    // render conditions
    const shouldRenderExistingIssuesModal =
      !hideWidgets?.includes("sub-work-items") &&
      issueCrudOperationState?.existing?.toggle &&
      issueCrudOperationState?.existing?.parentIssueId &&
      isSubIssuesModalOpen;

    const shouldRenderCreateUpdateModal =
      !hideWidgets?.includes("sub-work-items") &&
      issueCrudOperationState?.create?.toggle &&
      issueCrudOperationState?.create?.parentIssueId &&
      isCreateIssueModalOpen;

    return (
      <>
        {!hideWidgets?.includes("links") && (
          <IssueLinkCreateUpdateModal
            isModalOpen={isIssueLinkModalOpen}
            handleOnClose={handleIssueLinkModalOnClose}
            linkOperations={handleLinkOperations}
            issueServiceType={issueServiceType}
          />
        )}

        {shouldRenderCreateUpdateModal && (
          <CreateUpdateIssueModal
            isOpen={issueCrudOperationState?.create?.toggle}
            data={createUpdateModalData}
            onClose={handleCreateUpdateModalClose}
            onSubmit={handleCreateUpdateModalOnSubmit}
            isProjectSelectionDisabled
          />
        )}

        {shouldRenderExistingIssuesModal && (
          <ExistingIssuesListModal
            workspaceSlug={workspaceSlug}
            projectId={projectId}
            isOpen={issueCrudOperationState?.existing?.toggle}
            handleClose={handleExistingIssuesModalClose}
            searchParams={existingIssuesModalSearchParams}
            handleOnSubmit={handleExistingIssuesModalOnSubmit}
          />
        )}

        {!hideWidgets?.includes("relations") && (
          <ExistingIssuesListModal
            workspaceSlug={workspaceSlug}
            projectId={projectId}
            isOpen={
              isRelationModalOpen?.issueId === issueId &&
              isRelationModalOpen?.relationType === relationKey
            }
            handleClose={handleRelationOnClose}
            searchParams={{ issue_relation: true, issue_id: issueId }}
            handleOnSubmit={handleExistingIssueModalOnSubmit}
            workspaceLevelToggle
          />
        )}

        <WorkItemAdditionalWidgetModals
          hideWidgets={hideWidgets ?? []}
          issueServiceType={issueServiceType}
          projectId={projectId}
          workItemId={issueId}
          workspaceSlug={workspaceSlug}
        />
      </>
    );
  },
);