// types/navigation.ts
export type RootStackParamList = {
  Home: undefined;
  Article: { 
    id: string; 
    category?: string;
    source?: 'deeplink' | 'push' | 'internal';
    timestamp?: number;
  };
  Category: { 
    categoryId: string; 
    filter?: string;
    sortBy?: 'date' | 'popularity';
  };
  Search: { 
    query?: string; 
    filters?: SearchFilters;
    page?: number;
  };
  Profile: {
    userId: string;
    tab?: 'articles' | 'saved' | 'settings';
  };
};

interface SearchFilters {
  dateRange?: { start: string; end: string };
  categories?: string[];
  authors?: string[];
}

declare global {
  namespace ReactNavigation {
    interface RootParamList extends RootStackParamList {}
  }
}

// config/linking.ts
import { LinkingOptions } from '@react-navigation/native';
import { RootStackParamList } from '../types/navigation';
import dynamicLinks from '@react-native-firebase/dynamic-links';
import { Linking } from 'react-native';
import { validateDeepLinkParams } from '../utils/deepLinkValidation';
import { logDeepLinkEvent } from '../services/analytics';

export const linkingConfig: LinkingOptions<RootStackParamList> = {
  prefixes: [
    'mynewsapp://',
    'https://news.com',
    'https://www.news.com',
    'https://m.news.com',
  ],
  config: {
    screens: {
      Home: {
        path: '/',
        exact: true,
      },
      Article: {
        path: '/article/:id',
        parse: {
          id: (id: string) => {
            const validated = validateDeepLinkParams.articleId(id);
            if (!validated.isValid) {
              throw new Error(`Invalid article ID: ${validated.error}`);
            }
            return validated.value;
          },
          category: (category: string) => decodeURIComponent(category),
          source: (source: string) => source as 'deeplink' | 'push' | 'internal',
        },
        stringify: {
          id: (id: string) => id,
          category: (category: string) => encodeURIComponent(category),
        },
      },
      Category: {
        path: '/category/:categoryId',
        parse: {
          categoryId: (categoryId: string) => categoryId,
          filter: (filter: string) => decodeURIComponent(filter),
          sortBy: (sortBy: string) => sortBy as 'date' | 'popularity',
        },
      },
      Search: {
        path: '/search',
        parse: {
          query: (query: string) => decodeURIComponent(query),
          filters: (filters: string) => {
            try {
              return JSON.parse(decodeURIComponent(filters));
            } catch {
              return undefined;
            }
          },
          page: (page: string) => parseInt(page, 10) || 1,
        },
        stringify: {
          query: (query: string) => encodeURIComponent(query),
          filters: (filters: any) => encodeURIComponent(JSON.stringify(filters)),
          page: (page: number) => page.toString(),
        },
      },
      Profile: {
        path: '/profile/:userId',
        parse: {
          userId: (userId: string) => userId,
          tab: (tab: string) => tab as 'articles' | 'saved' | 'settings',
        },
      },
    },
  },
  async getInitialURL() {
    try {
      // Handle cold start from deep link
      const url = await Linking.getInitialURL();
      if (url) {
        logDeepLinkEvent('cold_start', { url, source: 'native' });
        return url;
      }
      
      // Handle Firebase Dynamic Links
      const dynamicLink = await dynamicLinks().getInitialLink();
      if (dynamicLink?.url) {
        logDeepLinkEvent('cold_start', { 
          url: dynamicLink.url, 
          source: 'firebase',
          minimumVersion: dynamicLink.minimumAppVersion,
        });
        return dynamicLink.url;
      }
    } catch (error) {
      console.error('Error getting initial URL:', error);
      logDeepLinkEvent('error', { error: error.message, phase: 'initial_url' });
    }
    
    return null;
  },
  subscribe(listener) {
    // Listen for incoming app links (warm start)
    const linkingSubscription = Linking.addEventListener('url', ({ url }) => {
      logDeepLinkEvent('warm_start', { url, source: 'native' });
      listener(url);
    });

    // Listen for Firebase Dynamic Links
    const dynamicLinkSubscription = dynamicLinks().onLink(({ url, minimumAppVersion }) => {
      logDeepLinkEvent('warm_start', { 
        url, 
        source: 'firebase',
        minimumVersion: minimumAppVersion,
      });
      listener(url);
    });

    return () => {
      linkingSubscription?.remove();
      dynamicLinkSubscription();
    };
  },
};

// utils/deepLinkValidation.ts
interface ValidationResult<T> {
  isValid: boolean;
  value?: T;
  error?: string;
}

