import { z } from 'zod';

/* v8 ignore start */

export const sdkTelemetryEventContextSchema = z
  .object({
    personalAccessToken: z.string().optional(),
    userId: z.string().optional(),
    organizationId: z.string().optional(),
    repositoryId: z.string().optional(),
    userEmail: z.string().optional(),
    organizationNamespace: z.string().optional(),
    sdkVersion: z.string().optional(),
  })
  .strict();
export type SDKTelemetryEventContext = z.infer<typeof sdkTelemetryEventContextSchema>;

function makeSDKTelemetryEvent<
  NameSchema extends string,
  PayloadSchema extends z.ZodObject<z.ZodRawShape, 'strict'>,
>(name: NameSchema, payload: PayloadSchema) {
  return z
    .object({
      name: z.literal(name),
      payload,
      context: sdkTelemetryEventContextSchema,
      at: z.number(),
    })
    .strict();
}

export const userLoggedInEventSchema = makeSDKTelemetryEvent(
  'SDK User Logged In',
  z.object({}).strict(),
);
export type UserLoggedInEvent = z.infer<typeof userLoggedInEventSchema>;

export const userFetchedRepositoryEventSchema = makeSDKTelemetryEvent(
  'SDK User Fetched Repository',
  z
    .object({
      repositoryName: z.string(),
    })
    .strict(),
);
export type UserFetchedRepositoryEvent = z.infer<typeof userFetchedRepositoryEventSchema>;

export const parsersEngineExecutedEventSchema = makeSDKTelemetryEvent(
  'Parsers Engine Executed',
  z
    .object({
      isRemote: z.boolean(),
      pipelines: z.array(
        z
          .object({
            pipelineName: z.string(),
            isFromRule: z.boolean(),
            status: z.union([z.literal('success'), z.literal('error')]),
            errorMessages: z.array(
              z
                .object({
                  type: z.literal('error'),
                  content: z.string(),
                  errorKey: z.string(),
                })
                .strict(),
            ),
            warningMessages: z.array(
              z
                .object({
                  type: z.literal('warning'),
                  content: z.string(),
                  errorKey: z.string(),
                })
                .strict(),
            ),
          })
          .strict(),
      ),
    })
    .strict(),
);
export type ParsersEngineExecutedEvent = z.infer<typeof parsersEngineExecutedEventSchema>;

export const builtInParserInitializedEventSchema = makeSDKTelemetryEvent(
  'Built In Parser Initialized',
  z
    .object({
      isFromRule: z.boolean(),
      parserName: z.string(),
      options: z.record(z.unknown()),
      output: z.record(z.unknown()),
    })
    .strict(),
);
export type BuiltInParserInitializedEvent = z.infer<typeof builtInParserInitializedEventSchema>;

export const sdkTelemetryEventSchema = z.union([
  userLoggedInEventSchema,
  userFetchedRepositoryEventSchema,
  parsersEngineExecutedEventSchema,
  builtInParserInitializedEventSchema,
]);
export type SDKTelemetryEvent =
  | UserLoggedInEvent
  | UserFetchedRepositoryEvent
  | ParsersEngineExecutedEvent
  | BuiltInParserInitializedEvent;

/* v8 ignore stop */