// core/shared/api/headers/providers/deviceHeaderProvider.ts
import { HeaderProvider } from '../types';
import { API_HEADERS } from '@/core/shared/constants/headers';
import DeviceInfo from 'react-native-device-info';
import { Platform } from 'react-native';
import { storage } from '@/core/shared/utils/storage';
 
export class DeviceHeaderProvider implements HeaderProvider {
  id = 'device';
  priority = 90; // High priority to ensure device context is available to other providers
  private deviceId: string | null = null;
  
  /**
   * Returns all device-related headers for API requests
   */
  async getHeaders(): Promise<Record<string, string | undefined>> {
    // Ensure we have a device ID
    if (!this.deviceId) {
      this.deviceId = await this.getOrCreateDeviceId();
    }
    
    // Collect basic device information
    const appVersion = DeviceInfo.getVersion();
    const buildNumber = DeviceInfo.getBuildNumber();
    const deviceType = DeviceInfo.getDeviceType();
    const deviceModel = await DeviceInfo.getModel();
    const systemVersion = DeviceInfo.getSystemVersion();
    const carrier = await DeviceInfo.getCarrierSync();
    
    return {
      [API_HEADERS.DEVICE_UUID]: this.deviceId,
      [API_HEADERS.DEVICE_TYPE]: deviceType,
      [API_HEADERS.APP_VERSION]: `${appVersion}+${buildNumber}`,
      [API_HEADERS.OS_VERSION]: `${Platform.OS} ${systemVersion}`,
      [API_HEADERS.DEVICE_MODEL]: deviceModel,
      ...(carrier ? { [API_HEADERS.CARRIER]: carrier } : {}),
    };
  }
  
  /**
   * Retrieves a stored device ID or creates a new one.
   * We persist this ID to provide consistent device identification
   * across app sessions.
   */
  private async getOrCreateDeviceId(): Promise<string> {
    // Try to get stored device ID
    let deviceId = await storage.getSecureItem('device_uuid');
    
    if (!deviceId) {
      // Create new device ID if none exists
      try {
        // First try to use the device's unique ID if available
        deviceId = await DeviceInfo.getUniqueId();
      } catch (error) {
        // Fallback to a generated UUID
        deviceId = this.generateUuidV4();
      }
      
      // Store for future use
      await storage.setSecureItem('device_uuid', deviceId);
    }
    
    return deviceId;
  }
  
  /**
   * Generate a UUID v4 as fallback device identifier
   */
  private generateUuidV4(): string {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
      const r = Math.random() * 16 | 0, 
          v = c == 'x' ? r : (r & 0x3 | 0x8);
      return v.toString(16);
    });
  }
}

// Example: Setting up API clients with device headers
import { PublicApiClient, AuthenticatedApiClient } from '@/core/shared/api/client';
import { DeviceHeaderProvider } from '@/core/shared/api/headers/providers/deviceHeaderProvider';
 
// Client setup
const apiConfig = { baseURL: process.env.API_BASE_URL };
 
// Create client instances
export const publicApi = new PublicApiClient(apiConfig);
export const authenticatedApi = new AuthenticatedApiClient(apiConfig);
 
// Register device header provider with both clients
const deviceHeaderProvider = new DeviceHeaderProvider();
publicApi.registerHeaderProvider(deviceHeaderProvider);
authenticatedApi.registerHeaderProvider(deviceHeaderProvider);

// core/shared/api/headers/providers/enhancedDeviceHeaderProvider.ts
import { DeviceHeaderProvider } from './deviceHeaderProvider';
import DeviceInfo from 'react-native-device-info';
import { Platform } from 'react-native';
import { API_HEADERS } from '@/core/shared/constants/headers';
 
export class EnhancedDeviceHeaderProvider extends DeviceHeaderProvider {
  id = 'enhanced-device';
  
  /**
   * Creates a device fingerprint from multiple device characteristics
   */
  private async createDeviceFingerprint(): Promise<string> {
    // Collect various device properties
    const brand = DeviceInfo.getBrand();
    const model = await DeviceInfo.getModel();
    const systemName = DeviceInfo.getSystemName();
    const systemVersion = DeviceInfo.getSystemVersion();
    const buildId = await DeviceInfo.getBuildId();
    const deviceName = await DeviceInfo.getDeviceName();
    const timezone = DeviceInfo.getTimezone();
    const hasNotch = DeviceInfo.hasNotch();
    
    // Combine properties into fingerprint string
    const fingerprintData = [
      brand,
      model,
      systemName,
      systemVersion,
      buildId,
      deviceName,
      timezone,
      hasNotch ? 'notch' : 'no-notch',
      Platform.constants?.reactNativeVersion || '',
    ].join('|');
    
    // Create hash of the fingerprint
    const fingerprintHash = await this.hashString(fingerprintData);
    return fingerprintHash;
  }
  
