import type { MuiSemanticMapping } from '../override/contracts';

function colorMapping(
  tokenPath: string,
  optionPath: string,
  cssVariable: string,
): MuiSemanticMapping {
  return {
    tokenPath,
    optionPath,
    cssVariable,
    channelCssVariable: `${cssVariable}Channel`,
  };
}

function paletteFamily(
  muiFamily: string,
  forgeFamily: string,
  darkSurface = 'strong-active',
): readonly MuiSemanticMapping[] {
  return [
    colorMapping(
      `color.surface.${forgeFamily}.strong`,
      `palette.${muiFamily}.main`,
      `--mui-palette-${muiFamily}-main`,
    ),
    colorMapping(
      `color.surface.${forgeFamily}.subtle`,
      `palette.${muiFamily}.light`,
      `--mui-palette-${muiFamily}-light`,
    ),
    colorMapping(
      `color.surface.${forgeFamily}.${darkSurface}`,
      `palette.${muiFamily}.dark`,
      `--mui-palette-${muiFamily}-dark`,
    ),
    colorMapping(
      `color.content.${forgeFamily}-on-strong`,
      `palette.${muiFamily}.contrastText`,
      `--mui-palette-${muiFamily}-contrastText`,
    ),
  ];
}

export const MUI_SEMANTIC_MAPPINGS = [
  ...paletteFamily('primary', 'action'),
  ...paletteFamily('secondary', 'accent', 'core'),
  ...paletteFamily('error', 'danger'),
  ...paletteFamily('warning', 'warning'),
  ...paletteFamily('success', 'success'),
  ...paletteFamily('info', 'info'),
  colorMapping('color.content.primary', 'palette.text.primary', '--mui-palette-text-primary'),
  colorMapping('color.content.secondary', 'palette.text.secondary', '--mui-palette-text-secondary'),
  colorMapping('color.content.tertiary', 'palette.text.disabled', '--mui-palette-text-disabled'),
  colorMapping(
    'color.surface.background',
    'palette.background.default',
    '--mui-palette-background-default',
  ),
  colorMapping(
    'color.surface.primary',
    'palette.background.paper',
    '--mui-palette-background-paper',
  ),
  colorMapping('color.stroke.secondary', 'palette.divider', '--mui-palette-divider'),
  colorMapping('color.content.secondary', 'palette.action.active', '--mui-palette-action-active'),
  colorMapping(
    'color.content.tertiary',
    'palette.action.disabled',
    '--mui-palette-action-disabled',
  ),
  colorMapping('color.stroke.focus', 'palette.action.focus', '--mui-palette-action-focus'),
  {
    tokenPath: 'opacity.hover',
    optionPath: 'palette.action.hoverOpacity',
    cssVariable: '--mui-palette-action-hoverOpacity',
  },
  {
    tokenPath: 'opacity.selected',
    optionPath: 'palette.action.selectedOpacity',
    cssVariable: '--mui-palette-action-selectedOpacity',
  },
  {
    tokenPath: 'opacity.disabled',
    optionPath: 'palette.action.disabledOpacity',
    cssVariable: '--mui-palette-action-disabledOpacity',
  },
  {
    tokenPath: 'opacity.focus',
    optionPath: 'palette.action.focusOpacity',
    cssVariable: '--mui-palette-action-focusOpacity',
  },
  {
    tokenPath: 'font.display',
    optionPath: 'typography.fontFamily',
    cssVariable: '--mui-typography-fontFamily',
  },
  {
    tokenPath: 'border-radius.default',
    optionPath: 'shape.borderRadius',
    cssVariable: '--mui-shape-borderRadius',
  },
] as const satisfies readonly MuiSemanticMapping[];

function cdsSubtleFamily(
  muiFamily: string,
  forgeFamily: string,
  hoverSurface = 'subtle-hover',
): readonly MuiSemanticMapping[] {
  return [
    colorMapping(
      `color.surface.${forgeFamily}.subtle`,
      `palette.${muiFamily}.subtle`,
      `--cds-palette-${muiFamily}-subtle`,
    ),
    colorMapping(
      `color.surface.${forgeFamily}.${hoverSurface}`,
      `palette.${muiFamily}.subtleHover`,
      `--cds-palette-${muiFamily}-subtleHover`,
    ),
    colorMapping(
      `color.content.${forgeFamily}-on-subtle`,
      `palette.${muiFamily}.subtleContrast`,
      `--cds-palette-${muiFamily}-subtleContrast`,
    ),
  ];
}

export const CDS_SEMANTIC_MAPPINGS = [
  ...cdsSubtleFamily('primary', 'action'),
  ...cdsSubtleFamily('secondary', 'accent', 'subtle'),
  ...cdsSubtleFamily('error', 'danger'),
  ...cdsSubtleFamily('warning', 'warning'),
  ...cdsSubtleFamily('success', 'success'),
  ...cdsSubtleFamily('info', 'info'),
  colorMapping('color.white', 'palette.text.inverse', '--cds-palette-text-inverse'),
  colorMapping(
    'color.stroke.primary',
    'palette.interactiveBorder',
    '--cds-palette-interactiveBorder',
  ),
] as const satisfies readonly MuiSemanticMapping[];

const CDS_CORE_SEMANTIC_MAPPINGS = MUI_SEMANTIC_MAPPINGS.map((mapping: MuiSemanticMapping) => ({
  ...mapping,
  cssVariable: mapping.cssVariable.replace(/^--mui-/, '--cds-'),
  ...(mapping.channelCssVariable
    ? {
        channelCssVariable: mapping.channelCssVariable.replace(/^--mui-/, '--cds-'),
      }
    : {}),
}));

export const CDS_BRIDGE_MAPPINGS = [
  ...CDS_CORE_SEMANTIC_MAPPINGS,
  ...CDS_SEMANTIC_MAPPINGS,
] satisfies readonly MuiSemanticMapping[];