export const validateDeepLinkParams = {
  articleId: (id: string): ValidationResult<string> => {
    const articleIdRegex = /^[a-zA-Z0-9-_]{1,50}$/;
    if (!articleIdRegex.test(id)) {
      return {
        isValid: false,
        error: 'Article ID must be alphanumeric with hyphens/underscores, max 50 chars',
      };
    }
    return { isValid: true, value: id };
  },
  
  userId: (id: string): ValidationResult<string> => {
    const userIdRegex = /^[a-zA-Z0-9]{8,32}$/;
    if (!userIdRegex.test(id)) {
      return {
        isValid: false,
        error: 'User ID must be alphanumeric, 8-32 characters',
      };
    }
    return { isValid: true, value: id };
  },
  
  categoryId: (id: string): ValidationResult<string> => {
    const validCategories = ['tech', 'politics', 'sports', 'business', 'entertainment'];
    if (!validCategories.includes(id.toLowerCase())) {
      return {
        isValid: false,
        error: `Category must be one of: ${validCategories.join(', ')}`,
      };
    }
    return { isValid: true, value: id.toLowerCase() };
  },
};

{
  "applinks": {
    "details": [
      {
        "appIDs": ["TEAMID.com.newsapp"],
        "components": [
          {
            "/": "/article/*",
            "comment": "Article deep links"
          },
          {
            "/": "/category/*",
            "comment": "Category pages"
          },
          {
            "/": "/search*",
            "comment": "Search results"
          },
          {
            "/": "/profile/*",
            "comment": "User profiles"
          }
        ]
      }
    ]
  },
  "webcredentials": {
    "apps": ["TEAMID.com.newsapp"]
  },
  "appclips": {
    "apps": ["TEAMID.com.newsapp.Clip"]
  }
}

<!-- android/app/src/main/AndroidManifest.xml -->
<activity
    android:name=".MainActivity"
    android:exported="true"
    android:launchMode="singleTop">
    
    <!-- Existing intent filter for app launch -->
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
    
    <!-- App Links intent filter -->
    <intent-filter android:autoVerify="true">
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="https"
              android:host="news.com" />
    </intent-filter>
    
    <!-- Additional domains -->
    <intent-filter android:autoVerify="true">
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="https"
              android:host="www.news.com" />
    </intent-filter>
    
    <!-- Custom scheme fallback -->
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="mynewsapp" />
    </intent-filter>
</activity>

// services/dynamicLinks.ts
import dynamicLinks, { FirebaseDynamicLinksTypes } from '@react-native-firebase/dynamic-links';

interface DynamicLinkConfig {
  link: string;
  domainUriPrefix: string;
  android?: {
    packageName: string;
    minimumVersion?: string;
    fallbackUrl?: string;
  };
  ios?: {
    bundleId: string;
    minimumVersion?: string;
    fallbackUrl?: string;
  };
  social?: {
    title?: string;
    description?: string;
    imageUrl?: string;
  };
  analytics?: {
    campaign?: string;
    source?: string;
    medium?: string;
  };
}

export class DynamicLinkService {
  private readonly domainUriPrefix = 'https://newsapp.page.link';
  
  async createArticleLink(articleId: string, options: Partial<DynamicLinkConfig> = {}) {
    const config: DynamicLinkConfig = {
      link: `https://news.com/article/${articleId}`,
      domainUriPrefix: this.domainUriPrefix,
      android: {
        packageName: 'com.news.app',
        minimumVersion: '12',
        fallbackUrl: `https://news.com/article/${articleId}`,
        ...options.android,
      },
      ios: {
        bundleId: 'com.news.app',
        minimumVersion: '1.2.0',
        fallbackUrl: `https://news.com/article/${articleId}`,
        ...options.ios,
      },
      social: {
        title: 'Check out this article',
        description: 'Read the latest news on our app',
        imageUrl: 'https://news.com/og-image.jpg',
        ...options.social,
      },
      analytics: {
        campaign: 'article_share',
        source: 'app',
        medium: 'dynamic_link',
        ...options.analytics,
      },
    };

    try {
      const link = await dynamicLinks().buildShortLink({
        link: config.link,
        domainUriPrefix: config.domainUriPrefix,
        android: config.android,
        ios: config.ios,
        social: config.social,
        analytics: config.analytics,
      });

      return {
        success: true,
        shortLink: link,
        previewLink: `${link}?d=1`, // Preview link for testing
      };
    } catch (error) {
      console.error('Failed to create dynamic link:', error);
      return {
        success: false,
        error: error.message,
        fallbackUrl: config.link,
      };
    }
  }

