import { z } from 'zod';

export const directoryParserOutputConfigurationName = 'directory';
export const directoryParserOutputConfigurationSchema = z
  .object({
    type: z.literal(directoryParserOutputConfigurationName),
    directoryPath: z.string({
      invalid_type_error: 'directoryPath must be a string',
      required_error: 'directoryPath is mandatory',
    }),
  })
  .strict();

export const fileParserOutputConfigurationName = 'file';
export const fileParserOutputConfigurationSchema = z
  .object({
    type: z.literal(fileParserOutputConfigurationName),
    filePath: z.string({
      invalid_type_error: 'filePath must be a string',
      required_error: 'filePath is mandatory',
    }),
  })
  .strict();

export const jsonParserOutputConfigurationName = 'JSON';
export const jsonParserOutputConfigurationSchema = z
  .object({ type: z.literal(jsonParserOutputConfigurationName) })
  .strict();

export const sdtfParserOutputConfigurationName = 'SDTF';
export const sdtfParserOutputConfigurationSchema = z
  .object({ type: z.literal(sdtfParserOutputConfigurationName) })
  .strict();

export const textParserOutputConfigurationName = 'text';
export const textParserOutputConfigurationSchema = z
  .object({ type: z.literal(textParserOutputConfigurationName) })
  .strict();

/* ------------------------------------------
   Union and mapping
--------------------------------------------- */
export const parserOutputConfigurationSchema = z.discriminatedUnion(
  'type',
  [
    directoryParserOutputConfigurationSchema,
    fileParserOutputConfigurationSchema,
    jsonParserOutputConfigurationSchema,
    sdtfParserOutputConfigurationSchema,
    textParserOutputConfigurationSchema,
  ],
  {
    invalid_type_error:
      'Output must be an object with a type property being one of "directory", "file", "JSON", "SDTF" or "text"',
  },
);
const parserOutputConfigurationTypeToSchemaMap = {
  [directoryParserOutputConfigurationName]: directoryParserOutputConfigurationSchema,
  [fileParserOutputConfigurationName]: fileParserOutputConfigurationSchema,
  [jsonParserOutputConfigurationName]: jsonParserOutputConfigurationSchema,
  [sdtfParserOutputConfigurationName]: sdtfParserOutputConfigurationSchema,
  [textParserOutputConfigurationName]: textParserOutputConfigurationSchema,
} as const;

export function getParserOutputConfigurationUnionSchema(
  types: Array<ParserOutputConfigurationType>,
) {
  if (types.length === 0) throw new Error('At least one output type must be provided');
  if (types.length === 1) return parserOutputConfigurationTypeToSchemaMap[types[0]] as any;
  return z.union(types.map(type => parserOutputConfigurationTypeToSchemaMap[type]) as any) as any;
}

export type ParserOutputConfiguration = z.infer<typeof parserOutputConfigurationSchema>;
export type ParserOutputConfigurationType = ParserOutputConfiguration['type'];

export type PickParserOutputConfiguration<T extends ParserOutputConfigurationType> = Extract<
  ParserOutputConfiguration,
  { type: T }
>;

export type PickParserOutputConfigurationSchema<T extends ParserOutputConfigurationType> =
  typeof parserOutputConfigurationTypeToSchemaMap[T];