// adapter.cloudflare.ts

import { connect } from 'cloudflare:sockets';
export { Buffer } from 'node:buffer';

// Stub implementations for incompatible modules
export const path = {};
export const process = {};
export const util = {};
export const fs = {};

// File system related functions (not supported in Workers)
export async function readFileUtf8(...pathParts: string[]): Promise<string> {
  throw new Error('File system operations are not supported in Cloudflare Workers');
}

export function hasFSReadPermission(): boolean {
  return false;
}

export async function readDir(path: string) {
  return [];
}

export async function walk(
  path: string,
  params?: { match?: RegExp[]; skip?: RegExp[] },
) {
  return [];
}

export async function exists(fn: string | URL): Promise<boolean> {
  return false;
}

// Crypto and environment-related functions
export function hashSHA1toHex(msg: string): string {
  const encoder = new TextEncoder();
  const data = encoder.encode(msg);
  const hashBuffer = crypto.subtle.digest('SHA-1', data);
  return Array.from(new Uint8Array(hashBuffer))
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

export function homeDir(): string {
  throw new Error('Home directory is not available in Cloudflare Workers');
}

export async function input(message = "", _params?: { silent?: boolean }) {
  throw new Error('User input is not supported in Cloudflare Workers');
}

// Networking-related classes and functions
export namespace net {
  export function createConnection(port: number, hostname?: string): Socket;
  export function createConnection(unixpath: string): Socket;
  export function createConnection(
    port: number | string,
    hostname?: string,
  ): Socket {
    if (typeof port === 'string') {
      throw new Error('Unix socket connections are not supported in Cloudflare Workers');
    }
    return new Socket(port, hostname);
  }

  export function isIP(input: string): 0 | 4 | 6 {
    if (/^(\d{1,3}\.){3}\d{1,3}$/.test(input)) return 4;
    if (/^[0-9a-fA-F:]+$/.test(input)) return 6;
    return 0;
  }

  export class Socket extends EventTarget {
    private connection: Promise<any>;

    constructor(port: number, hostname?: string) {
      super();
      this.connection = connect({ hostname: hostname || 'localhost', port });
    }

    async write(data: Uint8Array) {
      const socket = await this.connection;
      const writer = socket.writable.getWriter();
      await writer.write(data);
      writer.releaseLock();
    }

    setNoDelay() {}
    unref() { return this; }
    ref() { return this; }
    pause() {}
    resume() {}
    destroy(error?: Error) {
      if (error) throw error;
    }
  }
}

// TLS-related functions
export namespace tls {
  export function connect(options: tls.ConnectionOptions): tls.TLSSocket {
    return new TLSSocket(options);
  }

  export function checkServerIdentity(
    _hostname: string,
    _cert: object,
  ): Error | undefined {
    return undefined;
  }

  export interface ConnectionOptions {
    host?: string;
    port?: number;
    ALPNProtocols?: string[];
    ca?: string | string[];
    checkServerIdentity?: (a: string, b: any) => Error | undefined;
    rejectUnauthorized?: boolean;
    servername?: string;
  }

  export class TLSSocket extends net.Socket {
    private _alpnProtocol: string | null = null;

    constructor(options: ConnectionOptions) {
      super(options.port!, options.host);
    }

    get alpnProtocol(): string | false {
      return this._alpnProtocol ?? false;
    }
  }
}

// Utility functions
export function exit(code?: number) {
  throw new Error('Cannot exit in Cloudflare Workers environment');
}

export function srcDir() {
  return '/';
}