import { type IResourceAttributes } from '@multiplayer-app/session-recorder-common';
import OptionalConstants from './constants.optional';
import { Platform, Dimensions, PixelRatio } from 'react-native';
import { version } from '../version';
import { getAutoDetectedAppMetadata } from './app-metadata';

// Global app metadata configuration for non-Expo apps
let globalAppMetadata: { name?: string; version?: string; bundleId?: string } =
  {};

// Cache for auto-detected metadata to avoid repeated file reads
let autoDetectedMetadata: {
  name?: string;
  version?: string;
  bundleId?: string;
} | null = null;

export interface PlatformInfo {
  isExpo: boolean;
  isReactNative: boolean;
  platform: 'ios' | 'android' | 'web' | 'unknown';
  platformVersion?: string;
  expoVersion?: string;
  deviceType: string;
}

export function detectPlatform(): PlatformInfo {
  try {
    // Check if we're in an Expo environment
    const isExpo = !!OptionalConstants?.expoVersion;

    if (isExpo) {
      const expoVersion = OptionalConstants?.expoVersion;
      const platform = OptionalConstants?.platform;

      return {
        isExpo: true,
        isReactNative: true,
        platform: platform?.ios
          ? 'ios'
          : platform?.android
            ? 'android'
            : 'unknown',
        expoVersion,
        deviceType: 'expo',
      };
    }

    // Fallback to React Native detection
    return {
      isExpo: false,
      isReactNative: true,
      platform: Platform.OS as 'ios' | 'android' | 'web' | 'unknown',
      platformVersion: Platform.Version?.toString(),
      deviceType: Platform.OS,
    };
  } catch (error) {
    // Fallback for web or other environments
    return {
      isExpo: false,
      isReactNative: false,
      platform: 'unknown',
      deviceType: 'unknown',
    };
  }
}

export function getPlatformAttributes(): Record<string, any> {
  const platformInfo = detectPlatform();

  const attributes: Record<string, any> = {
    'platform': platformInfo.isExpo ? 'expo' : 'react-native',
    'device.type': platformInfo.deviceType,
  };

  if (platformInfo.platformVersion) {
    attributes['platform.version'] = platformInfo.platformVersion;
  }

  if (platformInfo.expoVersion) {
    attributes['expo.version'] = platformInfo.expoVersion;
  }

  return attributes;
}

export function isExpoEnvironment(): boolean {
  return detectPlatform().isExpo;
}

export function isReactNativeEnvironment(): boolean {
  return detectPlatform().isReactNative;
}

/**
 * Configure app metadata for non-Expo React Native apps
 * Call this function in your app initialization to provide app information
 *
 * @example
 * ```typescript
 * import { configureAppMetadata } from '@multiplayer-app/session-recorder-react-native'
 *
 * // In your App.tsx or index.js
 * configureAppMetadata({
 *   name: 'My Awesome App',
 *   version: '1.2.3',
 *   bundleId: 'com.mycompany.myapp',
 *   buildNumber: '123',
 *   displayName: 'My App',
 * })
 * ```
 */
export function configureAppMetadata(metadata: {
  name?: string;
  version?: string;
  bundleId?: string;
  buildNumber?: string;
  displayName?: string;
}): void {
  globalAppMetadata = { ...globalAppMetadata, ...metadata };
}

/**
 * Get configured app metadata
 */
export function getConfiguredAppMetadata(): {
  name?: string;
  version?: string;
  bundleId?: string;
  buildNumber?: string;
  displayName?: string;
} {
  return { ...globalAppMetadata };
}

/**
 * Automatically detect app metadata from common configuration files
 * This runs without developer intervention
 */
function autoDetectAppMetadata(): {
  name?: string;
  version?: string;
  bundleId?: string;
} {
  if (autoDetectedMetadata) {
    return autoDetectedMetadata;
  }

  try {
    // Get auto-detected metadata from build-time generated file
    const autoMetadata = getAutoDetectedAppMetadata();

    // Filter out undefined values
    const metadata: { name?: string; version?: string; bundleId?: string } = {};
    if (autoMetadata.name) metadata.name = autoMetadata.name;
    if (autoMetadata.version) metadata.version = autoMetadata.version;
    if (autoMetadata.bundleId) metadata.bundleId = autoMetadata.bundleId;

    autoDetectedMetadata = metadata;
    return metadata;
  } catch (error) {
    // Silently fail - this is optional auto-detection
    autoDetectedMetadata = {};
    return {};
  }
}

/**
 * Enhanced app metadata detection with automatic fallbacks
 */
export function getAppMetadata(): {
  name?: string;
  version?: string;
  bundleId?: string;
} {
  // Priority order:
  // 1. Expo config (if available)
  // 2. Manually configured metadata
  // 3. Auto-detected metadata
  // 4. Fallbacks

  const expoMetadata = getExpoMetadata();
  const configuredMetadata = getConfiguredAppMetadata();
  const autoMetadata = autoDetectAppMetadata();

  return {
    name: expoMetadata.name || configuredMetadata.name || autoMetadata.name,
    version:
      expoMetadata.version ||
      configuredMetadata.version ||
      autoMetadata.version,
    bundleId:
      expoMetadata.bundleId ||
      configuredMetadata.bundleId ||
      autoMetadata.bundleId,
  };
}

/**
 * Get metadata from Expo config
 */
function getExpoMetadata(): {
  name?: string;
  version?: string;
  bundleId?: string;
} {
  const expoConfig = OptionalConstants?.expoConfig;
  if (!expoConfig) return {};

  return {
    name: expoConfig.name,
    version: expoConfig.version,
    bundleId: expoConfig.ios?.bundleIdentifier || expoConfig.android?.package,
  };
}

