// TlsnClient - Lightweight client SDK for TLSN component
// Zero dependencies. Works in any bundler or even as a plain <script> tag.

export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
export type LogLevel = 'info' | 'success' | 'warning' | 'error';

export interface AttestRequest {
  url: string;
  method: HttpMethod;
  headers?: Record<string, string>;
  body?: string | Record<string, unknown>;
}

export interface CommitRanges {
  sent: Array<{ start: number; end: number }>;
  recv: Array<{ start: number; end: number }>;
}

export interface AttestOptions {
  commitRanges?: CommitRanges;
  storage?: 'local' | 'onchain';
}

export interface AttestResult {
  presentation: unknown;
  serverName: string;
  time: number;
  sent: string;
  recv: string;
  verifyingKey: string;
  tokenId: string;
  requestTxHash: string;
}

export interface VerifyResult {
  serverName: string;
  time: number;
  sent: string;
  recv: string;
  verifyingKey: string;
}

export interface TranscriptPreview {
  sent: number[];
  recv: number[];
  sentText: string;
  recvText: string;
}

export interface StoreResult {
  txHash: string;
}

export interface TransactionDetails {
  description: string;
  amount: string;
  targetUrl?: string;
  tokenId?: string;
  txHash: string;
}

export interface TlsnClientOptions {
  /** URL where the TLSN iframe embed is hosted */
  iframeUrl: string;
  /** Container element to append the iframe to. Defaults to document.body. */
  container?: HTMLElement;
  /** Timeout in milliseconds for RPC calls. Defaults to 300000 (5 min). */
  timeout?: number;
  /** Timeout in milliseconds for iframe ready. Defaults to 30000 (30s). */
  readyTimeout?: number;
  /** Enable debug logging to console. Defaults to false. */
  debug?: boolean;
}

type EventCallback = (...args: any[]) => void;
type TxConfirmHandler = (details: TransactionDetails) => Promise<boolean>;