  async handleIncomingLink(url: string) {
    try {
      // Parse the URL and extract parameters
      const urlObj = new URL(url);
      const pathSegments = urlObj.pathname.split('/').filter(Boolean);
      
      // Route based on path structure
      if (pathSegments[0] === 'article' && pathSegments[1]) {
        return {
          route: 'Article',
          params: {
            id: pathSegments[1],
            source: 'deeplink',
            timestamp: Date.now(),
          },
        };
      } else if (pathSegments[0] === 'category' && pathSegments[1]) {
        return {
          route: 'Category',
          params: {
            categoryId: pathSegments[1],
            source: 'deeplink',
          },
        };
      } else if (pathSegments[0] === 'search') {
        const query = urlObj.searchParams.get('q');
        return {
          route: 'Search',
          params: {
            query: query ? decodeURIComponent(query) : undefined,
            source: 'deeplink',
          },
        };
      }
      
      // Default to home
      return {
        route: 'Home',
        params: {},
      };
    } catch (error) {
      console.error('Error handling incoming link:', error);
      return {
        route: 'Home',
        params: {},
        error: error.message,
      };
    }
  }
}

// services/analytics.ts
import analytics from '@react-native-firebase/analytics';
import crashlytics from '@react-native-firebase/crashlytics';

interface DeepLinkEvent {
  url: string;
  source: 'native' | 'firebase';
  phase: 'cold_start' | 'warm_start' | 'error' | 'navigation_success' | 'navigation_failure';
  route?: string;
  params?: Record<string, any>;
  error?: string;
  timestamp: number;
  userAgent?: string;
}

export function logDeepLinkEvent(
  type: DeepLinkEvent['phase'],
  data: Partial<DeepLinkEvent>
) {
  const event: DeepLinkEvent = {
    ...data,
    phase: type,
    timestamp: Date.now(),
  };

  // Log to Firebase Analytics
  analytics().logEvent('deep_link_event', {
    phase: event.phase,
    source: event.source,
    route: event.route,
    url_hash: event.url ? hashUrl(event.url) : undefined,
  });

  // Log errors to Crashlytics
  if (type === 'error' && event.error) {
    crashlytics().recordError(new Error(`Deep Link Error: ${event.error}`));
    crashlytics().setAttributes({
      deeplink_url: event.url || 'unknown',
      deeplink_source: event.source || 'unknown',
    });
  }

  // Development logging
  if (__DEV__) {
    console.log('Deep Link Event:', event);
  }
}

function hashUrl(url: string): string {
  // Simple hash function for privacy-safe URL logging
  let hash = 0;
  for (let i = 0; i < url.length; i++) {
    const char= url.charCodeAt(i);
    hash= ((hash << 5) - hash) + char;
    hash= hash & hash; // Convert to 32bit integer
  }
  return hash.toString();
}

// context/DeepLinkContext.tsx
import React, { createContext, useContext, useEffect, useReducer } from 'react';
import { DynamicLinkService } from '../services/dynamicLinks';
import { useNavigation } from '@react-navigation/native';

interface DeepLinkState {
  isProcessing: boolean;
  lastProcessedUrl?: string;
  pendingNavigation?: {
    route: string;
    params: any;
  };
  error?: string;
}

type DeepLinkAction =
  | { type: 'PROCESSING_START'; url: string }
  | { type: 'PROCESSING_SUCCESS'; route: string; params: any }
  | { type: 'PROCESSING_ERROR'; error: string }
  | { type: 'CLEAR_ERROR' }
  | { type: 'NAVIGATION_COMPLETE' };

const initialState: DeepLinkState = {
  isProcessing: false,
};

function deepLinkReducer(state: DeepLinkState, action: DeepLinkAction): DeepLinkState {
  switch (action.type) {
    case 'PROCESSING_START':
      return {
        ...state,
        isProcessing: true,
        lastProcessedUrl: action.url,
        error: undefined,
      };
    case 'PROCESSING_SUCCESS':
      return {
        ...state,
        isProcessing: false,
        pendingNavigation: {
          route: action.route,
          params: action.params,
        },
      };
    case 'PROCESSING_ERROR':
      return {
        ...state,
        isProcessing: false,
        error: action.error,
      };
    case 'CLEAR_ERROR':
      return {
        ...state,
        error: undefined,
      };
    case 'NAVIGATION_COMPLETE':
      return {
        ...state,
        pendingNavigation: undefined,
      };
    default:
      return state;
  }
}

const DeepLinkContext = createContext<{
  state: DeepLinkState;
  processDeepLink: (url: string) => Promise<void>;
  clearError: () => void;
} | null>(null);  

