import { z, objectUtil } from 'zod';

import {
  getParsersEngineDataBoxUnionSchema,
  type ParsersEngineDataBoxType,
  type PickParsersEngineDataBoxSchema,
} from '../../parsersEngine/definitions/parsersEngineDataBox.js';
import type { ParserFunction } from '../../parsersEngine/definitions/ParserFunction.js';
import {
  type CommonBuiltInParserOptionsSchema,
  commonBuiltInParserOptionsSchema,
  optionalCommonBuiltInParserOptionsSchema,
  type OptionalCommonBuiltInParserOptionsSchema,
} from './commonBuiltInParserOptions.js';
import {
  getParserOutputConfigurationUnionSchema,
  type ParserOutputConfigurationType,
  type PickParserOutputConfigurationSchema,
} from './parserOutputConfiguration.js';
import type { BuiltInParserFunction } from './BuiltInParserFunction.js';

/* v8 ignore start */

export type BuiltInParserDefinitionSignature<
  Name extends string,
  Kind extends 'utility' | 'generation',
  HasOptionalOptions extends boolean,
  OptionsSchema extends z.ZodObject<z.ZodRawShape, 'strict'> | undefined,
  HasOptionalOutput extends boolean,
  OutputTypes extends Array<ParserOutputConfigurationType> | undefined,
  InTypes extends Array<ParsersEngineDataBoxType>,
  OutType extends ParsersEngineDataBoxType,
> = {
  name: Name;
  nameSchema: z.ZodLiteral<Name>;
  kind: Kind;
  hasOptionalOptions: HasOptionalOptions;
  optionsSchema: OptionsSchema extends undefined
    ? OptionalCommonBuiltInParserOptionsSchema
    : HasOptionalOptions extends true
      ? z.ZodOptional<
          z.ZodObject<
            objectUtil.extendShape<
              NonNullable<OptionsSchema>['shape'],
              CommonBuiltInParserOptionsSchema['shape']
            >,
            'strict'
          >
        >
      : z.ZodObject<
          objectUtil.extendShape<
            NonNullable<OptionsSchema>['shape'],
            CommonBuiltInParserOptionsSchema['shape']
          >,
          'strict'
        >;
  hasOptionalOutput: HasOptionalOutput;
  outputTypes: OutputTypes extends [] ? undefined : OutputTypes;
  outputSchema: OutputTypes extends undefined
    ? z.ZodOptional<z.ZodUndefined>
    : OutputTypes extends []
      ? z.ZodOptional<z.ZodUndefined>
      : OutputTypes extends Array<infer A extends ParserOutputConfigurationType>
        ? HasOptionalOutput extends true
          ? z.ZodOptional<z.ZodUnion<Readonly<[PickParserOutputConfigurationSchema<A>]>>>
          : z.ZodUnion<Readonly<[PickParserOutputConfigurationSchema<A>]>>
        : never;
  inTypes: InTypes;
  inSchema: InTypes extends []
    ? never
    : InTypes extends Array<infer A extends ParsersEngineDataBoxType>
      ? z.ZodUnion<Readonly<[PickParsersEngineDataBoxSchema<A>]>>
      : never;
  outType: OutType;
  outSchema: PickParsersEngineDataBoxSchema<OutType>;
  parserConfigurationSchema: z.ZodObject<
    {
      name: z.ZodLiteral<Name>;
      options: OptionsSchema extends undefined
        ? OptionalCommonBuiltInParserOptionsSchema
        : HasOptionalOptions extends true
          ? z.ZodOptional<
              z.ZodObject<
                objectUtil.extendShape<
                  NonNullable<OptionsSchema>['shape'],
                  CommonBuiltInParserOptionsSchema['shape']
                >,
                'strict'
              >
            >
          : z.ZodObject<
              objectUtil.extendShape<
                NonNullable<OptionsSchema>['shape'],
                CommonBuiltInParserOptionsSchema['shape']
              >,
              'strict'
            >;
      output: OutputTypes extends undefined
        ? z.ZodOptional<z.ZodUndefined>
        : OutputTypes extends []
          ? z.ZodOptional<z.ZodUndefined>
          : OutputTypes extends Array<infer A extends ParserOutputConfigurationType>
            ? HasOptionalOutput extends true
              ? z.ZodOptional<z.ZodUnion<Readonly<[PickParserOutputConfigurationSchema<A>]>>>
              : z.ZodUnion<Readonly<[PickParserOutputConfigurationSchema<A>]>>
            : never;
    },
    'strict'
  >;
};

