// Register for protocol handling in manifest.json
{
  "protocol_handlers": [
    {
      "protocol": "gns",
      "name": "GeoNet Semantic Handler",
      "uriTemplate": "chrome-extension://[EXTENSION-ID]/handler.html?url=%s"
    }
  ]
}

// In background.js
chrome.webRequest.onBeforeRequest.addListener(
  function(details) {
    // Parse GNS URL
    const url = new URL(details.url);
    if (url.protocol === 'gns:') {
      const semanticAddress = url.hostname;
      return { redirectUrl: `chrome-extension://[EXTENSION-ID]/viewer.html?address=${semanticAddress}` };
    }
    return { cancel: false };
  },
  { urls: ["gns://*/*"] },
  ["blocking"]
);

// App.js - Main component
import React, { useEffect } from 'react';
import { SafeAreaView, StatusBar, View } from 'react-native';
import { DragonFireProvider } from './DragonFireContext';
import { AddressBar } from './components/AddressBar';
import { ContentViewer } from './components/ContentViewer';
import { initDragonFire } from './services/dragonfire';

const App = () => {
  useEffect(() => {
    // Initialize DragonFire client
    initDragonFire();
  }, []);

  return (
    
      
        
        
          
          
        
      
    
  );
};

export default App;

// Android: TimeModule.java
public class TimeModule extends ReactContextBaseJavaModule {
    private SntpClient sntpClient;
    
    @ReactMethod
    public void synchronizeTime(Promise promise) {
        sntpClient = new SntpClient();
        boolean success = sntpClient.requestTime("time.dragonfire.io", 5000);
        
        if (success) {
            WritableMap result = Arguments.createMap();
            result.putDouble("offset", sntpClient.getOffset());
            result.putDouble("time", sntpClient.getNtpTime());
            promise.resolve(result);
        } else {
            promise.reject("TIME_SYNC_ERROR", "Failed to synchronize time");
        }
    }
    
    @ReactMethod
    public double getCurrentSyncedTime() {
        return sntpClient.getNow();
    }
}

// 1. Initialize SDK
const sdk = new DragonFireSDK({
  apiKey: 'your-key',
  serviceName: 'YourService'
});
await sdk.initialize();

// 2. Register semantic ports
await sdk.registerService({
  ports: [
    {
      name: 'yourservice.resource',
      description: 'Resource access',
      commands: ['GET', 'UPDATE']
    }
  ]
});

// 3. Implement handlers
sdk.registerPortHandler('yourservice.resource', async (message) => {
  const { command, payload } = message;
  
  switch (command) {
    case 'GET':
      return await fetchResource(payload.id);
    case 'UPDATE':
      return await updateResource(payload.id, payload.data);
    default:
      throw new Error(`Unsupported command: ${command}`);
  }
});

// Resolve semantic address to port and handler
function resolveSemanticAddress(address) {
  const parts = address.split('.');
  if (parts.length !== 2) {
    throw new Error('Invalid semantic address format. Expected: namespace.resource');
  }
  
  const [namespace, resource] = parts;
  
  // Lookup in registry
  return lookupAddressInRegistry(namespace, resource)
    .then(registryEntry => {
      return {
        port: registryEntry.port,
        serviceEndpoint: registryEntry.endpoint,
        metaData: registryEntry.metaData
      };
    });
}

// Handle GNS links in web content
document.addEventListener('click', event => {
  // Check if clicked element is a GNS link
  if (event.target.tagName === 'A' && event.target.href.startsWith('gns://')) {
    event.preventDefault();
    
    const gnsUrl = new URL(event.target.href);
    const semanticAddress = gnsUrl.hostname;
    const path = gnsUrl.pathname;
    
    // Handle the GNS navigation
    navigateToSemanticAddress(semanticAddress, path);
  }
});

// Schedule a computation 5 seconds in the future
const currentTime = timeSync.getSyncedMicroTime();
const futureTime = currentTime + 5000000; // 5 seconds in microseconds
const targetFrame = timeSync.timeToFrame(futureTime);

timeSync.scheduleComputation(() => {
  // This will execute precisely at the target frame
  performSynchronizedOperation();
}, targetFrame);

// Coordinate distributed operations
function coordinateDistributedTask() {
  const startTime = timeSync.getSyncedMicroTime() + 10000000; // 10 seconds from now
  const startFrame = timeSync.timeToFrame(startTime);
  
  // Notify all participants
  participants.forEach(node => {
    notifyNode(node, {
      operation: 'DISTRIBUTED_TASK',
      startFrame: startFrame,
      parameters: taskParameters
    });
  });
  
  // Schedule local execution
  timeSync.scheduleComputation(() => {
    executeDistributedTaskLocally(taskParameters);
  }, startFrame);
}

// Generate a secure RWT token
const token = RWT.generate(userKey, {
  releaseAt: Date.now(),
  expiresAt: Date.now() + (60 * 60 * 1000), // 1 hour expiry
  meta: {
    userId: user.id,
    scopes: ['store.read', 'profile.read', 'profile.write']
  }
});

// Verify token on server side
function verifyToken(token, userKey) {
  if (!RWT.verify(token, userKey)) {
    throw new Error('Invalid or expired token');
  }
  
  const decoded = RWT.decode(token);
  const scopes = decoded.payload.meta.scopes || [];
  
  return {
    userId: decoded.payload.meta.userId,
    scopes,
    expiresAt: decoded.payload.expiresAt
  };
}

// Setup local development environment
const localDragonFire = new DragonFireDevServer({
  port: 9000,
  enableMockServices: true,
  mockTimeSync: true,
  logLevel: 'debug'
});

// Start the server
await localDragonFire.start();
console.log(`Local DragonFire server running at ws://localhost:9000`);

// Connect client to local server
const client = new DragonFireSDK({
  server: 'ws://localhost:9000',
  apiKey: 'dev-key'
});

// Mock time synchronization
client.timeSync.useMockTime({
  baseTime: Date.now() * 1000, // Convert to microseconds
  drift: 0 // No drift for predictable testing
});