export * from './base.schema';
export * from './database.schema';
export * from './provider.schema';
export * from './service.schema';

import { z } from 'zod';
import { baseConfigSchema, environmentSchema } from './base.schema';
import { providerConfigSchema, webshareProviderConfigSchema } from './provider.schema';
import { httpConfigSchema, queueConfigSchema } from './service.schema';

// Flexible service schema with defaults
const flexibleServiceConfigSchema = z.object({
  name: z.string().default('default-service'),
  port: z.number().min(1).max(65535).default(3000),
  host: z.string().default('0.0.0.0'),
  healthCheckPath: z.string().default('/health'),
  metricsPath: z.string().default('/metrics'),
  shutdownTimeout: z.number().default(30000),
  cors: z.object({
    enabled: z.boolean().default(true),
    origin: z.union([z.string(), z.array(z.string())]).default('*'),
    credentials: z.boolean().default(true),
  }).default({}),
}).default({});

// Flexible database schema with defaults
const flexibleDatabaseConfigSchema = z.object({
  postgres: z.object({
    host: z.string().default('localhost'),
    port: z.number().default(5432),
    database: z.string().default('test_db'),
    user: z.string().default('test_user'),
    password: z.string().default('test_pass'),
    ssl: z.boolean().default(false),
    poolSize: z.number().min(1).max(100).default(10),
    connectionTimeout: z.number().default(30000),
    idleTimeout: z.number().default(10000),
  }).default({}),
  questdb: z.object({
    host: z.string().default('localhost'),
    ilpPort: z.number().default(9009),
    httpPort: z.number().default(9000),
    pgPort: z.number().default(8812),
    database: z.string().default('questdb'),
    user: z.string().default('admin'),
    password: z.string().default('quest'),
    bufferSize: z.number().default(65536),
    flushInterval: z.number().default(1000),
  }).default({}),
  mongodb: z.object({
    uri: z.string().url().optional(),
    host: z.string().default('localhost'),
    port: z.number().default(27017),
    database: z.string().default('test_mongo'),
    user: z.string().optional(),
    password: z.string().optional(),
    authSource: z.string().default('admin'),
    replicaSet: z.string().optional(),
    poolSize: z.number().min(1).max(100).default(10),
  }).default({}),
  dragonfly: z.object({
    host: z.string().default('localhost'),
    port: z.number().default(6379),
    password: z.string().optional(),
    db: z.number().min(0).max(15).default(0),
    keyPrefix: z.string().optional(),
    ttl: z.number().optional(),
    maxRetries: z.number().default(3),
    retryDelay: z.number().default(100),
  }).default({}),
}).default({});

// Flexible log schema with defaults (renamed from logging)
const flexibleLogConfigSchema = z.object({
  level: z.enum(['trace', 'debug', 'info', 'warn', 'error', 'fatal']).default('info'),
  format: z.enum(['json', 'pretty']).default('json'),
  hideObject: z.boolean().default(false),
  loki: z.object({
    enabled: z.boolean().default(false),
    host: z.string().default('localhost'),
    port: z.number().default(3100),
    labels: z.record(z.string()).default({}),
  }).optional(),
}).default({});

// Complete application configuration schema
export const appConfigSchema = baseConfigSchema.extend({
  environment: environmentSchema.default('development'),
  service: flexibleServiceConfigSchema,
  log: flexibleLogConfigSchema,
  database: flexibleDatabaseConfigSchema,
  queue: queueConfigSchema.optional(),
  http: httpConfigSchema.optional(),
  providers: providerConfigSchema.optional(),
  webshare: webshareProviderConfigSchema.optional(),
});

export type AppConfig = z.infer<typeof appConfigSchema>;