xtremobile/lib/core/api/dns_interceptor.dart

import 'dart:convert';
import 'dart:io';
import 'package:dio/dio.dart';
import 'package:dio/io.dart';

/// Interceptor to fallback to DNS-over-HTTPS if standard DNS fails
/// Useful for emulators or restricted networks
class DnsFallbackInterceptor extends Interceptor {
  final Dio _dio;
  
  // Cache for resolved IPs
  final Map<String, String> _dnsCache = {};

  DnsFallbackInterceptor(this._dio);

  @override
  Future<void> onError(DioException err, ErrorInterceptorHandler handler) async {
    // Basic check for connection/host lookup errors
    if (_isDnsError(err)) {
      final uri = err.requestOptions.uri;
      final host = uri.host;

      print('DnsFallback: Caught DNS error for $host');

      // Check cache first
      String? ip = _dnsCache[host];

      if (ip == null) {
        try {
          // Attempt resolution attempts
          print('DnsFallback: Attempting DoH resolution...');
          ip = await _resolveWithDoH(host);
          
          if (ip != null) {
            print('DnsFallback: Resolved $host to $ip');
            _dnsCache[host] = ip;
          } else {
             print('DnsFallback: Failed to resolve $host');
          }
        } catch (e) {
          print('DnsFallback: Resolution error: $e');
          return handler.next(err);
        }
      }

      if (ip != null) {
        try {
          // Clone options but replace host with IP
          final newUri = uri.replace(host: ip);
          final options = err.requestOptions.copyWith(path: newUri.toString());
          
          // IMPORTANT: Set Host header so the server handles it correctly
          options.headers['Host'] = host;
          
          // Retry request
          print('DnsFallback: Retrying request to $ip');
          final response = await _dio.fetch(options);
          return handler.resolve(response);
        } catch (e) {
           print('DnsFallback: Retry failed: $e');
           return handler.next(err);
        }
      }
    }
    
    handler.next(err);
  }

  bool _isDnsError(DioException err) {
    if (err.type == DioExceptionType.connectionError || err.type == DioExceptionType.unknown) {
       if (err.error is SocketException) {
          final msg = (err.error as SocketException).message;
          return msg.contains('Failed host lookup') || msg.contains('No address associated with hostname');
       }
    }
    return false;
  }

  /// Resolve hostname using multiple DoH providers
  Future<String?> _resolveWithDoH(String hostname) async {
    // 1. Google DNS (8.8.8.8)
    String? ip = await _queryDoH('https://8.8.8.8/resolve?name=$hostname&type=A');
    if (ip != null) return ip;

    // 2. Cloudflare DNS (1.1.1.1)
    ip = await _queryDoH('https://1.1.1.1/dns-query?name=$hostname&type=A', 
      headers: {'accept': 'application/dns-json'});
    if (ip != null) return ip;
    
    return null;
  }

  Future<String?> _queryDoH(String url, {Map<String, String>? headers}) async {
    try {
      // Create a raw HttpClient to avoid loop and control SSL
      final client = HttpClient()
        ..badCertificateCallback = (cert, host, port) => true; // IGNORE SSL ERRORS just for DoH IP connectivity
        
      final request = await client.getUrl(Uri.parse(url));
      if (headers != null) {
        headers.forEach((k, v) => request.headers.add(k, v));
      }
      
      final response = await request.close();
      
      if (response.statusCode == 200) {
        final body = await response.transform(utf8.decoder).join();
        final json = jsonDecode(body);
        
        // Google/Cloudflare JSON format
        if (json['Status'] == 0 && json['Answer'] != null) {
          final answers = json['Answer'] as List;
          for (final ans in answers) {
             if (ans['type'] == 1) { // Type A record
               return ans['data'];
             }
          }
        }
      }
    } catch (e) {
      print('DnsFallback: DoH query to $url failed: $e');
    }
    return null;
  }
}