// packages/logger/src/index.ts
import winston from 'winston';

export interface LoggerConfig {
  serviceName: string;
  level?: string;
  environment?: string;
}

export const createLogger = (config: LoggerConfig | string) => {
  // Support both: createLogger('service-name') and createLogger({ ... })
  const options: LoggerConfig = typeof config === 'string' 
    ? { serviceName: config }
    : config;

  const {
    serviceName,
    level = process.env.LOG_LEVEL || 'info',
    environment = process.env.NODE_ENV || 'development',
  } = options;

  // Structured format for production
  const jsonFormat = winston.format.combine(
    winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
    winston.format.errors({ stack: true }),
    winston.format.json()
  );

  // Human-readable format for development
  const consoleFormat = winston.format.combine(
    winston.format.colorize(),
    winston.format.timestamp({ format: 'HH:mm:ss' }),
    winston.format.printf(({ timestamp, level, message, service, ...meta }) => {
      const metaStr = Object.keys(meta).length 
        ? '\n' + JSON.stringify(meta, null, 2) 
        : '';
      return `${timestamp} [${service}] ${level}: ${message}${metaStr}`;
    })
  );

  return winston.createLogger({
    level,
    format: jsonFormat,
    defaultMeta: { 
      service: serviceName,
      environment,
      hostname: process.env.HOSTNAME,
    },
    transports: [
      // Console for all environments
      new winston.transports.Console({
        format: environment === 'production' ? jsonFormat : consoleFormat,
      }),
      
      // File logs in production
      ...(environment === 'production' ? [
        new winston.transports.File({ 
          filename: 'logs/error.log', 
          level: 'error',
          maxsize: 5242880, // 5MB
          maxFiles: 5,
        }),
        new winston.transports.File({ 
          filename: 'logs/combined.log',
          maxsize: 5242880,
          maxFiles: 5,
        }),
      ] : []),
    ],
  });
};

// Export types
export type Logger = winston.Logger;

// packages/logger/__tests__/logger.test.ts
import { createLogger } from '../src';

describe('Logger', () => {
  it('should create logger with service name', () => {
    const logger = createLogger('test-service');
    expect(logger.defaultMeta.service).toBe('test-service');
  });

  it('should accept string or config object', () => {
    const logger1 = createLogger('service-1');
    const logger2 = createLogger({ serviceName: 'service-2' });
    
    expect(logger1.defaultMeta.service).toBe('service-1');
    expect(logger2.defaultMeta.service).toBe('service-2');
  });

  it('should use environment variables', () => {
    process.env.LOG_LEVEL = 'debug';
    const logger = createLogger('test');
    
    expect(logger.level).toBe('debug');
  });
});

// services/auth-service/src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { createLogger } from '@radarkit/logger';  // ← Import from package

async function bootstrap() {
  const logger = createLogger('auth-service');
  
  const app = await NestFactory.create(AppModule, {
    logger: false, // Disable default logger
  });
  
  // Use our logger
  app.useLogger(logger);
  
  const port = process.env.PORT || 3001;
  await app.listen(port);
  
  logger.info(`Auth service running on port ${port}`);
}

bootstrap();

// services/auth-service/src/auth/auth.service.ts
import { Injectable } from '@nestjs/common';
import { createLogger } from '@radarkit/logger';

@Injectable()
export class AuthService {
  private logger = createLogger('auth-service');

  async login(email: string, password: string) {
    this.logger.info('Login attempt', { email });
    
    try {
      // ... authentication logic
      this.logger.info('Login successful', { email, userId: user.id });
      return user;
    } catch (error) {
      this.logger.error('Login failed', { email, error: error.message });
      throw error;
    }
  }
}

// packages/types/src/index.ts

// Domain entities
export interface User {
  id: string;
  email: string;
  name: string;
  role: 'user' | 'admin';
  createdAt: Date;
}

export interface Source {
  id: string;
  userId: string;
  url: string;
  type: 'rss' | 'web';
  status: 'active' | 'paused' | 'error';
  checkInterval: number;
  createdAt: Date;
}

export interface Alert {
  id: string;
  sourceId: string;
  userId: string;
  title: string;
  content: string;
  url: string;
  publishedAt: Date;
  createdAt: Date;
}

// Event types (for Kafka)
export interface DomainEvent<T = unknown> {
  type: string;
  timestamp: string;
  data: T;
  metadata: {
    service: string;
    version: string;
    correlationId: string;
    causationId?: string;
  };
}

