import { z } from 'zod';

export const mcpSnapshotSchemaVersionSchema = z.literal(1);

export const mcpSourceTypeSchema = z.enum([
  'fragments-json',
  'cloud',
  'auto-extract',
  'custom-json',
  'bundle',
]);

export const mcpCapabilitySchema = z.enum([
  'components',
  'tokens',
  'blocks',
  'graph',
  'performance',
]);

export const mcpPerformanceImportSchema = z.object({
  path: z.string().min(1),
  bytes: z.number().nonnegative(),
  percent: z.number().nonnegative(),
});

export const mcpPerformanceDataSchema = z.object({
  bundleSize: z.number().nonnegative(),
  rawSize: z.number().nonnegative(),
  complexity: z.enum(['lightweight', 'moderate', 'heavy']),
  budgetPercent: z.number().nonnegative(),
  overBudget: z.boolean(),
  measuredAt: z.string().datetime(),
  imports: z.array(mcpPerformanceImportSchema).optional(),
});

export const mcpPerformanceSummarySchema = z.object({
  preset: z.string().min(1),
  budget: z.number().nonnegative(),
  total: z.number().int().nonnegative(),
  overBudget: z.number().int().nonnegative(),
  tiers: z.record(
    z.enum(['lightweight', 'moderate', 'heavy']),
    z.number().int().nonnegative(),
  ),
});

export const mcpComponentPropSchema = z.object({
  type: z.string().min(1),
  description: z.string().default(''),
  required: z.boolean().default(false),
  default: z.unknown().optional(),
  values: z.array(z.string()).optional(),
  constraints: z.array(z.string()).optional(),
});

export const mcpComponentExampleSchema = z.object({
  name: z.string().min(1),
  description: z.string().optional(),
  code: z.string().optional(),
  kind: z.string().optional(),
});

export const mcpComponentRelationSchema = z.object({
  componentName: z.string().min(1),
  componentId: z.string().optional(),
  relationship: z.string().min(1),
  note: z.string().optional(),
  description: z.string().optional(),
});

export const mcpCompoundChildSchema = z.object({
  name: z.string().min(1),
  componentId: z.string().optional(),
  description: z.string().optional(),
  required: z.boolean().optional(),
  accepts: z.array(z.string()).optional(),
  visibility: z.enum(['public', 'internal']).optional(),
});

export const mcpGuidancePatternSchema = z.object({
  name: z.string().min(1),
  description: z.string().optional(),
});

export const mcpComponentGuidanceSchema = z.object({
  when: z.array(z.string()).default([]),
  whenNot: z.array(z.string()).default([]),
  guidelines: z.array(z.string()).default([]),
  accessibility: z.array(z.string()).default([]),
  usageGuidance: z.string().optional(),
  dos: z.array(z.string()).default([]),
  donts: z.array(z.string()).default([]),
  patterns: z.array(mcpGuidancePatternSchema).default([]),
});

export const mcpComponentMetadataSchema = z.object({
  a11yRules: z.array(z.string()).default([]),
  scenarioTags: z.array(z.string()).default([]),
});

export const mcpComponentSchema = z.object({
  id: z.string().min(1),
  name: z.string().min(1),
  description: z.string().default(''),
  category: z.string().default('uncategorized'),
  status: z.string().default('stable'),
  tags: z.array(z.string()).default([]),
  props: z.record(z.string(), mcpComponentPropSchema).default({}),
  propsSummary: z.array(z.string()).default([]),
  examples: z.array(mcpComponentExampleSchema).default([]),
  relations: z.array(mcpComponentRelationSchema).default([]),
  compoundChildren: z.array(mcpCompoundChildSchema).default([]),
  guidance: mcpComponentGuidanceSchema.default({
    when: [],
    whenNot: [],
    guidelines: [],
    accessibility: [],
    dos: [],
    donts: [],
    patterns: [],
  }),
  sourceType: mcpSourceTypeSchema,
  sourcePath: z.string().optional(),
  sourceRepoFullName: z.string().optional(),
  packageName: z.string().optional(),
  importPath: z.string().optional(),
  publicRef: z.string().optional(),
  publicSlug: z.string().nullable().optional(),
  isCanonical: z.boolean().optional(),
  tier: z.string().optional(),
  parentComponentId: z.string().optional(),
  parentComponentName: z.string().optional(),
  performance: mcpPerformanceDataSchema.optional(),
  metadata: mcpComponentMetadataSchema.default({
    a11yRules: [],
    scenarioTags: [],
  }),
});

