var _excluded = ["name", "tags", "product"];
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
import { useState, useEffect } from 'react';
import { useSelector, useDispatch } from 'react-redux';
import { Rename } from '@scaleflex/icons';
import { Spinner } from '@filerobot/common';
import handlePromise from '@filerobot/utils/lib/handlePromise';
import { PERMISSIONS } from '@filerobot/utils/lib/constants';
import validateItemMetadata from '@filerobot/utils/lib/metadata/validateItemMetadata';
import { selectIsUserAuth } from '@filerobot/core/lib/slices/user.slice';
import { updateUploadInfoMetaTags } from '@filerobot/core/lib/slices/uploads.slice';
import isUploadableFile from '@filerobot/utils/lib/isUploadableFile';
import { useExplorer, useValidateFileRenaming } from '../../../../hooks';
import GeneralSection from './GeneralSection';
import CustomMetadataSection from './CustomMetadataSection';
import EmbeddedMetadataSection from './EmbeddedMetadataSection';
import StyledDetailsTab from './DetailsTab.styled';
import ProductSection from './ProductSection';
import { itemMetadataErrorsUpdated, selectIsM0LegacyMeta, selectMetadata, selectMetadataModel } from '../../../../slices/metadata.slice';
import { fileWindowUpdated, selectFileWindow } from '../../../../slices/panels.slice';
import { renameFile, updateFileMeta, updateFileProduct, updateFileTags } from '../../../../slices/files.slice';
import { jsx as _jsx } from "react/jsx-runtime";
import { jsxs as _jsxs } from "react/jsx-runtime";
var DetailsTab = function DetailsTab(_ref) {
  var _file$info;
  var originalFile = _ref.originalFile,
    file = _ref.previewedFile,
    setIsTabsHidden = _ref.setIsTabsHidden,
    i18n = _ref.i18n,
    alertUnsavedChangesFirst = _ref.alertUnsavedChangesFirst,
    hasUnsavedChangesRef = _ref.hasUnsavedChangesRef;
  var dispatch = useDispatch();
  var _useExplorer = useExplorer(),
    info = _useExplorer.info,
    checkUserPermissions = _useExplorer.checkUserPermissions,
    _useExplorer$opts = _useExplorer.opts,
    showFileProduct = _useExplorer$opts.showFileProduct,
    viewerMode = _useExplorer$opts.viewerMode;
  var fileMeta = (file === null || file === void 0 ? void 0 : file.meta) || {};
  var metadataModel = useSelector(selectMetadataModel);
  var isM0LegacyMeta = useSelector(selectIsM0LegacyMeta);
  var metadata = useSelector(selectMetadata);
  var isEditing = useSelector(function (state) {
    return selectFileWindow(state).enableEdit;
  });
  var isUserAuth = useSelector(selectIsUserAuth);
  var handleItemRenamingValidation = useValidateFileRenaming(true);
  var _useState = useState(true),
    _useState2 = _slicedToArray(_useState, 2),
    isDetailsOpened = _useState2[0],
    setIsDetailsOpened = _useState2[1];
  var _useState3 = useState(true),
    _useState4 = _slicedToArray(_useState3, 2),
    isProductOpened = _useState4[0],
    setIsProductOpened = _useState4[1];
  var _useState5 = useState(true),
    _useState6 = _slicedToArray(_useState5, 2),
    isCustomMetadataOpened = _useState6[0],
    setIsCustomMetadataOpened = _useState6[1];
  var _useState7 = useState(false),
    _useState8 = _slicedToArray(_useState7, 2),
    isEmbeddedMetadataOpened = _useState8[0],
    setIsEmbeddedMetadataOpened = _useState8[1];
  var _useState9 = useState(false),
    _useState10 = _slicedToArray(_useState9, 2),
    ignoreChangedNameExtension = _useState10[0],
    setIgnoreChangedNameExtension = _useState10[1];
  var _useState11 = useState(fileMeta),
    _useState12 = _slicedToArray(_useState11, 2),
    editedDetails = _useState12[0],
    setEditedDetails = _useState12[1];
  var _useState13 = useState(false),
    _useState14 = _slicedToArray(_useState13, 2),
    isSaving = _useState14[0],
    setIsSaving = _useState14[1];
  var _useState15 = useState({}),
    _useState16 = _slicedToArray(_useState15, 2),
    metaErrors = _useState16[0],
    setMetaErrors = _useState16[1];
  var isPreUpload = isUploadableFile(file);
  useEffect(function () {
    if (isPreUpload) {
      // TODO: Do we really need to dispatch the item metadata errors or not?
      // Need to check, it was inside the validateItemMetadata function so I have moved it outside the functin.
      var _validateItemMetadata = validateItemMetadata({
          metadata: metadata,
          itemMeta: fileMeta,
          i18n: i18n,
          fileName: file === null || file === void 0 ? void 0 : file.name
        }),
        errors = _validateItemMetadata.errors;
      dispatch(itemMetadataErrorsUpdated(errors));
      setMetaErrors(errors || {});
      dispatch(fileWindowUpdated({
        enableEdit: true
      }));
      setIsCustomMetadataOpened(true);
    }
  }, [isPreUpload, file]);

  // reser errors on pressing cancel
  useEffect(function () {
    if (!isEditing) setMetaErrors({});
  }, [isEditing]);
  useEffect(function () {
    if (JSON.stringify(fileMeta) !== JSON.stringify(editedDetails)) {
      setEditedDetails(fileMeta);
    }
  }, [fileMeta]);
  var toggleDetails = function toggleDetails() {
    // Avoid closing the accordion while enabling edit mode for avoiding user changes and once closing the accordion his changes will be dismissed.
    if (isEditing && isDetailsOpened) {
      return;
    }
    setIsDetailsOpened(function (_isOpened) {
      return !_isOpened;
    });
  };
  var toggleProduct = function toggleProduct() {
    if (isEditing && isProductOpened) {
      return;
    }
    setIsProductOpened(function (_isOpened) {
      return !_isOpened;
    });
  };
  var toggleCustomFields = function toggleCustomFields() {
    if (isEditing && isCustomMetadataOpened) {
      return;
    }
    setIsCustomMetadataOpened(function (_isOpened) {
      return !_isOpened;
    });
  };
  var toggleMetadata = function toggleMetadata() {
    setIsEmbeddedMetadataOpened(function (_isOpened) {
      return !_isOpened;
    });
  };
  var enableEditing = function enableEditing() {
    // Don't enable editing for the versioned file previewed.
    if (originalFile.uuid !== file.uuid) {
      return;
    }
    var _validateItemMetadata2 = validateItemMetadata({
        metadata: metadata,
        itemMeta: fileMeta,
        i18n: i18n,
        fileName: file === null || file === void 0 ? void 0 : file.name
      }),
      errors = _validateItemMetadata2.errors;
    dispatch(itemMetadataErrorsUpdated(errors));
    setMetaErrors(errors || {});
    setEditedDetails(fileMeta);
    dispatch(fileWindowUpdated({
      enableEdit: true
    }));
    setIsTabsHidden(true);
  };
  var cancelEditing = function cancelEditing() {
    if (isSaving) {
      return;
    }
    var triggerCancellation = function triggerCancellation() {
      setEditedDetails(fileMeta);
      setIsTabsHidden(false);
      dispatch(fileWindowUpdated({
        enableEdit: false
      }));
    };
    alertUnsavedChangesFirst(triggerCancellation);
  };
  var renderNoValue = function renderNoValue() {
    return /*#__PURE__*/_jsx(StyledDetailsTab.NoValueWrapper, {
      children: "\u2014"
    });
  };
  var updateEditedDetails = function updateEditedDetails(objValue) {
    setEditedDetails(function (_editedDetails) {
      return _objectSpread(_objectSpread({}, _editedDetails), objValue);
    });
    hasUnsavedChangesRef.current = true;
    var _validateItemMetadata3 = validateItemMetadata({
        metadata: metadata,
        itemMeta: _objectSpread(_objectSpread({}, editedDetails), objValue),
        i18n: i18n,
        fileName: file === null || file === void 0 ? void 0 : file.name
      }),
      errors = _validateItemMetadata3.errors;
    dispatch(itemMetadataErrorsUpdated(errors));
    setMetaErrors(errors || {});
  };
  var handleSavingOneFile = function handleSavingOneFile(name) {
    setIsSaving(true);
    handlePromise(dispatch(renameFile({
      uuid: file.uuid,
      name: name || file.name
    })), function () {
      hasUnsavedChangesRef.current = false;
      setEditedDetails(fileMeta);
      dispatch(fileWindowUpdated({
        enableEdit: false
      }));
      setIsTabsHidden(false);
    }, info, function () {
      setIsSaving(false);
    });
  };
  var toggleFileWindow = function toggleFileWindow() {
    var fileUuidOrId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
    dispatch(fileWindowUpdated(fileUuidOrId));
  };
  var saveEditedDetails = function saveEditedDetails() {
    if (isSaving || originalFile.uuid !== file.uuid) {
      return;
    }
    var name = editedDetails.name,
      tags = editedDetails.tags,
      product = editedDetails.product,
      meta = _objectWithoutProperties(editedDetails, _excluded);
    var _validateItemMetadata4 = validateItemMetadata({
        metadata: metadata,
        itemMeta: _objectSpread(_objectSpread({}, fileMeta), meta),
        i18n: i18n,
        fileName: name
      }),
      isMetaValid = _validateItemMetadata4.isValid,
      metadataErrors = _validateItemMetadata4.errors;
    dispatch(itemMetadataErrorsUpdated(metadataErrors));
    setMetaErrors(metadataErrors || {});
    if (!isMetaValid) return;
    if (isPreUpload) {
      var newMeta = _objectSpread(_objectSpread({}, fileMeta), meta || {});
      var newName = name || (file === null || file === void 0 ? void 0 : file.name) || (file === null || file === void 0 ? void 0 : file.info.name);
      var triggerFileUpdate = function triggerFileUpdate() {
        return dispatch(updateUploadInfoMetaTags({
          filesIds: [file.id],
          meta: newMeta,
          info: {
            name: newName
          }
        }));
      };
      if (newName) {
        setIgnoreChangedNameExtension(false);
        var renameValidation = handleItemRenamingValidation(file.name, newName || file.name, {
          ignoreChangedNameExtension: ignoreChangedNameExtension,
          onChangeExtension: function onChangeExtension(handleCancellation) {
            setEditedDetails(fileMeta);
            triggerFileUpdate();
            toggleFileWindow();
            setIgnoreChangedNameExtension(true);
            handleCancellation();
          },
          onKeepOldExtension: function onKeepOldExtension(_, handleCancellation) {
            handleCancellation();
          }
        });
        if (!renameValidation.valid) return;
      }
      setEditedDetails(fileMeta);
      triggerFileUpdate();
      toggleFileWindow();
      return;
    }
    if (Object.keys(editedDetails).length === 0) {
      dispatch(fileWindowUpdated({
        enableEdit: false
      }));
      setIsTabsHidden(false);
      return;
    }
    // TODO: replace the 4 requests with 1 request once backend supports this.
    var requestsPromises = [];
    if (showFileProduct && product && Object.keys(product).length > 0) {
      requestsPromises.push(handlePromise(dispatch(updateFileProduct({
        uuid: file.uuid,
        product: product
      })), function (_ref2) {
        var product = _ref2.product;
        return {
          product: product
        };
      }));
    }
    if (tags) {
      var existingTags = [];
      var newTags = [];
      var tagLanguage = Object.keys(tags)[0];
      tags[tagLanguage].forEach(function (tag) {
        if (_typeof(tag) === 'object' && tag.sid && tag.label) {
          existingTags.push(tag.sid);
        } else {
          newTags.push(tag);
        }
      });
      requestsPromises.push(handlePromise(dispatch(updateFileTags({
        uuid: file.uuid,
        languageKey: tagLanguage,
        existingTags: existingTags,
        newTags: newTags
      })), function (_ref3) {
        var tags = _ref3.tags;
        return {
          tags: tags
        };
      }));
    }
    if (name) {
      setIgnoreChangedNameExtension(false);
      var _renameValidation = handleItemRenamingValidation(file.name, name || file.name, {
        ignoreChangedNameExtension: ignoreChangedNameExtension,
        onChangeExtension: function onChangeExtension(handleCancellation) {
          setIsSaving(true);
          handleSavingOneFile(name);
          handleCancellation();
        },
        onKeepOldExtension: function onKeepOldExtension(newNameWithOldExt, handleCancellation) {
          handleCancellation();
        }
      });
      if (!_renameValidation.valid) {
        return;
      }
      requestsPromises.push(handlePromise(dispatch(renameFile({
        uuid: file.uuid,
        name: name
      })), function (_ref4) {
        var name = _ref4.name;
        return {
          name: name
        };
      }));
    }
    if (metadataModel && meta && Object.keys(meta).length > 0) {
      requestsPromises.push(handlePromise(dispatch(updateFileMeta({
        uuid: file.uuid,
        meta: meta
      })), function (_ref5) {
        var meta = _ref5.meta;
        return {
          meta: meta
        };
      }));
    }
    // We set isSaving by true before handling all promises
    setIsSaving(true);
    handlePromise(Promise.all(requestsPromises), function () {
      hasUnsavedChangesRef.current = false;
      setEditedDetails(fileMeta);
      dispatch(fileWindowUpdated({
        enableEdit: false
      }));
      setIsTabsHidden(false);
    }, info, function () {
      setIsSaving(false);
    });
  };
  var tabSections = [{
    i18nStr: 'tabSectionGeneralLabel',
    component: GeneralSection,
    isOpened: isDetailsOpened,
    toggleFn: toggleDetails
  }, {
    i18nStr: 'tabSectionProductLabel',
    component: ProductSection,
    isOpened: isProductOpened,
    toggleFn: toggleProduct,
    hide: !showFileProduct
  }, {
    i18nStr: 'tabSectionCustomMetadataLabel',
    component: CustomMetadataSection,
    isOpened: isCustomMetadataOpened,
    toggleFn: toggleCustomFields,
    hide: !metadataModel || isM0LegacyMeta
  }, {
    i18nStr: 'tabSectionEmbeddedMetadataLabel',
    component: EmbeddedMetadataSection,
    isOpened: isEmbeddedMetadataOpened,
    toggleFn: toggleMetadata,
    hide: Object.keys(((_file$info = file.info) === null || _file$info === void 0 ? void 0 : _file$info.metadata) || {}).length === 0 || isM0LegacyMeta
  }];
  return /*#__PURE__*/_jsxs(StyledDetailsTab.Wrapper, {
    children: [(isUserAuth || checkUserPermissions([PERMISSIONS.UPLOAD, PERMISSIONS.FILE_META])) && !viewerMode && !isEditing && originalFile.uuid === file.uuid && /*#__PURE__*/_jsx(StyledDetailsTab.EditBtn, {
      color: "basic",
      size: "sm",
      onClick: enableEditing,
      children: /*#__PURE__*/_jsx(Rename, {
        size: 16
      })
    }), /*#__PURE__*/_jsx(StyledDetailsTab.TabSections, {
      isEditing: isEditing,
      children: tabSections.map(function (section) {
        return !section.hide && /*#__PURE__*/_jsx(StyledDetailsTab.SectionAccordion, {
          expanded: section.isOpened || isEditing,
          label: i18n(section.i18nStr),
          onChange: section.toggleFn,
          children: /*#__PURE__*/_jsx(section.component, {
            i18n: i18n,
            checkUserPermissions: checkUserPermissions,
            file: file,
            isEditing: isEditing,
            formRef: section.formRef,
            editedDetails: editedDetails,
            updateEditedDetails: updateEditedDetails,
            metaErrors: metaErrors,
            setMetaErrors: setMetaErrors,
            renderNoValue: renderNoValue
          })
        }, section.i18nStr);
      })
    }), isEditing && /*#__PURE__*/_jsxs(StyledDetailsTab.ActionsBtns, {
      children: [/*#__PURE__*/_jsx(StyledDetailsTab.ActionBtn, {
        size: "sm",
        color: "basic",
        onClick: cancelEditing,
        disabled: isSaving,
        children: i18n('mutualizedCancelButtonLabel')
      }), /*#__PURE__*/_jsx(StyledDetailsTab.ActionBtn, {
        size: "sm",
        color: "primary",
        onClick: saveEditedDetails,
        disabled: isSaving,
        children: isSaving ? /*#__PURE__*/_jsx(Spinner, {}) : i18n('mutualizedSaveButton')
      })]
    })]
  });
};
export default DetailsTab;