export function DeepLinkProvider({ children }: { children: React.ReactNode }) {
  const [state, dispatch] = useReducer(deepLinkReducer, initialState);
  const navigation = useNavigation();
  const dynamicLinkService = new DynamicLinkService();

  const processDeepLink = async (url: string) => {
    dispatch({ type: 'PROCESSING_START', url });
    
    try {
      const result = await dynamicLinkService.handleIncomingLink(url);
      
      if (result.error) {
        throw new Error(result.error);
      }
      
      dispatch({ 
        type: 'PROCESSING_SUCCESS', 
        route: result.route, 
        params: result.params 
      });
      
      // Navigate to the resolved route
      navigation.navigate(result.route as any, result.params);
      dispatch({ type: 'NAVIGATION_COMPLETE' });
      
    } catch (error) {
      dispatch({ type: 'PROCESSING_ERROR', error: error.message });
    }
  };

  const clearError = () => {
    dispatch({ type: 'CLEAR_ERROR' });
  };

  return (
    <DeepLinkContext.Provider value={{ state, processDeepLink, clearError }}>
      {children}
    </DeepLinkContext.Provider>
  );
}

export function useDeepLink() {
  const context = useContext(DeepLinkContext);
  if (!context) {
    throw new Error('useDeepLink must be used within a DeepLinkProvider');
  }
  return context;
}

// hooks/useAuthenticatedDeepLink.ts
import { useEffect } from 'react';
import { useNavigation } from '@react-navigation/native';
import { useAuth } from '../context/AuthContext';
import { useDeepLink } from '../context/DeepLinkContext';

interface AuthenticatedRoute {
  route: string;
  requiresAuth: boolean;
  requiredPermissions?: string[];
}

const routeConfig: Record<string, AuthenticatedRoute> = {
  Home: { route: 'Home', requiresAuth: false },
  Article: { route: 'Article', requiresAuth: false },
  Profile: { 
    route: 'Profile', 
    requiresAuth: true,
    requiredPermissions: ['profile.read'],
  },
  Search: { route: 'Search', requiresAuth: false },
  Category: { route: 'Category', requiresAuth: false },
};

export function useAuthenticatedDeepLink() {
  const navigation = useNavigation();
  const { user, isAuthenticated, permissions } = useAuth();
  const { state: deepLinkState } = useDeepLink();

  useEffect(() => {
    if (!deepLinkState.pendingNavigation) return;

    const { route, params } = deepLinkState.pendingNavigation;
    const config = routeConfig[route];

    if (!config) {
      console.warn(`Unknown route: ${route}`);
      navigation.navigate('Home');
      return;
    }

    // Check authentication requirements
    if (config.requiresAuth && !isAuthenticated) {
      // Store the intended destination and redirect to login
      navigation.navigate('Login', {
        redirectTo: route,
        redirectParams: params,
      });
      return;
    }

    // Check permissions
    if (config.requiredPermissions && isAuthenticated) {
      const hasPermissions = config.requiredPermissions.every(
        permission => permissions?.includes(permission)
      );

      if (!hasPermissions) {
        navigation.navigate('Unauthorized', {
          requiredPermissions: config.requiredPermissions,
        });
        return;
      }
    }

    // Navigate to the target route
    navigation.navigate(route as any, params);
  }, [deepLinkState.pendingNavigation, isAuthenticated, permissions]);
}

// __tests__/deepLinking.test.ts
import { linkingConfig } from '../config/linking';
import { getStateFromPath } from '@react-navigation/native';

describe('Deep Link Configuration', () => {
  test('should parse article URLs correctly', () => {
    const url = 'https://news.com/article/tech-news-123?category=technology';
    const state = getStateFromPath(url, linkingConfig.config);
    
    expect(state?.routes[0]?.name).toBe('Article');
    expect(state?.routes[0]?.params).toEqual({
      id: 'tech-news-123',
      category: 'technology',
    });
  });

  test('should handle search URLs with complex filters', () => {
    const filters = { categories: ['tech', 'sports'], dateRange: { start: '2024-01-01', end: '2024-12-31' } };
    const url = `https://news.com/search?query=breaking&filters=${encodeURIComponent(JSON.stringify(filters))}`;
    const state = getStateFromPath(url, linkingConfig.config);
    
    expect(state?.routes[0]?.name).toBe('Search');
    expect(state?.routes[0]?.params?.query).toBe('breaking');
    expect(state?.routes[0]?.params?.filters).toEqual(filters);
  });

  test('should validate article IDs', () => {
    const invalidUrl = 'https://news.com/article/invalid@id#123';
    
    expect(() => {
      getStateFromPath(invalidUrl, linkingConfig.config);
    }).toThrow('Invalid article ID');
  });
});