// contexts/WindowManagerContext.tsx

'use client';

import React, { createContext, useContext, useState, useEffect } from 'react';

type WindowProps = {
  width?: string;
  height?: string;
  initialState?: 'open' | 'closed' | 'minimized';
  gravity?: number; // New gravity property
};

type WindowData = {
  name: string;
  Component: React.ComponentType;
  windowProps: WindowProps;
};

type WindowState = {
  visible: boolean;
  minimized: boolean;
  maximized: boolean;
  width: number;
  height: number;
  x: number;
  y: number;
  zIndex: number;
  prevWidth?: number;
  prevHeight?: number;
  prevX?: number;
  prevY?: number;
};

type WindowManagerContextType = {
  windows: { [key: string]: WindowData };
  windowStates: { [key: string]: WindowState };
  openWindow: (name: string) => void;
  closeWindow: (name: string) => void;
  minimizeWindow: (name: string) => void;
  restoreWindow: (name: string) => void;
  maximizeWindow: (name: string) => void;
  updateWindowState: (name: string, newState: Partial<WindowState>) => void;
  bringToFront: (name: string) => void;
};

const WindowManagerContext = createContext<WindowManagerContextType | undefined>(undefined);

export const useWindowManager = () => {
  const context = useContext(WindowManagerContext);
  if (!context) {
    throw new Error('useWindowManager must be used within a WindowManagerProvider');
  }
  return context;
};

