import { z } from "zod";

import { DEFAULT_ENTRY, DEFAULT_IGNORE, DEFAULT_MANIFEST_HEADER } from "./constants.js";

export function normalizeExtension(value: string): string {
  return value.startsWith(".") ? value : `.${value}`;
}

export const extensionSchema = z
  .union([z.boolean(), z.string()])
  .default(true)
  .transform((value) => {
    if (typeof value === "string") {
      return normalizeExtension(value);
    }
    return value;
  });

export type ExtensionOption = z.infer<typeof extensionSchema>;

export const formattingSchema = z.object({
  quotes: z.enum(["single", "double"]).default("double"),
  header: z.array(z.string()).default([...DEFAULT_MANIFEST_HEADER]),
  extension: extensionSchema,
});

export type FormattingOptions = z.input<typeof formattingSchema>;
export type ResolvedFormattingOptions = z.infer<typeof formattingSchema>;

export const DEFAULT_FORMATTING: ResolvedFormattingOptions = {
  quotes: "double",
  header: [...DEFAULT_MANIFEST_HEADER],
  extension: true,
};

export const taserConfigSchema = z
  .object({
    routesDir: z.string().optional(),
    entry: z.string().default(DEFAULT_ENTRY),
    entryPath: z.string().optional(),
    serverDir: z.string().optional(),
    serverEntry: z.string().optional(),
    serverEntryPath: z.string().optional(),
    basePath: z.string().optional(),
    ignore: z.array(z.string()).default([...DEFAULT_IGNORE]),
    formatting: formattingSchema.default(DEFAULT_FORMATTING),
  })
  .transform((config) => ({
    ...config,
    entry: config.entryPath ?? config.entry,
    serverEntry: config.serverEntryPath ?? config.serverEntry,
  }));

export type TaserConfig = z.input<typeof taserConfigSchema>;
export type ResolvedTaserConfig = z.infer<typeof taserConfigSchema>;

export function resolveImportExtension(extension?: ExtensionOption): string | null {
  if (typeof extension === "string") {
    return normalizeExtension(extension);
  }
  return extension === false ? null : ".js";
}