// Specific event types
export type SourceCreatedEvent = DomainEvent<{
  sourceId: string;
  userId: string;
  url: string;
  type: 'rss' | 'web';
}>;

export type ContentFoundEvent = DomainEvent<{
  sourceId: string;
  title: string;
  content: string;
  url: string;
  publishedAt: string;
}>;

export type AlertCreatedEvent = DomainEvent<{
  alertId: string;
  userId: string;
  title: string;
}>;

// API types
export interface ApiResponse<T> {
  success: boolean;
  data?: T;
  error?: {
    code: string;
    message: string;
  };
}

export interface PaginatedResponse<T> {
  items: T[];
  total: number;
  page: number;
  pageSize: number;
  hasMore: boolean;
}

// sources-service/src/sources/sources.service.ts
import { SourceCreatedEvent } from '@radarkit/types';

const event: SourceCreatedEvent = {
  type: 'source.created',
  timestamp: new Date().toISOString(),
  data: {
    sourceId: source.id,
    userId: source.userId,
    url: source.url,
    type: source.type,
  },
  metadata: {
    service: 'sources-service',
    version: '1.0.0',
    correlationId: uuid(),
  },
};

await kafka.publish('sources.created', event);

// scraper-service/src/scraper/scraper.consumer.ts
import { SourceCreatedEvent } from '@radarkit/types';

async handleSourceCreated(message: SourceCreatedEvent) {
  // TypeScript knows the exact shape!
  const { sourceId, url, type } = message.data;
  
  // Type-safe access to all fields
  this.logger.info('New source to scrape', { sourceId, url });
  
  await this.startScraping(sourceId, url, type);
}

// packages/kafka-client/src/index.ts
import { Kafka, Producer, Consumer, EachMessagePayload } from 'kafkajs';
import { DomainEvent } from '@radarkit/types';
import { createLogger } from '@radarkit/logger';
import { v4 as uuid } from 'uuid';

export class KafkaClient {
  private kafka: Kafka;
  private producer: Producer;
  private logger = createLogger('kafka-client');
  
  constructor(
    private clientId: string,
    brokers: string[] = process.env.KAFKA_BROKERS?.split(',') || ['localhost:9092']
  ) {
    this.kafka = new Kafka({
      clientId,
      brokers,
      retry: {
        retries: 3,
        initialRetryTime: 300,
        factor: 2,
      },
    });
    
    this.producer = this.kafka.producer();
  }
  
  async connect(): Promise<void> {
    await this.producer.connect();
    this.logger.info('Kafka producer connected', { clientId: this.clientId });
  }
  
  async publish<T = unknown>(topic: string, event: DomainEvent<T>): Promise<void> {
    try {
      // Ensure correlation ID exists
      if (!event.metadata.correlationId) {
        event.metadata.correlationId = uuid();
      }
      
      await this.producer.send({
        topic,
        messages: [
          {
            key: event.metadata.correlationId,
            value: JSON.stringify(event),
            headers: {
              'event-type': event.type,
              'correlation-id': event.metadata.correlationId,
              'service': event.metadata.service,
            },
          },
        ],
      });
      
      this.logger.debug('Event published', { 
        topic, 
        type: event.type,
        correlationId: event.metadata.correlationId,
      });
    } catch (error) {
      this.logger.error('Failed to publish event', { 
        topic, 
        type: event.type,
        error: error.message,
      });
      throw error;
    }
  }
  
  createConsumer(groupId: string): Consumer {
    return this.kafka.consumer({ 
      groupId,
      sessionTimeout: 30000,
    });
  }
  
  async subscribe(
    consumer: Consumer,
    topic: string,
    handler: (event: DomainEvent) => Promise<void>
  ): Promise<void> {
    await consumer.connect();
    await consumer.subscribe({ topic, fromBeginning: false });
    
    await consumer.run({
      eachMessage: async ({ topic, partition, message }: EachMessagePayload) => {
        const correlationId = message.headers?.['correlation-id']?.toString();
        
        try {
          const event: DomainEvent = JSON.parse(message.value!.toString());
          
          this.logger.debug('Event received', { 
            topic, 
            type: event.type,
            correlationId,
          });
          
          await handler(event);
          
        } catch (error) {
          this.logger.error('Failed to process message', {
            topic,
            partition,
            offset: message.offset,
            correlationId,
            error: error.message,
          });
          throw error;
        }
      },
    });
  }
  
  async disconnect(): Promise<void> {
    await this.producer.disconnect();
    this.logger.info('Kafka producer disconnected');
  }
}