import { PALETTE_STEPS, type PaletteCategory } from '../palette';

export type CatalogInputStrategy<TInputId extends string = string> =
  | {
      readonly kind: 'palette';
      readonly category: PaletteCategory;
      readonly fallback?: {
        readonly inputId: TInputId;
        readonly transform: 'derive-base-color';
      };
    }
  | {
      readonly kind: 'display-font';
    };

export type CatalogRecipeStrategy<TTokenPath extends string = string> =
  | {
      readonly kind: 'scale-family';
      readonly anchorPath: TTokenPath;
    }
  | {
      readonly kind: 'replace-anchor';
      readonly anchorPath: TTokenPath;
    }
  | {
      readonly kind: 'stepped-anchor';
      readonly anchorPath: TTokenPath;
      readonly interactionPaths: readonly TTokenPath[];
      readonly lightDirection: 1 | -1;
      readonly darkDirection: 1 | -1;
    }
  | {
      readonly kind: 'invariant-reference';
      readonly anchorPath: TTokenPath;
    };

type SourceSetFilter =
  | {
      readonly kind: 'numeric-color';
    }
  | {
      readonly kind: 'curated-color';
    }
  | {
      readonly kind: 'status-color';
      readonly families: readonly string[];
    }
  | {
      readonly kind: 'path-prefix';
      readonly prefix: string;
    };

interface AuthoredInputDefinitionBase {
  readonly id: string;
  readonly priority: number;
  readonly managedTargets: readonly string[];
}

type AuthoredInputDefinition =
  | (AuthoredInputDefinitionBase & {
      readonly valueType: 'color-seed';
      readonly executionPhase: 'primitive';
      readonly strategy: Extract<CatalogInputStrategy, { readonly kind: 'palette' }>;
    })
  | (AuthoredInputDefinitionBase & {
      readonly valueType: 'font-family';
      readonly executionPhase: 'resolved';
      readonly strategy: Extract<CatalogInputStrategy, { readonly kind: 'display-font' }>;
    });

interface AuthoredSourceSetDefinition {
  readonly id: string;
  readonly filter: SourceSetFilter;
  readonly excludesInputSeeds: boolean;
}

interface AuthoredSelectionDefinitionBase {
  readonly id: string;
  readonly sourceSetId: string;
  readonly priority: number;
}

interface AuthoredRecipeDefinition<TStrategy extends CatalogRecipeStrategy> {
  readonly id: string;
  readonly managedTargets: readonly string[];
  readonly strategy: TStrategy;
}

type AuthoredSelectionDefinition =
  | (AuthoredSelectionDefinitionBase & {
      readonly valueShape: 'linked-reference';
      readonly modePolicy: 'mode-capable';
      readonly recipe: AuthoredRecipeDefinition<
        Exclude<CatalogRecipeStrategy, { readonly kind: 'invariant-reference' }>
      >;
    })
  | (AuthoredSelectionDefinitionBase & {
      readonly valueShape: 'invariant-reference';
      readonly modePolicy: 'invariant';
      readonly recipe: AuthoredRecipeDefinition<
        Extract<CatalogRecipeStrategy, { readonly kind: 'invariant-reference' }>
      >;
    });

export interface OverrideCatalogDefinitionAuthoring {
  readonly inputs: readonly AuthoredInputDefinition[];
  readonly sourceSets: readonly AuthoredSourceSetDefinition[];
  readonly selections: readonly AuthoredSelectionDefinition[];
}

const PALETTE_INPUT_TARGET_STEP = 'input';

export function paletteTargets(category: PaletteCategory): readonly string[] {
  const targets = PALETTE_STEPS.map((step) => `color.${category}.${step}`);
  return category === 'base'
    ? targets
    : [...targets, `color.${category}.${PALETTE_INPUT_TARGET_STEP}`];
}

export const displayFontTargets = [
  'font.display',
  'font.display-medium',
  'font.display-semibold',
  'font.display-bold',
  'font.display-italic',
  'font.display-medium-italic',
  'font.display-semibold-italic',
  'font.display-bold-italic',
] as const;

export function statusTargets(
  status: 'danger' | 'success' | 'warning' | 'info',
): readonly string[] {
  return [
    `color.surface.${status}.strong`,
    `color.surface.${status}.strong-hover`,
    `color.surface.${status}.strong-active`,
    `color.surface.${status}.subtle`,
    `color.surface.${status}.subtle-hover`,
    `color.surface.${status}.subtle-active`,
    `color.surface.${status}.tint`,
    `color.surface.${status}.tint-hover`,
    `color.surface.${status}.tint-active`,
    `color.content.${status}`,
    `color.content.${status}-on-strong`,
    `color.content.${status}-on-subtle`,
    `color.stroke.${status}`,
  ];
}