import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'dart:typed_data';

import '../core/utils/app_logger.dart';

class HostMappingProxyService {
  HostMappingProxyService._();

  static final HostMappingProxyService instance = HostMappingProxyService._();

  ServerSocket? _server;
  HostMappingProxyEndpoint? _endpoint;
  Map<String, String> _hostMap = const {};

  HostMappingProxyEndpoint? get endpoint => _hostMap.isEmpty ? null : _endpoint;

  Future<HostMappingProxyEndpoint?> configure(
    Map<String, String> hostMap,
  ) async {
    final cleaned = <String, String>{};
    for (final entry in hostMap.entries) {
      final host = _normalizeHost(entry.key);
      final ip = entry.value.trim();
      if (host.isNotEmpty && ip.isNotEmpty) {
        cleaned[host] = ip;
      }
    }

    if (cleaned.isEmpty) {
      await stop();
      return null;
    }

    _hostMap = cleaned;
    if (_server == null) {
      _server = await ServerSocket.bind(InternetAddress.loopbackIPv4, 0);
      _endpoint = HostMappingProxyEndpoint(
        host: InternetAddress.loopbackIPv4.address,
        port: _server!.port,
      );
      _server!.listen(
        _handleClient,
        onError: (e) {
          AppLogger.d('自定义线路本地代理监听错误: $e');
        },
      );
      AppLogger.d('自定义线路本地代理已启动: ${_endpoint!.proxyUri}');
    }
    return _endpoint;
  }

  Future<void> stop() async {
    _hostMap = const {};
    final server = _server;
    _server = null;
    _endpoint = null;
    if (server != null) {
      await server.close();
      AppLogger.d('自定义线路本地代理已关闭');
    }
  }

  void _handleClient(Socket client) {
    unawaited(_serveClient(client));
  }

  Future<void> _serveClient(Socket client) async {
    Socket? remote;
    StreamController<List<int>>? rest;
    try {
      client.setOption(SocketOption.tcpNoDelay, true);
      final initial = await _readInitialRequest(client);
      rest = initial.rest;
      final lines = latin1.decode(initial.header).split('\r\n');
      if (lines.isEmpty || lines.first.trim().isEmpty) {
        throw const FormatException('empty proxy request');
      }

      final first = lines.first.split(' ');
      if (first.length < 3) {
        throw FormatException('invalid proxy request: ${lines.first}');
      }

      final method = first[0].toUpperCase();
      if (method == 'CONNECT') {
        final target = _splitAuthority(first[1], 443);
        remote = await _connectMapped(target.host, target.port);
        client.add(utf8.encode('HTTP/1.1 200 Connection Established\r\n\r\n'));
        await client.flush();
      } else {
        final target = _httpTarget(first[1], lines);
        remote = await _connectMapped(target.host, target.port);
        remote.add(_rewriteHttpHeader(initial.header, target.requestTarget));
      }

      remote.setOption(SocketOption.tcpNoDelay, true);
      unawaited(rest.stream.pipe(remote).catchError((_) {}));
      unawaited(remote.cast<List<int>>().pipe(client).catchError((_) {}));
    } catch (e) {
      AppLogger.d('自定义线路本地代理请求失败: $e');
      try {
        client.add(utf8.encode('HTTP/1.1 502 Bad Gateway\r\n\r\n'));
        await client.flush();
      } catch (_) {}
      await rest?.close();
      remote?.destroy();
      client.destroy();
    }
  }

  Future<_ProxyInitialRequest> _readInitialRequest(Socket socket) {
    final completer = Completer<_ProxyInitialRequest>();
    final builder = BytesBuilder(copy: false);
    final rest = StreamController<List<int>>(sync: true);
    late StreamSubscription<Uint8List> subscription;

    subscription = socket.listen(
      (chunk) {
        if (completer.isCompleted) {
          rest.add(chunk);
          return;
        }

        builder.add(chunk);
        final bytes = builder.toBytes();
        final end = _headerEnd(bytes);
        if (end >= 0) {
          final headerEnd = end + 4;
          completer.complete(
            _ProxyInitialRequest(
              header: bytes.sublist(0, headerEnd),
              rest: rest,
            ),
          );
          if (bytes.length > headerEnd) {
            rest.add(bytes.sublist(headerEnd));
          }
        } else if (bytes.length > 64 * 1024) {
          completer.completeError(
            const FormatException('proxy request header too large'),
          );
          unawaited(subscription.cancel());
          unawaited(rest.close());
        }
      },
      onError: (Object error, StackTrace stackTrace) {
        if (!completer.isCompleted) {
          completer.completeError(error, stackTrace);
        } else {
          rest.addError(error, stackTrace);
        }
      },
      onDone: () {
        if (!completer.isCompleted) {
          completer.completeError(const SocketException('proxy client closed'));
        }
        unawaited(rest.close());
      },
      cancelOnError: false,
    );

    return completer.future;
  }