export const mcpBlockSchema = z.object({
  id: z.string().min(1),
  name: z.string().min(1),
  description: z.string().default(''),
  category: z.string().default('uncategorized'),
  components: z.array(z.string()).default([]),
  tags: z.array(z.string()).default([]),
  code: z.string().default(''),
});

export const mcpTokenSchema = z.object({
  name: z.string().min(1),
  category: z.string().min(1),
  value: z.string().optional(),
  description: z.string().optional(),
  path: z.array(z.string()).optional(),
  type: z.string().optional(),
});

export const mcpTokenDataSchema = z.object({
  prefix: z.string(),
  total: z.number().int().nonnegative(),
  categories: z.record(z.string(), z.array(mcpTokenSchema)),
  flat: z.array(mcpTokenSchema).default([]),
});

export const mcpSnapshotMetadataSchema = z.object({
  designSystemName: z.string().optional(),
  packageName: z.string().optional(),
  importPath: z.string().optional(),
  revision: z.string().optional(),
  updatedAt: z.string().optional(),
});

export const mcpSnapshotSchema = z.object({
  schemaVersion: mcpSnapshotSchemaVersionSchema,
  sourceType: mcpSourceTypeSchema,
  sourceLabel: z.string().min(1),
  capabilities: z.array(mcpCapabilitySchema),
  metadata: mcpSnapshotMetadataSchema.default({}),
  components: z.record(z.string(), mcpComponentSchema),
  blocks: z.record(z.string(), mcpBlockSchema).optional(),
  tokens: mcpTokenDataSchema.optional(),
  graph: z.unknown().optional(),
  performanceSummary: mcpPerformanceSummarySchema.optional(),
  packageMap: z.record(z.string(), z.string()).default({}),
  defaultPackageName: z.string().optional(),
});

export type McpSnapshotSchemaVersion = z.infer<
  typeof mcpSnapshotSchemaVersionSchema
>;
export type McpSourceType = z.infer<typeof mcpSourceTypeSchema>;
export type McpCapability = z.infer<typeof mcpCapabilitySchema>;
export type McpPerformanceImport = z.infer<
  typeof mcpPerformanceImportSchema
>;
export type McpPerformanceData = z.infer<typeof mcpPerformanceDataSchema>;
export type McpPerformanceSummary = z.infer<
  typeof mcpPerformanceSummarySchema
>;
export type McpComponentProp = z.infer<typeof mcpComponentPropSchema>;
export type McpComponentExample = z.infer<typeof mcpComponentExampleSchema>;
export type McpComponentRelation = z.infer<
  typeof mcpComponentRelationSchema
>;
export type McpCompoundChild = z.infer<typeof mcpCompoundChildSchema>;
export type McpGuidancePattern = z.infer<typeof mcpGuidancePatternSchema>;
export type McpComponentGuidance = z.infer<
  typeof mcpComponentGuidanceSchema
>;
export type McpComponentMetadata = z.infer<
  typeof mcpComponentMetadataSchema
>;
export type McpComponent = z.infer<typeof mcpComponentSchema>;
export type McpBlock = z.infer<typeof mcpBlockSchema>;
export type McpToken = z.infer<typeof mcpTokenSchema>;
export type McpTokenData = z.infer<typeof mcpTokenDataSchema>;
export type McpSnapshotMetadata = z.infer<
  typeof mcpSnapshotMetadataSchema
>;
export type McpSnapshot = z.infer<typeof mcpSnapshotSchema>;