import { DatagramShort, isRequest, isResponse, CResponse } from "../../Independents/Datagram/datagram.js";
import { convertHeaders, mimeType } from "../communication/HttpTransport.js";
import { Datagram } from "../../Independents/Datagram/datagram-types.js";
import { decodeBody } from "./EncodeDecodeMessage.js";
import { Transport } from "./Transport.js";
import { RouteDatagram } from "../datagram-routing.js";
import { Gateway } from "../Gateway.js";

export class HttpBrowserTransport extends Transport {
    get isClosed() {
        return false;
    }

    close() {
    }

    async transmitDatagram(datagram: Datagram) {
        if (isResponse(datagram)) {
            throw new Error(`Http browser Transport cannot provide response`)
            return;
        }
        if (isRequest(datagram)) {
            this.employer.gateway.state.log("HttpOut", DatagramShort(datagram));
            try {
                let url = datagram.url ?? `http://${datagram.to}${datagram.path}`;
                //console.log(`REACHING OUT TO HTTP FETCH USING ${url}`, datagram);
                let res = await fetch(url, {
                    method: datagram.method,
                    headers: datagram.headers
                })
                await res;
                if (res.status == 502) {
                    let roots = res.headers.get("burparoots");
                    if (roots) {
                        let pr = roots.split(",");
                        let state = this.employer.gateway.state;
                        if (!state.whole.persistent.rootHost) {
                            state.whole.persistent.rootHost = pr[0];
                        }
                        if (!state.whole.persistent.rootGateway) {
                            state.whole.persistent.rootGateway = pr[1];
                        }

                        console.warn(`Discovered that receiver ${datagram.to} is not an external http host but should be a burpanet host`)
                        datagram.trail = [];
                        const lgw = state.LocalGateway();
                        await lgw.registerAtUpstream(state.whole.persistent.rootGateway);
                        RouteDatagram(state, datagram);
                    }
                }
                let blob = await res.blob();
                let buff = await blob.arrayBuffer();
                let type = mimeType(res.headers.get("content-type"));
                let body = decodeBody(buff, type);
                let resp = new CResponse({
                    from: datagram.to,
                    to: datagram.from,
                    port: datagram.port,
                    reqno: datagram.reqno,
                    headers: convertHeaders(res.headers),
                    body,
                    status: res.status,
                }, datagram);
                //console.warn("response", resp);
                RouteDatagram(this.employer.gateway.state, resp);
            }
            catch (e) {
                console.error(e);
            }
            return;
        }
        throw new Error(`Http browser Transport ${DatagramShort(datagram)}`);
    }

}