  int _headerEnd(List<int> bytes) {
    for (var i = 0; i <= bytes.length - 4; i++) {
      if (bytes[i] == 13 &&
          bytes[i + 1] == 10 &&
          bytes[i + 2] == 13 &&
          bytes[i + 3] == 10) {
        return i;
      }
    }
    return -1;
  }

  Future<Socket> _connectMapped(String host, int port) {
    final normalized = _normalizeHost(host);
    final targetHost = _hostMap[normalized] ?? host;
    return Socket.connect(
      targetHost,
      port,
      timeout: const Duration(seconds: 12),
    );
  }

  _ProxyTarget _httpTarget(String target, List<String> lines) {
    final uri = Uri.tryParse(target);
    if (uri != null && uri.hasScheme && uri.host.isNotEmpty) {
      return _ProxyTarget(
        host: uri.host,
        port: uri.hasPort ? uri.port : (uri.scheme == 'https' ? 443 : 80),
        requestTarget: _originForm(uri),
      );
    }

    final hostHeader = _headerValue(lines, 'Host');
    final authority = _splitAuthority(hostHeader, 80);
    return _ProxyTarget(
      host: authority.host,
      port: authority.port,
      requestTarget: target,
    );
  }

  List<int> _rewriteHttpHeader(List<int> header, String requestTarget) {
    final text = latin1.decode(header);
    final lines = text.split('\r\n');
    final first = lines.first.split(' ');
    first[1] = requestTarget.isEmpty ? '/' : requestTarget;
    lines[0] = first.join(' ');
    final filtered = lines
        .where((line) => !line.toLowerCase().startsWith('proxy-connection:'))
        .join('\r\n');
    return latin1.encode(filtered);
  }

  String _originForm(Uri uri) {
    final path = uri.path.isEmpty ? '/' : uri.path;
    return uri.hasQuery ? '$path?${uri.query}' : path;
  }

  String _headerValue(List<String> lines, String name) {
    final prefix = '${name.toLowerCase()}:';
    for (final line in lines.skip(1)) {
      if (line.toLowerCase().startsWith(prefix)) {
        return line.substring(line.indexOf(':') + 1).trim();
      }
    }
    throw FormatException('missing $name header');
  }

  _ProxyAuthority _splitAuthority(String value, int defaultPort) {
    final authority = value.trim();
    if (authority.startsWith('[')) {
      final end = authority.indexOf(']');
      if (end > 0) {
        final host = authority.substring(1, end);
        final port = authority.length > end + 2
            ? int.tryParse(authority.substring(end + 2)) ?? defaultPort
            : defaultPort;
        return _ProxyAuthority(host, port);
      }
    }

    final colon = authority.lastIndexOf(':');
    if (colon > 0 && colon < authority.length - 1) {
      final port = int.tryParse(authority.substring(colon + 1));
      if (port != null) {
        return _ProxyAuthority(authority.substring(0, colon), port);
      }
    }
    return _ProxyAuthority(authority, defaultPort);
  }

  String _normalizeHost(String host) {
    final value = host.trim();
    final uri = Uri.tryParse(value);
    final resolved = uri != null && uri.hasScheme && uri.host.isNotEmpty
        ? uri.host
        : value;
    return resolved.toLowerCase().replaceAll(RegExp(r'\.$'), '');
  }
}

class HostMappingProxyEndpoint {
  final String host;
  final int port;

  const HostMappingProxyEndpoint({required this.host, required this.port});

  String get proxyUri => 'http://$host:$port';
}

class HostMappingHttpOverrides extends HttpOverrides {
  @override
  HttpClient createHttpClient(SecurityContext? context) {
    final client = super.createHttpClient(context);
    client.findProxy = (_) {
      final endpoint = HostMappingProxyService.instance.endpoint;
      if (endpoint == null) return 'DIRECT';
      return 'PROXY ${endpoint.host}:${endpoint.port}; DIRECT';
    };
    return client;
  }
}

class _ProxyInitialRequest {
  final Uint8List header;
  final StreamController<List<int>> rest;

  const _ProxyInitialRequest({required this.header, required this.rest});
}

class _ProxyAuthority {
  final String host;
  final int port;

  const _ProxyAuthority(this.host, this.port);
}

class _ProxyTarget {
  final String host;
  final int port;
  final String requestTarget;

  const _ProxyTarget({
    required this.host,
    required this.port,
    required this.requestTarget,
  });
}