export const convertAbsoluteBoundsToRelative = weakMemo((newBounds: Bounds, element: SyntheticElement, window: SyntheticWindow) => {
  const { left, top } = getElementStartPosition(element, window);
  const oldBounds = window.allComputedBounds[element.$id];
  return moveBounds(newBounds, {
    left: newBounds.left - left,
    top: newBounds.top - top
  });
});

const getBestWindowBounds = (browser: SyntheticBrowser, bounds: Bounds) => {
  if (!browser.windows.length) return bounds;
  const rightMostWindow = browser.windows.length > 1 ? browser.windows.reduce((a, b) => {
    return a.bounds.right > b.bounds.right ? a : b;
  }) : browser.windows[0];

  return moveBounds(bounds, {
    left: rightMostWindow.bounds.right + WINDOW_PADDING,
    top: rightMostWindow.bounds.top
  });
};

const stageReducer = (state: ApplicationState, event: BaseEvent) => {

  switch(event.type) {
    case VISUAL_EDITOR_WHEEL: {
      const { workspaceId, metaKey, ctrlKey, deltaX, deltaY, canvasHeight, canvasWidth } = event as StageWheel;
      const workspace = getWorkspaceById(state, workspaceId);

      if (workspace.stage.fullScreen) {
        return state;
      }
      
      let translate = getStageTranslate(workspace.stage);

      if (metaKey || ctrlKey) {
        translate = centerTransformZoom(translate, boundsFromRect({
          width: canvasWidth,
          height: canvasHeight
        }), clamp(translate.zoom + translate.zoom * deltaY / ZOOM_SENSITIVITY, MIN_ZOOM, MAX_ZOOM), workspace.stage.mousePosition);
      } else {
        translate = {
          ...translate,
          left: translate.left - deltaX,
          top: translate.top - deltaY
        };
      }

      return updateWorkspaceStage(state, workspace.$id, { smooth: false, translate });
    }

    case TOGGLE_TOOLS_SHORTCUT_PRESSED: {
      const workspace = getSelectedWorkspace(state);
      return updateWorkspaceStage(state, workspace.$id, {
        showTools: workspace.stage.showTools == null ? false : !workspace.stage.showTools
      })
    }

    case STAGE_TOOL_EDIT_TEXT_KEY_DOWN: {
      const { sourceEvent, nodeId } = event as StageToolEditTextKeyDown;
      if (sourceEvent.key === "Escape") {
        // const workspace = getSyntheticNodeWorkspace(state, nodeId);
        // state = setWorkspaceSelection(state, workspace.$id, getStructReference(getNestedObjectById(nodeId, getNodeArtboard(nodeId, state).document)));
        // state = updateWorkspaceStage(state, workspace.$id, {
        //   secondarySelection: false
        // });
      }
      return state;
    }

    case RESIZER_MOVED: {
      const { point, workspaceId, point: newPoint } = event as ResizerMoved;
      const workspace = getSelectedWorkspace(state);
      state = updateWorkspaceStage(state, workspace.$id, {
        movingOrResizing: true
      });

      const translate = getStageTranslate(workspace.stage);

      const selectionBounds = getWorkspaceSelectionBounds(workspace);
      for (const item of getBoundedWorkspaceSelection(workspace)) {
        const itemBounds = getWorkspaceItemBounds(item, workspace);

        // skip moving window if in full screen mode
        if (workspace.stage.fullScreen && workspace.stage.fullScreen.artboardId === item.$id) {
          break;
        }

        const newBounds = roundBounds(scaleInnerBounds(itemBounds, selectionBounds, moveBounds(selectionBounds, newPoint)));

        if (item.$type === ARTBOARD) {
          state = updateArtboard(state, item.$id, { bounds: newBounds });
        }
      }

      return state;

    }

    case RESIZER_PATH_MOUSE_MOVED: {
      let { workspaceId, anchor, originalBounds, newBounds, sourceEvent } = event as ResizerPathMoved;

      const workspace = getSelectedWorkspace(state);
      state = updateWorkspaceStage(state, workspace.$id, {
        movingOrResizing: true
      });

      // TODO - possibly use BoundsStruct instead of Bounds since there are cases where bounds prop doesn't exist
      const currentBounds = getWorkspaceSelectionBounds(workspace);


      const keepAspectRatio = sourceEvent.shiftKey;
      const keepCenter      = sourceEvent.altKey;

      if (keepCenter) {
        // newBounds = keepBoundsCenter(newBounds, bounds, anchor);
      }

      if (keepAspectRatio) {
        newBounds = keepBoundsAspectRatio(newBounds, originalBounds, anchor, keepCenter ? { left: 0.5, top: 0.5 } : anchor);
      }

//.........这里部分代码省略.........

export const syntheticBrowserReducer = <TRootState extends SyntheticBrowserRootState>(root: TRootState = createSyntheticBrowserRootState() as TRootState, event: BaseEvent): TRootState => {

  switch(event.type) {
    case SYNTHETIC_WINDOW_PROXY_OPENED: {
      const { instance, parentWindowId } = event as SyntheticWindowOpened;
      let syntheticBrowser: SyntheticBrowser;
      syntheticBrowser = getSyntheticBrowser(root, instance.browserId);
      if (!syntheticBrowser) {
        console.warn(`Unable to find synthetic browser with ID ${instance.browserId}. It's likely that the app state was replaced.`);
        return root;
      }
      return upsertSyntheticWindow(root, syntheticBrowser.$id, instance.struct);
    }
    
    case SYNTHETIC_WINDOW_SCROLLED: {
      const { scrollPosition, syntheticWindowId } = event as SyntheticWindowScrolled;
      return updateSyntheticWindow(root, syntheticWindowId, {
        scrollPosition,
      });
    }

    case FETCHED_CONTENT: {
      const { publicPath, content, mtime } = event as FetchedContent;
      return setFileCacheItem(publicPath, content, new Date(0), root);
    }

    case SYNTHETIC_WINDOW_RESIZED: 
    case SYNTHETIC_WINDOW_MOVED: {
      const { instance: { $id, screenLeft, screenTop, innerWidth, innerHeight } } = event as SyntheticWindowChanged;
      return updateSyntheticWindow(root, $id, {
        bounds: {
          left: screenLeft,
          top: screenTop,
          right: screenLeft + innerWidth,
          bottom: screenTop + innerHeight,
        }
      });
    }

    case SYNTHETIC_WINDOW_CLOSED: {
      const { instance: { $id } } = event as SyntheticWindowChanged;
      return removeSyntheticWindow(root, $id);
    }

    case MOVED: {
      const { itemId, itemType, point } = event as Moved;
      if (itemType === SYNTHETIC_WINDOW) {
        const window = getSyntheticWindow(root, itemId);
        if (window) {
          return updateSyntheticWindow(root, itemId, {
            bounds: moveBounds(window.bounds, point)
          });
        }
        break;
      }
      break;
    }

    case REMOVED: {
      const { itemId, itemType } = event as Removed;
      if (itemType === SYNTHETIC_WINDOW) {
        return removeSyntheticWindow(root, itemId);
      }

      break;
    }

    case SYNTHETIC_WINDOW_LOADED:
    case SYNTHETIC_WINDOW_CHANGED: {
      const { instance } = event as SyntheticWindowLoaded;
      return updateSyntheticWindow(root, instance.$id, instance.struct);
    }

    case SYNTHETIC_WINDOW_RECTS_UPDATED: {
      const { rects, styles, syntheticWindowId } = event as SyntheticWindowRectsUpdated;
      return updateSyntheticWindow(root, syntheticWindowId, {
        allComputedBounds: rects,
        allComputedStyles: styles
      });
    }

    case SYNTHETIC_WINDOW_RESOURCE_LOADED: {
      const { uri, syntheticWindowId } = event as SyntheticWindowResourceLoaded;
      const window = getSyntheticWindow(root, syntheticWindowId);
      return updateSyntheticWindow(root, syntheticWindowId, {
        externalResourceUris: uniq(window.externalResourceUris, uri)
      });
    }
  }

  return root;
}