  /**
   * Simple hash function for fingerprint
   */
  private async hashString(str: string): Promise<string> {
    // This is a simple hash for demonstration purposes
    // In a real implementation, use a cryptographic hash function
    let hash = 0;
    for (let i = 0; i < str.length; i++) {
      const char = str.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash;
    }
    return hash.toString(16);
  }
  
  /**
   * Override getHeaders to include fingerprint
   */
  async getHeaders(): Promise<Record<string, string | undefined>> {
    // Get base headers from parent class
    const baseHeaders = await super.getHeaders();
    
    // Add fingerprint
    const fingerprint = await this.createDeviceFingerprint();
    
    return {
      ...baseHeaders,
      'X-DEVICE-FINGERPRINT': fingerprint,
    };
  }
}

// core/domains/security/deviceChangeDetector.ts
import { HeaderProvider } from '@/core/shared/api/headers/types';
import { API_HEADERS } from '@/core/shared/constants/headers';
import { useAuthStore } from '@/core/domains/auth/store';
import { storage } from '@/core/shared/utils/storage';
 
export class DeviceChangeDetector {
  /**
   * Checks if the current device differs from the last authenticated device
   * @param userId The ID of the current user
   * @param currentDeviceId The current device UUID
   */
  async checkDeviceChanged(userId: string, currentDeviceId: string): Promise<boolean> {
    const storageKey = `last_device_${userId}`;
    const lastDeviceId = await storage.getSecureItem(storageKey);
    
    // If no previous device ID or same device, no change detected
    if (!lastDeviceId || lastDeviceId === currentDeviceId) {
      // Update the last device ID
      await storage.setSecureItem(storageKey, currentDeviceId);
      return false;
    }
    
    // Device has changed
    // Update the stored device ID
    await storage.setSecureItem(storageKey, currentDeviceId);
    return true;
  }
}
 
/**
 * Hook to check device changes on login
 */
export function useDeviceChangeDetection() {
  const deviceChangeDetector = new DeviceChangeDetector();
  
  const checkDeviceChange = async (deviceId: string): Promise<boolean> => {
    const { user } = useAuthStore.getState();
    
    if (!user) {
      return false;
    }
    
    return deviceChangeDetector.checkDeviceChanged(user.id, deviceId);
  };
  
  return { checkDeviceChange };
}

// core/shared/api/headers/providers/networkQualityHeaderProvider.ts
import { HeaderProvider } from '../types';
import { API_HEADERS } from '@/core/shared/constants/headers';
import NetInfo, { NetInfoState } from '@react-native-community/netinfo';
 
export class NetworkQualityHeaderProvider implements HeaderProvider {
  id = 'network-quality';
  priority = 85; // Just below device headers
  
  async getHeaders(): Promise<Record<string, string | undefined>> {
    try {
      const netInfo = await NetInfo.fetch();
      
      return {
        'X-CONNECTION-TYPE': netInfo.type,
        'X-CONNECTION-EFFECTIVE-TYPE': netInfo.details?.effectiveType,
        ...(netInfo.isConnected !== null ? { 'X-CONNECTED': netInfo.isConnected.toString() } : {}),
        ...(typeof netInfo.details?.isConnectionExpensive === 'boolean' 
            ? { 'X-EXPENSIVE-CONNECTION': netInfo.details.isConnectionExpensive.toString() } 
            : {}),
      };
    } catch (error) {
      console.warn('Failed to get network information:', error);
      return {};
    }
  }
  
  /**
   * Subscribe to network changes and update network quality metrics
   */
  subscribeToNetworkChanges(callback?: (state: NetInfoState) => void): () => void {
    return NetInfo.addEventListener(state => {
      if (callback) {
        callback(state);
      }
    });
  }
}

// __tests__/core/shared/api/headers/providers/deviceHeaderProvider.test.ts
import { DeviceHeaderProvider } from '@/core/shared/api/headers/providers/deviceHeaderProvider';
import DeviceInfo from 'react-native-device-info';
import { API_HEADERS } from '@/core/shared/constants/headers';
import { storage } from '@/core/shared/utils/storage';
 
// Mock dependencies
jest.mock('react-native-device-info');
jest.mock('@/core/shared/utils/storage');
 