export function createBuiltInParserDefinition<
  Name extends string,
  Kind extends 'generation' | 'utility',
  HasOptionalOptions extends boolean,
  OptionsSchema extends z.ZodObject<z.ZodRawShape, 'strict'> | undefined,
  HasOptionalOutput extends boolean,
  OutputTypes extends
    | [ParserOutputConfigurationType, ...Array<ParserOutputConfigurationType>]
    | undefined,
  InTypes extends Array<ParsersEngineDataBoxType>,
  OutType extends ParsersEngineDataBoxType,
>(params: {
  name: Name;
  kind: Kind;
  hasOptionalOptions: HasOptionalOptions;
  optionsSchema: OptionsSchema;
  hasOptionalOutput: HasOptionalOutput;
  outputTypes: OutputTypes;
  inTypes: InTypes;
  outType: OutType;
}): BuiltInParserDefinitionSignature<
  Name,
  Kind,
  HasOptionalOptions,
  OptionsSchema,
  HasOptionalOutput,
  OutputTypes,
  InTypes,
  OutType
> {
  const nameSchema = z.literal(params.name);
  const optionsSchema = params.optionsSchema
    ? params.hasOptionalOptions
      ? params.optionsSchema.merge(commonBuiltInParserOptionsSchema).optional()
      : params.optionsSchema.merge(commonBuiltInParserOptionsSchema)
    : optionalCommonBuiltInParserOptionsSchema;
  const outputTypes =
    params.outputTypes && params.outputTypes.length === 0 ? undefined : params.outputTypes;
  const outputSchema =
    outputTypes === undefined
      ? z.undefined().optional()
      : params.hasOptionalOutput
        ? getParserOutputConfigurationUnionSchema(outputTypes).optional()
        : getParserOutputConfigurationUnionSchema(outputTypes);

  return {
    name: params.name,
    nameSchema,
    kind: params.kind,
    hasOptionalOptions: params.hasOptionalOptions,
    optionsSchema: optionsSchema as any,
    hasOptionalOutput: params.hasOptionalOutput,
    outputTypes: outputTypes as any,
    outputSchema,
    inTypes: params.inTypes,
    inSchema: getParsersEngineDataBoxUnionSchema(params.inTypes),
    outType: params.outType,
    outSchema: getParsersEngineDataBoxUnionSchema([params.outType]),
    parserConfigurationSchema: z
      .object({
        name: nameSchema,
        options: optionsSchema,
        output: outputSchema,
      })
      .strict() as any,
  } as any;
}

export type DeriveMakeParserFunctionFromDefinition<
  Def extends BuiltInParserDefinitionSignature<any, any, any, any, any, any, any, any>,
> = (
  params: Def['hasOptionalOptions'] extends true
    ? Def['hasOptionalOutput'] extends true
      ? {
          options?: z.infer<Def['optionsSchema']>;
          output?: z.infer<Def['outputSchema']>;
        }
      : {
          options?: z.infer<Def['optionsSchema']>;
          output: z.infer<Def['outputSchema']>;
        }
    : Def['hasOptionalOutput'] extends true
      ? {
          options: z.infer<Def['optionsSchema']>;
          output?: z.infer<Def['outputSchema']>;
        }
      : {
          options: z.infer<Def['optionsSchema']>;
          output: z.infer<Def['outputSchema']>;
        },
) => ParserFunction<z.infer<Def['inSchema']>, z.infer<Def['outSchema']>>;

export type DeriveBuiltInParserHandlerFromDefinition<
  Def extends BuiltInParserDefinitionSignature<any, any, any, any, any, any, any, any>,
> = BuiltInParserFunction<
  z.infer<Def['optionsSchema']>,
  z.infer<Def['outputSchema']>,
  z.infer<Def['inSchema']>,
  z.infer<Def['outSchema']>
>;

export type DeriveParserOptionsFromDefinition<
  Def extends BuiltInParserDefinitionSignature<any, any, any, any, any, any, any, any>,
> = z.infer<Def['optionsSchema']>;

/* v8 ignore stop */