import { config } from 'dotenv';
import { logger } from '../utils/logger';

// Load test environment variables
config({ path: '.env.test' });

// Set test environment
process.env.NODE_ENV = 'test';

// Mock external services
jest.mock('../config/firebase', () => ({
  initializeApp: jest.fn(),
  getAuth: jest.fn(() => ({
    verifyIdToken: jest.fn().mockResolvedValue({
      uid: 'test-user-id',
      email: 'test@example.com'
    })
  })),
  getStorage: jest.fn(() => ({
    bucket: jest.fn(() => ({
      file: jest.fn(() => ({
        save: jest.fn().mockResolvedValue([{}]),
        getSignedUrl: jest.fn().mockResolvedValue(['https://test-url.com'])
      }))
    }))
  }))
}));

jest.mock('../config/supabase', () => ({
  getSupabaseClient: jest.fn(() => ({
    from: jest.fn(() => ({
      select: jest.fn().mockReturnThis(),
      insert: jest.fn().mockReturnThis(),
      update: jest.fn().mockReturnThis(),
      delete: jest.fn().mockReturnThis(),
      eq: jest.fn().mockReturnThis(),
      single: jest.fn().mockResolvedValue({ data: {}, error: null }),
      then: jest.fn().mockResolvedValue({ data: [], error: null })
    })),
    auth: {
      getUser: jest.fn().mockResolvedValue({
        data: { user: { id: 'test-user-id', email: 'test@example.com' } },
        error: null
      })
    }
  })),
  getSupabaseServiceClient: jest.fn(() => ({
    from: jest.fn(() => ({
      select: jest.fn().mockReturnThis(),
      insert: jest.fn().mockReturnThis(),
      update: jest.fn().mockReturnThis(),
      delete: jest.fn().mockReturnThis(),
      eq: jest.fn().mockReturnThis(),
      single: jest.fn().mockResolvedValue({ data: {}, error: null }),
      then: jest.fn().mockResolvedValue({ data: [], error: null })
    }))
  }))
}));

jest.mock('../services/documentAiProcessor', () => ({
  DocumentAIProcessor: jest.fn().mockImplementation(() => ({
    processDocument: jest.fn().mockResolvedValue({
      text: 'Test document text',
      confidence: 0.95
    }),
    checkConfiguration: jest.fn().mockResolvedValue(true)
  }))
}));

jest.mock('../services/llmService', () => ({
  LLMService: jest.fn().mockImplementation(() => ({
    processCIMDocument: jest.fn().mockResolvedValue({
      content: 'Test LLM response',
      model: 'test-model',
      tokensUsed: 100,
      cost: 0.01
    }),
    checkConfiguration: jest.fn().mockResolvedValue(true)
  }))
}));

jest.mock('../services/emailService', () => ({
  EmailService: jest.fn().mockImplementation(() => ({
    sendEmail: jest.fn().mockResolvedValue(true),
    sendWeeklySummary: jest.fn().mockResolvedValue(true)
  }))
}));

// Mock logger to prevent console output during tests
jest.mock('../utils/logger', () => ({
  logger: {
    info: jest.fn(),
    warn: jest.fn(),
    error: jest.fn(),
    debug: jest.fn(),
    uploadStart: jest.fn(),
    uploadSuccess: jest.fn(),
    uploadError: jest.fn(),
    processingStart: jest.fn(),
    processingSuccess: jest.fn(),
    processingError: jest.fn(),
    storageOperation: jest.fn(),
    jobQueueOperation: jest.fn()
  }
}));

// Global test utilities
global.testUtils = {
  // Create mock user
  createMockUser: (overrides = {}) => ({
    id: 'test-user-id',
    email: 'test@example.com',
    role: 'user',
    created_at: new Date().toISOString(),
    ...overrides
  }),

  // Create mock document
  createMockDocument: (overrides = {}) => ({
    id: 'test-document-id',
    user_id: 'test-user-id',
    filename: 'test-document.pdf',
    status: 'completed',
    created_at: new Date().toISOString(),
    updated_at: new Date().toISOString(),
    ...overrides
  }),

  // Create mock processing job
  createMockProcessingJob: (overrides = {}) => ({
    id: 'test-job-id',
    document_id: 'test-document-id',
    user_id: 'test-user-id',
    status: 'completed',
    created_at: new Date().toISOString(),
    updated_at: new Date().toISOString(),
    ...overrides
  }),

  // Mock request object
  createMockRequest: (overrides = {}) => ({
    method: 'GET',
    path: '/test',
    headers: {
      'content-type': 'application/json',
      authorization: 'Bearer test-token'
    },
    body: {},
    params: {},
    query: {},
    user: global.testUtils.createMockUser(),
    correlationId: 'test-correlation-id',
    ...overrides
  }),

  // Mock response object
  createMockResponse: () => {
    const res: any = {};
    res.status = jest.fn().mockReturnValue(res);
    res.json = jest.fn().mockReturnValue(res);
    res.send = jest.fn().mockReturnValue(res);
    res.setHeader = jest.fn().mockReturnValue(res);
    res.getHeader = jest.fn().mockReturnValue('test-header');
    return res;
  },

  // Mock next function
  createMockNext: () => jest.fn(),

  // Wait for async operations
  wait: (ms: number) => new Promise(resolve => setTimeout(resolve, ms)),

  // Generate test data
  generateTestData: {
    users: (count: number) => Array.from({ length: count }, (_, i) => 
      global.testUtils.createMockUser({
        id: `user-${i}`,
        email: `user${i}@example.com`
      })
    ),
    documents: (count: number) => Array.from({ length: count }, (_, i) => 
      global.testUtils.createMockDocument({
        id: `doc-${i}`,
        filename: `document-${i}.pdf`
      })
    ),
    processingJobs: (count: number) => Array.from({ length: count }, (_, i) => 
      global.testUtils.createMockProcessingJob({
        id: `job-${i}`,
        document_id: `doc-${i}`
      })
    )
  }
};

// Test environment setup
beforeAll(async () => {
  // Setup test database if needed
  console.log('Setting up test environment...');
});

afterAll(async () => {
  // Cleanup test environment
  console.log('Cleaning up test environment...');
});

// Global test configuration
beforeEach(() => {
  // Clear all mocks before each test
  jest.clearAllMocks();
  
  // Reset test data
  global.testData = {
    users: [],
    documents: [],
    processingJobs: []
  };
});

afterEach(() => {
  // Cleanup after each test
  jest.restoreAllMocks();
});

// Export test utilities for use in test files
export { global };