describe('DeviceHeaderProvider', () => {
  let provider: DeviceHeaderProvider;
  
  beforeEach(() => {
    // Reset mocks
    jest.clearAllMocks();
    
    // Setup default mock values
    (DeviceInfo.getVersion as jest.Mock).mockReturnValue('1.0.0');
    (DeviceInfo.getBuildNumber as jest.Mock).mockReturnValue('42');
    (DeviceInfo.getDeviceType as jest.Mock).mockReturnValue('Handset');
    (DeviceInfo.getModel as jest.Mock).mockResolvedValue('iPhone 12');
    (DeviceInfo.getSystemVersion as jest.Mock).mockReturnValue('14.5');
    (DeviceInfo.getCarrierSync as jest.Mock).mockReturnValue('T-Mobile');
    (DeviceInfo.getUniqueId as jest.Mock).mockResolvedValue('device-123');
    
    // Mock storage
    (storage.getSecureItem as jest.Mock).mockResolvedValue(null);
    (storage.setSecureItem as jest.Mock).mockResolvedValue(undefined);
    
    // Create provider instance
    provider = new DeviceHeaderProvider();
  });
  
  it('should retrieve device UUID from storage if it exists', async () => {
    // Setup storage mock to return existing device ID
    (storage.getSecureItem as jest.Mock).mockResolvedValue('stored-device-id');
    
    const headers = await provider.getHeaders();
    
    // Assert stored device ID is used
    expect(headers[API_HEADERS.DEVICE_UUID]).toBe('stored-device-id');
    
    // Verify storage was checked but not set
    expect(storage.getSecureItem).toHaveBeenCalledWith('device_uuid');
    expect(storage.setSecureItem).not.toHaveBeenCalled();
  });
  
  it('should create and store new device UUID if none exists', async () => {
    // Ensure storage returns null (no existing ID)
    (storage.getSecureItem as jest.Mock).mockResolvedValue(null);
    
    const headers = await provider.getHeaders();
    
    // Assert device ID is retrieved from DeviceInfo and stored
    expect(headers[API_HEADERS.DEVICE_UUID]).toBe('device-123');
    expect(storage.setSecureItem).toHaveBeenCalledWith('device_uuid', 'device-123');
  });
  
  it('should include all required device headers', async () => {
    const headers = await provider.getHeaders();
    
    // Verify all expected headers are present
    expect(headers[API_HEADERS.DEVICE_UUID]).toBeDefined();
    expect(headers[API_HEADERS.DEVICE_TYPE]).toBe('Handset');
    expect(headers[API_HEADERS.APP_VERSION]).toBe('1.0.0+42');
    expect(headers[API_HEADERS.OS_VERSION]).toContain('14.5');
    expect(headers[API_HEADERS.DEVICE_MODEL]).toBe('iPhone 12');
    expect(headers[API_HEADERS.CARRIER]).toBe('T-Mobile');
  });
  
  it('should handle errors from DeviceInfo gracefully', async () => {
    // Make DeviceInfo.getUniqueId throw an error
    (DeviceInfo.getUniqueId as jest.Mock).mockRejectedValue(new Error('Failed to get unique ID'));
    
    // Mock the UUID generation
    const mockUuid = 'generated-uuid-123';
    jest.spyOn(provider as any, 'generateUuidV4').mockReturnValue(mockUuid);
    
    const headers = await provider.getHeaders();
    
    // Verify fallback UUID was used
    expect(headers[API_HEADERS.DEVICE_UUID]).toBe(mockUuid);
    expect(storage.setSecureItem).toHaveBeenCalledWith('device_uuid', mockUuid);
  });
});

// __tests__/integration/api/deviceHeadersIntegration.test.ts
import { authenticatedApi } from '@/core/shared/api/client';
import { DeviceHeaderProvider } from '@/core/shared/api/headers/providers/deviceHeaderProvider';
import { API_HEADERS } from '@/core/shared/constants/headers';
import MockAdapter from 'axios-mock-adapter';
 
describe('Device Headers Integration', () => {
  let mockAxios: MockAdapter;
  
  beforeEach(() => {
    // Setup mock for the Axios instance
    mockAxios = new MockAdapter((authenticatedApi as any).client);
    
    // Register device header provider for testing
    authenticatedApi.registerHeaderProvider(new DeviceHeaderProvider());
  });
  
  afterEach(() => {
    mockAxios.restore();
  });
  
  it('should include device headers in API requests', async () => {
    // Setup mock response
    mockAxios.onGet('/test-endpoint').reply((config) => {
      // Check that device headers are present
      expect(config.headers[API_HEADERS.DEVICE_UUID]).toBeDefined();
      expect(config.headers[API_HEADERS.DEVICE_TYPE]).toBeDefined();
      expect(config.headers[API_HEADERS.APP_VERSION]).toBeDefined();
      
      return [200, { success: true }];
    });
    
    // Make request
    await authenticatedApi.get('/test-endpoint');
    
    // Verification is done in the mock response
    expect(mockAxios.history.get.length).toBe(1);
  });
});