/**
 * @license
 * Copyright 2022-2026 Matter.js Authors
 * SPDX-License-Identifier: Apache-2.0
 */

import { Bytes, Channel, ChannelType, ConnectedChannel, Duration, Observable, Transport } from "@matter/general";
import { Scanner } from "../common/Scanner.js";
import { PeerCommunicationError } from "../peer/PeerCommunicationError.js";
import { MatterBle } from "./BleConsts.js";

export class BleError extends PeerCommunicationError {}

/** Thrown when a BLE write or subscribe operation fails because the peripheral disconnected. */
export class BleDisconnectedError extends BleError {}

/**
 * Fired as the `cause` when the BLE transport under a PASE session closes, triggering a
 * force-close of the session so pending exchanges reject immediately instead of waiting
 * for MRP timeouts.
 */
export class BleChannelClosedError extends BleDisconnectedError {}

// TODO - need to factor out the general platform BLE from Matter/BTP so this can move into matter.js-general
export abstract class Ble {
    abstract get peripheralInterface(): BlePeripheralInterface;
    abstract get centralInterface(): Transport;
    abstract get scanner(): Scanner;
}

export interface BlePeripheralInterface extends Transport {
    advertise(advertiseData: Bytes, additionalAdvertisementData?: Bytes, interval?: Duration): Promise<void>;
    stopAdvertising(): Promise<void>;
}

export abstract class BleChannel<T extends Bytes = Bytes> implements Channel<T>, ConnectedChannel {
    readonly maxPayloadSize = MatterBle.MAX_MATTER_PAYLOAD_SIZE;
    readonly isReliable = true as const;
    readonly supportsLargeMessages = false;
    readonly type = ChannelType.BLE;

    abstract name: string;
    abstract send(data: T): Promise<void>;
    abstract close(): Promise<void>;
    abstract onClose(listener: () => void): Transport.Listener;
    abstract [Symbol.asyncIterator](): AsyncIterator<Bytes>;

    readonly #closed = Observable<[]>();
    #closedFired = false;

    /**
     * Emitted exactly once when the channel is lost (peripheral disconnect, BTP session close,
     * or explicit {@link close}).  Consumers that hold a secure session over this channel use
     * this to force-close the session and reject pending exchanges without waiting for MRP
     * timeouts.
     *
     * Subclasses must call {@link emitClosed} from each of their termination paths.  The
     * latch guarantees exactly-once semantics regardless of which triggers fire.
     */
    get closed() {
        return this.#closed;
    }

    protected emitClosed() {
        if (this.#closedFired) {
            return;
        }
        this.#closedFired = true;
        this.#closed.emit();
    }
}