"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const types = require("../../../../utils/types.js");
const constants = require("../constants.js");
const Vue = require("vue");
const debounce = require("../../../../../../lodash-es/debounce.js");
const useRow = (props, { mainTableRef, leftTableRef, rightTableRef, tableInstance, ns, isScrolling }) => {
  const vm = Vue.getCurrentInstance();
  const { emit } = vm;
  const isResetting = Vue.shallowRef(false);
  const expandedRowKeys = Vue.ref(props.defaultExpandedRowKeys || []);
  const lastRenderedRowIndex = Vue.ref(-1);
  const resetIndex = Vue.shallowRef(null);
  const rowHeights = Vue.ref({});
  const pendingRowHeights = Vue.ref({});
  const leftTableHeights = Vue.shallowRef({});
  const mainTableHeights = Vue.shallowRef({});
  const rightTableHeights = Vue.shallowRef({});
  const isDynamic = Vue.computed(() => types.isNumber(props.estimatedRowHeight));
  function onRowsRendered(params) {
    var _a;
    (_a = props.onRowsRendered) == null ? void 0 : _a.call(props, params);
    if (params.rowCacheEnd > Vue.unref(lastRenderedRowIndex)) lastRenderedRowIndex.value = params.rowCacheEnd;
  }
  function onRowHovered({ hovered, rowKey }) {
    if (isScrolling.value) return;
    tableInstance.vnode.el.querySelectorAll(`[rowkey="${String(rowKey)}"]`).forEach((row) => {
      if (hovered) row.classList.add(ns.is("hovered"));
      else row.classList.remove(ns.is("hovered"));
    });
  }
  function onRowExpanded({ expanded, rowData, rowIndex, rowKey }) {
    var _a, _b;
    const _expandedRowKeys = [...Vue.unref(expandedRowKeys)];
    const currentKeyIndex = _expandedRowKeys.indexOf(rowKey);
    if (expanded) {
      if (currentKeyIndex === -1) _expandedRowKeys.push(rowKey);
    } else if (currentKeyIndex > -1) _expandedRowKeys.splice(currentKeyIndex, 1);
    expandedRowKeys.value = _expandedRowKeys;
    emit("update:expandedRowKeys", _expandedRowKeys);
    (_a = props.onRowExpand) == null ? void 0 : _a.call(props, {
      expanded,
      rowData,
      rowIndex,
      rowKey
    });
    (_b = props.onExpandedRowsChange) == null ? void 0 : _b.call(props, _expandedRowKeys);
    if (tableInstance.vnode.el.querySelector(`.${ns.is("hovered")}[rowkey="${String(rowKey)}"]`)) Vue.nextTick(() => onRowHovered({
      hovered: true,
      rowKey
    }));
  }
  const flushingRowHeights = debounce.default(() => {
    var _a, _b, _c, _d;
    isResetting.value = true;
    rowHeights.value = {
      ...Vue.unref(rowHeights),
      ...Vue.unref(pendingRowHeights)
    };
    resetAfterIndex(Vue.unref(resetIndex), false);
    pendingRowHeights.value = {};
    resetIndex.value = null;
    (_a = mainTableRef.value) == null ? void 0 : _a.forceUpdate();
    (_b = leftTableRef.value) == null ? void 0 : _b.forceUpdate();
    (_c = rightTableRef.value) == null ? void 0 : _c.forceUpdate();
    (_d = vm.proxy) == null ? void 0 : _d.$forceUpdate();
    isResetting.value = false;
  }, 0);
  function resetAfterIndex(index, forceUpdate = false) {
    if (!Vue.unref(isDynamic)) return;
    [
      mainTableRef,
      leftTableRef,
      rightTableRef
    ].forEach((tableRef) => {
      const table = Vue.unref(tableRef);
      if (table) table.resetAfterRowIndex(index, forceUpdate);
    });
  }
  function resetHeights(rowKey, height, rowIdx) {
    const resetIdx = Vue.unref(resetIndex);
    if (resetIdx === null) resetIndex.value = rowIdx;
    else if (resetIdx > rowIdx) resetIndex.value = rowIdx;
    pendingRowHeights.value[rowKey] = height;
  }
  function onRowHeightChange({ rowKey, height, rowIndex }, fixedDir) {
    if (!fixedDir) mainTableHeights.value[rowKey] = height;
    else if (fixedDir === constants.FixedDir.RIGHT) rightTableHeights.value[rowKey] = height;
    else leftTableHeights.value[rowKey] = height;
    const maximumHeight = Math.max(...[
      leftTableHeights,
      rightTableHeights,
      mainTableHeights
    ].map((records) => records.value[rowKey] || 0));
    if (Vue.unref(rowHeights)[rowKey] !== maximumHeight) {
      resetHeights(rowKey, maximumHeight, rowIndex);
      flushingRowHeights();
    }
  }
  return {
    expandedRowKeys,
    lastRenderedRowIndex,
    isDynamic,
    isResetting,
    rowHeights,
    resetAfterIndex,
    onRowExpanded,
    onRowHovered,
    onRowsRendered,
    onRowHeightChange
  };
};
exports.useRow = useRow;
