Duffer Derek

import { mapBlockToComponent } from './componentMapper';
import { v4 as uuidv4 } from 'uuid';

interface GridItem {
  contentKey: string;
  columnSpan: number;
  rowSpan: number;
  areas: Array<{
    key: string;
    items: GridItem[];
  }>;
}

// eslint-disable-next-line @typescript-eslint/no-explicit-any
export const mapUmbracoToComponentData = (umbracoData: any) => {
  const mainContent = umbracoData.values.find(
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    (item: any) => item.alias === "mainContent"
  )?.value;

  if (!mainContent?.layout?.["Umbraco.BlockGrid"]) {
    return {};
  }

  const pageId = umbracoData.id;
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
  const result:{ [key: string]: any } = {
    [pageId]: {
      layouts: [],
      components: {}
    }
  };

  // Find content data by key
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  const findContentData = (key: string) => mainContent.contentData.find((item: any) => item.key === key);

  // Process grid items recursively
  const processGridItem = (item: GridItem, parentId?: string) => {
    const contentData = findContentData(item.contentKey);
    if (!contentData) return null;

    // Check if this is a grid (based on contentTypeKey matching grid types)
    const isGrid = [
      '99740655-b76b-4d34-aaac-aace495a39b6', // DEFAULT
      'c996b4ec-1a0d-4a7c-b99d-466c2b153da4', // ONE_COLUMN
      'd6dbc5f5-510a-4020-be64-ef32b741be22', // TWO_COLUMN
      'bfe13a0c-ab38-4f4f-8720-dcf34f8475d1'  // THREE_COLUMN
    ].includes(contentData.contentTypeKey);

    if (isGrid) {
      // Generate a unique ID for this grid instance
      const gridInstanceId = `${contentData.contentTypeKey}-${uuidv4()}`;
      
      const grid = {
        id: gridInstanceId, // Use the unique instance ID
        documentId: contentData.contentTypeKey, // Keep the original content type key
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
        columns: [] as any[][],
        parentId
      };

      // Process areas as columns
      if (item.areas) {
        grid.columns = item.areas.map(area => {
          return area.items.map(subItem => {
            const subItemData = findContentData(subItem.contentKey);
            if (!subItemData) return null;

            // Check if subitem is a grid
            if ([
              '99740655-b76b-4d34-aaac-aace495a39b6',
              'c996b4ec-1a0d-4a7c-b99d-466c2b153da4',
              'd6dbc5f5-510a-4020-be64-ef32b741be22',
              'bfe13a0c-ab38-4f4f-8720-dcf34f8475d1'
            ].includes(subItemData.contentTypeKey)) {
              return processGridItem(subItem, gridInstanceId);
            } else {
              // This is a component
              const component = mapBlockToComponent(subItemData);
              if (component) {
                if (!result[pageId].components[gridInstanceId]) {
                  result[pageId].components[gridInstanceId] = [];
                }
                result[pageId].components[gridInstanceId].push(component);
                return component;
              }
            }
            return null;
          }).filter(Boolean);
        });
      }

      return grid;
    }

    // If not a grid, treat as component
    const component = mapBlockToComponent(contentData);
    if (component) {
      if (!result[pageId].components[parentId || 'root']) {
        result[pageId].components[parentId || 'root'] = [];
      }
      result[pageId].components[parentId || 'root'].push(component);
      return component;
    }

    return null;
  };

  // Process the root level grid items
  mainContent.layout["Umbraco.BlockGrid"].forEach((item: GridItem) => {
    const grid = processGridItem(item);
    if (grid) {
      result[pageId].layouts.push(grid);
    }
  });

  return result;
};