export const WindowManagerProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
  const [windows, setWindows] = useState<{ [key: string]: WindowData }>({});
  const [windowStates, setWindowStates] = useState<{ [key: string]: WindowState }>({});
  const [nextZIndex, setNextZIndex] = useState(1);

  // Define grid size constant
  const GRID_SIZE = 25;

  type WindowDataAndState = {
    windowData: WindowData;
    windowState: WindowState;
  };

  useEffect(() => {
    // Dynamically import window components
    const importWindows = async () => {
      const windowsContext = require.context('../windows', false, /\.tsx$/);
      const windowFiles = windowsContext.keys();

      let zIndexCounter = 1;

      const windowsDataPromises: Promise<WindowDataAndState>[] = windowFiles.map(
        async (file: string, index: number): Promise<WindowDataAndState> => {
          const mod = await windowsContext(file);
          const name = file.replace('./', '').replace('.tsx', '');
          const Component = mod.default;
          const windowProps = mod.windowProps || {};

          // Parse initial size
          let width = windowProps.width
            ? parseSize(windowProps.width, 'width')
            : 0.35 * window.innerWidth;
          let height = windowProps.height
            ? parseSize(windowProps.height, 'height')
            : 0.2 * window.innerHeight;

          // Adjust width and height to align with grid
          width = Math.round(width / GRID_SIZE) * GRID_SIZE;
          height = Math.round(height / GRID_SIZE) * GRID_SIZE;

          // Determine initial state
          const initialState = windowProps.initialState || 'open';
          let visible = true;
          let minimized = false;

          switch (initialState) {
            case 'open':
              visible = true;
              minimized = false;
              break;
            case 'closed':
              visible = false;
              minimized = false;
              break;
            case 'minimized':
              visible = false;
              minimized = true;
              break;
            default:
              visible = true;
              minimized = false;
              break;
          }

          // Adjust initial positions to align with grid
          const initialX = Math.round((100 + index * 50) / GRID_SIZE) * GRID_SIZE;
          const initialY = Math.round((100 + index * 50) / GRID_SIZE) * GRID_SIZE;

          const windowData: WindowData = { name, Component, windowProps };
          const windowState: WindowState = {
            visible,
            minimized,
            maximized: false,
            width,
            height,
            x: initialX,
            y: initialY,
            zIndex: zIndexCounter++,
          };

          return { windowData, windowState };
        }
      );

      const windowsDataArray: WindowDataAndState[] = await Promise.all(windowsDataPromises);

      const newWindows: { [key: string]: WindowData } = {};
      const newWindowStates: { [key: string]: WindowState } = {};

      windowsDataArray.forEach(({ windowData, windowState }) => {
        newWindows[windowData.name] = windowData;
        newWindowStates[windowData.name] = windowState;
      });

      setWindows(newWindows);
      setWindowStates(newWindowStates);
      setNextZIndex(zIndexCounter);
    };

    importWindows();
  }, []);

  const bringToFront = (name: string) => {
    setWindowStates((prev) => {
      const maxZ = nextZIndex;
      setNextZIndex(maxZ + 1);
      return {
        ...prev,
        [name]: {
          ...prev[name],
          zIndex: maxZ,
        },
      };
    });
  };

  const openWindow = (name: string) => {
    setWindowStates((prev) => ({
      ...prev,
      [name]: {
        ...prev[name],
        visible: true,
        minimized: false,
      },
    }));
    bringToFront(name);
  };

  const closeWindow = (name: string) => {
    setWindowStates((prev) => ({
      ...prev,
      [name]: {
        ...prev[name],
        visible: false,
        minimized: false,
      },
    }));
  };

  const minimizeWindow = (name: string) => {
    setWindowStates((prev) => ({
      ...prev,
      [name]: {
        ...prev[name],
        minimized: true,
        visible: false,
      },
    }));
  };

  const restoreWindow = (name: string) => {
    setWindowStates((prev) => ({
      ...prev,
      [name]: {
        ...prev[name],
        minimized: false,
        visible: true,
      },
    }));
    bringToFront(name);
  };

  const maximizeWindow = (name: string) => {
    setWindowStates((prev) => {
      const state = prev[name];
      const isMaximized = !state.maximized;

      if (isMaximized) {
        // Store previous size and position
        const prevSizePosition = {
          prevWidth: state.width,
          prevHeight: state.height,
          prevX: state.x,
          prevY: state.y,
        };

        const maxWidth = window.innerWidth - 20; // Adjusted width for spacing
        const maxHeight = window.innerHeight - 20; // Adjusted height for spacing

        // Adjust to align with grid
        const adjustedWidth = Math.floor(maxWidth / GRID_SIZE) * GRID_SIZE;
        const adjustedHeight = Math.floor(maxHeight / GRID_SIZE) * GRID_SIZE;

        return {
          ...prev,
          [name]: {
            ...state,
            maximized: true,
            ...prevSizePosition,
            x: 10, // Adjusted for spacing when maximized
            y: 10, // Adjusted for spacing when maximized
            width: adjustedWidth,
            height: adjustedHeight,
          },
        };
      } else {
        // Restore previous size and position
        return {
          ...prev,
          [name]: {
            ...state,
            maximized: false,
            width: state.prevWidth || state.width,
            height: state.prevHeight || state.height,
            x: state.prevX || state.x,
            y: state.prevY || state.y,
          },
        };
      }
    });
    bringToFront(name);
  };

  const updateWindowState = (
    name: string,
    newState: Partial<WindowState>,
    skipGrid = false
  ) => {
    setWindowStates((prev) => {
      let updatedState = {
        ...prev[name],
        ...newState,
      };
  
      if (!skipGrid) {
        // Ensure positions and sizes align with the grid
        updatedState.x = Math.round(updatedState.x / GRID_SIZE) * GRID_SIZE;
        updatedState.y = Math.round(updatedState.y / GRID_SIZE) * GRID_SIZE;
        updatedState.width = Math.round(updatedState.width / GRID_SIZE) * GRID_SIZE;
        updatedState.height = Math.round(updatedState.height / GRID_SIZE) * GRID_SIZE;
      }
  
      return {
        ...prev,
        [name]: updatedState,
      };
    });
  };

  function parseSize(size: string, dimension: 'width' | 'height'): number {
    if (typeof window === 'undefined') return 400;
    if (size.endsWith('%')) {
      const percentage = parseFloat(size) / 100;
      if (dimension === 'width') {
        return percentage * window.innerWidth;
      } else {
        return percentage * window.innerHeight;
      }
    } else if (size.endsWith('px')) {
      return parseFloat(size);
    } else {
      return dimension === 'width' ? 400 : 300;
    }
  }

  return (
    <WindowManagerContext.Provider
      value={{
        windows,
        windowStates,
        openWindow,
        closeWindow,
        minimizeWindow,
        restoreWindow,
        maximizeWindow,
        updateWindowState,
        bringToFront,
      }}
    >
      {children}
    </WindowManagerContext.Provider>
  );
};

TASK: Make it so that there are some new props for window of intialX and intialY which is the starting posiont and where teh window will be rendered at can either be px or % values.