export const getNavigatorInfo = (): IResourceAttributes => {
  const platformInfo = detectPlatform();
  const screenData = Dimensions.get('window');
  const screenDataScreen = Dimensions.get('screen');
  const pixelRatio = PixelRatio.get();

  // Get device type based on screen dimensions
  const getDeviceType = (): string => {
    const { width, height } = screenData;
    const minDimension = Math.min(width, height);
    const maxDimension = Math.max(width, height);

    // Rough device type detection based on screen size
    if (maxDimension >= 1024) {
      return 'Tablet';
    } else if (minDimension >= 600) {
      return 'Large Phone';
    } else {
      return 'Phone';
    }
  };

  // Get orientation
  const getOrientation = (): string => {
    const { width, height } = screenData;
    return width > height ? 'Landscape' : 'Portrait';
  };

  // Get OS version details
  const getOSInfo = (): string => {
    if (platformInfo.isExpo) {
      const platform = OptionalConstants?.platform;
      if (platform?.ios) {
        return `iOS ${Platform.Version}`;
      } else if (platform?.android) {
        return `Android ${Platform.Version}`;
      }
    }

    if (Platform.OS === 'ios') {
      return `iOS ${Platform.Version}`;
    } else if (Platform.OS === 'android') {
      return `Android ${Platform.Version}`;
    }

    return `${Platform.OS} ${Platform.Version || 'Unknown'}`;
  };

  // Get device info string
  const getDeviceInfo = (): string => {
    const deviceType = getDeviceType();
    const osInfo = getOSInfo();
    return `${deviceType} - ${osInfo}`;
  };

  // Get browser/runtime info
  const getBrowserInfo = (): string => {
    if (platformInfo.isExpo) {
      return `Expo ${platformInfo.expoVersion || 'Unknown'} - React Native`;
    }
    return 'React Native';
  };

  // Get screen size string
  const getScreenSize = (): string => {
    return `${Math.round(screenData.width)}x${Math.round(screenData.height)}`;
  };
  const metadata = getAppMetadata();
  // Get app info with fallbacks for non-Expo apps
  const getAppInfo = (): string => {
    const appName = getAppName();
    const appVersion = getAppVersion();
    return `${appName} v${appVersion}`;
  };

  // Get app name with automatic detection
  const getAppName = (): string => {
    if (metadata.name) return metadata.name;

    // Try configured display name as fallback
    const configuredMetadata = getConfiguredAppMetadata();
    if (configuredMetadata.displayName) return configuredMetadata.displayName;

    // Final fallback
    return 'React Native App';
  };

  // Get app version with automatic detection
  const getAppVersion = (): string => {
    if (metadata.version) return metadata.version;

    // Final fallback
    return 'Unknown';
  };

  // Get bundle ID with automatic detection
  const getBundleId = (): string => {
    if (metadata.bundleId) return metadata.bundleId;

    // Fallback
    return 'com.reactnative.app';
  };

  // Get build number with multiple fallback strategies
  const getBuildNumber = (): string => {
    // Try Expo config first
    const expoBuildNumber =
      OptionalConstants?.expoConfig?.ios?.buildNumber ||
      OptionalConstants?.expoConfig?.android?.versionCode;
    if (expoBuildNumber) return expoBuildNumber.toString();

    // Try configured metadata for non-Expo apps
    const configuredMetadata = getConfiguredAppMetadata();
    if (configuredMetadata.buildNumber) return configuredMetadata.buildNumber;

    // Fallback
    return '1';
  };

  // Get hardware info
  const getHardwareInfo = (): string => {
    const pixelRatioInfo = `Pixel Ratio: ${pixelRatio}`;
    const screenDensity = PixelRatio.getFontScale();
    return `${pixelRatioInfo}, Font Scale: ${screenDensity}`;
  };

  return {
    // Core platform info
    platform: platformInfo.isExpo ? 'expo' : 'react-native',
    userAgent: getBrowserInfo(),
    timestamp: new Date().toISOString(),

    // Device and OS information
    deviceInfo: getDeviceInfo(),
    osInfo: getOSInfo(),
    browserInfo: getBrowserInfo(),

    // Screen information
    screenSize: getScreenSize(),
    pixelRatio: pixelRatio,
    orientation: getOrientation(),
    screenWidth: Math.round(screenData.width),
    screenHeight: Math.round(screenData.height),
    screenScale: pixelRatio,

    // Device capabilities
    hardwareConcurrency: 1, // React Native doesn't expose CPU cores directly
    cookiesEnabled: 'N/A', // Not applicable in React Native

    // App information
    packageVersion: version,
    appInfo: getAppInfo(),
    appName: getAppName(),
    appVersion: getAppVersion(),
    bundleId: getBundleId(),
    buildNumber: getBuildNumber(),

    // Platform specific
    platformType: platformInfo.platform,
    platformVersion: platformInfo.platformVersion,
    expoVersion: platformInfo.expoVersion,
    deviceType: getDeviceType(),

    // Performance and hardware
    hardwareInfo: getHardwareInfo(),

    // Screen details
    screenDensity: PixelRatio.getFontScale(),
    screenScaleFactor: pixelRatio,
    windowWidth: Math.round(screenData.width),
    windowHeight: Math.round(screenData.height),
    fullScreenWidth: Math.round(screenDataScreen.width),
    fullScreenHeight: Math.round(screenDataScreen.height),

    // Environment info
    isExpo: platformInfo.isExpo,
    isReactNative: platformInfo.isReactNative,
    environment: platformInfo.isExpo ? 'expo' : 'react-native',

    // System type identifier (previously in system tags)
    systemType: 'mobile',
    // Additional platform attributes
    // ...getPlatformAttributes(),
  };
};