export class TlsnClient {
  private iframe: HTMLIFrameElement;
  private ready: Promise<void>;
  private pendingCalls = new Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }>();
  private listeners = new Map<string, Set<EventCallback>>();
  private txConfirmHandler: TxConfirmHandler | null = null;
  private timeout: number;
  private readyTimeout: number;
  private debugEnabled: boolean;
  private destroyed = false;

  constructor(options: TlsnClientOptions) {
    this.timeout = options.timeout || 300_000;
    this.readyTimeout = options.readyTimeout || 30_000;
    this.debugEnabled = options.debug || false;

    this.iframe = document.createElement('iframe');
    this.iframe.src = options.iframeUrl;
    this.iframe.style.cssText = 'display:none;width:0;height:0;border:none;position:absolute;';

    const container = options.container || document.body;
    container.appendChild(this.iframe);

    this.ready = new Promise<void>((resolve, reject) => {
      const timer = setTimeout(() => {
        window.removeEventListener('message', onMessage);
        reject(new Error(
          `TlsnClient: iframe did not become ready within ${this.readyTimeout}ms. ` +
          `Check that ${options.iframeUrl} is reachable and serving the TLSN embed with COOP/COEP headers.`
        ));
      }, this.readyTimeout);

      const onMessage = (event: MessageEvent) => {
        if (event.source !== this.iframe.contentWindow) return;
        if (event.data?.type === 'ready') {
          clearTimeout(timer);
          window.removeEventListener('message', onMessage);
          resolve();
        }
      };
      window.addEventListener('message', onMessage);
    });

    window.addEventListener('message', this.handleMessage);
  }

  async waitReady(): Promise<void> { await this.ready; }

  destroy(): void {
    this.destroyed = true;
    window.removeEventListener('message', this.handleMessage);
    this.iframe.remove();
    for (const [, pending] of this.pendingCalls) {
      pending.reject(new Error('TlsnClient destroyed'));
    }
    this.pendingCalls.clear();
    this.listeners.clear();
  }

  on(event: string, callback: EventCallback): void {
    if (!this.listeners.has(event)) this.listeners.set(event, new Set());
    this.listeners.get(event)!.add(callback);
  }

  off(event: string, callback: EventCallback): void {
    this.listeners.get(event)?.delete(callback);
  }

  onTransactionConfirm(handler: TxConfirmHandler): void {
    this.txConfirmHandler = handler;
  }

  async connect(rpcUrl: string): Promise<void> {
    await this.ready;
    await this.call('connect', { rpcUrl });
  }

  async connectWallet(mnemonic: string): Promise<string> {
    const result = await this.call<{ address: string }>('connectWallet', { mnemonic });
    return result.address;
  }

  async disconnect(): Promise<void> { await this.call('disconnect', {}); }

  async getAddress(): Promise<string> {
    const result = await this.call<{ address: string }>('getAddress', {});
    return result.address;
  }

  async getBalance(): Promise<string> {
    const result = await this.call<{ balance: string }>('getBalance', {});
    return result.balance;
  }

  async checkTlsNotary(): Promise<boolean> {
    const result = await this.call<{ enabled: boolean }>('checkTlsNotary', {});
    return result.enabled;
  }

  async generateMnemonic(): Promise<string> {
    const result = await this.call<{ mnemonic: string }>('generateMnemonic', {});
    return result.mnemonic;
  }

  async attest(request: AttestRequest, options?: AttestOptions): Promise<AttestResult> {
    return this.call<AttestResult>('attest', { request, options });
  }

  async verify(presentation: unknown): Promise<VerifyResult> {
    return this.call<VerifyResult>('verify', { presentation });
  }

  async previewTranscript(request: AttestRequest): Promise<TranscriptPreview> {
    return this.call<TranscriptPreview>('previewTranscript', { request });
  }

  async storeProof(tokenId: string, presentation: unknown): Promise<StoreResult> {
    return this.call<StoreResult>('storeProof', { tokenId, presentation });
  }

  private handleMessage = (event: MessageEvent): void => {
    if (event.source !== this.iframe.contentWindow) return;
    const msg = event.data;
    if (!msg || !msg.type) return;

    if (msg.type === 'result' && msg.id) {
      const pending = this.pendingCalls.get(msg.id);
      if (pending) { this.pendingCalls.delete(msg.id); pending.resolve(msg.data); }
      return;
    }

    if (msg.type === 'error' && msg.id) {
      const pending = this.pendingCalls.get(msg.id);
      if (pending) { this.pendingCalls.delete(msg.id); pending.reject(new Error(msg.message)); }
      return;
    }

    if (msg.type === 'event') {
      if (msg.event === 'tx:confirm') {
        this.handleTxConfirm(msg.id, msg.data);
        return;
      }
      const callbacks = this.listeners.get(msg.event);
      if (callbacks) {
        for (const cb of callbacks) {
          try { cb(msg.data); } catch (err) { console.error(`TlsnClient event error [${msg.event}]:`, err); }
        }
      }
    }
  };

  private async handleTxConfirm(confirmId: string, details: TransactionDetails): Promise<void> {
    let confirmed = true;
    if (this.txConfirmHandler) {
      try { confirmed = await this.txConfirmHandler(details); } catch { confirmed = false; }
    }
    this.iframe.contentWindow?.postMessage({ id: confirmId, type: 'txConfirmResponse', confirmed }, '*');
  }

  private call<T = unknown>(type: string, params: Record<string, unknown>): Promise<T> {
    if (this.destroyed) return Promise.reject(new Error('TlsnClient has been destroyed'));
    const id = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;

    return new Promise<T>((resolve, reject) => {
      const timer = setTimeout(() => {
        this.pendingCalls.delete(id);
        reject(new Error(`TlsnClient call '${type}' timed out after ${this.timeout}ms`));
      }, this.timeout);

      this.pendingCalls.set(id, {
        resolve: (value: any) => { clearTimeout(timer); resolve(value); },
        reject: (error: Error) => { clearTimeout(timer); reject(error); },
      });

      this.iframe.contentWindow?.postMessage({ id, type, ...params }, '*');
    });
  }
}