import {
    type IEither,
    isEither,
    type ITraceable,
    Metric,
    type PenguenoRequest,
    type ServerTrace,
} from '@emprespresso/pengueno';

export type BodyInit =
    | ArrayBuffer
    | AsyncIterable<Uint8Array>
    | Blob
    | FormData
    | Iterable<Uint8Array>
    | NodeJS.ArrayBufferView
    | URLSearchParams
    | null
    | string;
export type ResponseBody = object | string;
export type TResponseInit = Omit<ResponseInit, 'headers'> & {
    status: number;
    headers?: Record<string, string>;
};

const getResponse = (req: PenguenoRequest, opts: TResponseInit): ResponseInit => {
    const baseHeaders = req.baseResponseHeaders();
    const optHeaders = opts.headers || {};

    return {
        ...opts,
        headers: {
            ...baseHeaders,
            ...optHeaders,
            'Content-Type': (optHeaders['Content-Type'] ?? 'text/plain') + '; charset=utf-8',
        } as Record<string, string>,
    };
};

const ResponseCodeMetrics = [0, 1, 2, 3, 4, 5].map((x) => Metric.fromName(`response.${x}xx`));
export const getResponseMetrics = (status: number) => {
    const index = Math.floor(status / 100);
    return ResponseCodeMetrics.map((metric, i) => metric.count.withValue(i === index ? 1.0 : 0.0));
};

export class PenguenoResponse extends Response {
    constructor(req: ITraceable<PenguenoRequest, ServerTrace>, msg: BodyInit, opts: TResponseInit) {
        const responseOpts = getResponse(req.get(), opts);
        for (const metric of getResponseMetrics(opts.status)) {
            req.trace.trace(metric);
        }
        super(msg, responseOpts);
    }
}

export class JsonResponse extends PenguenoResponse {
    constructor(
        req: ITraceable<PenguenoRequest, ServerTrace>,
        e: BodyInit | IEither<ResponseBody, ResponseBody>,
        opts: TResponseInit,
    ) {
        const optsWithJsonContentType: TResponseInit = {
            ...opts,
            headers: {
                ...opts.headers,
                'Content-Type': 'application/json',
            },
        };
        if (isEither<ResponseBody, ResponseBody>(e)) {
            super(
                req,
                JSON.stringify(e.fold(({ isLeft, value }) => (isLeft ? { error: value } : { ok: value }))),
                optsWithJsonContentType,
            );
            return;
        }
        super(
            req,
            JSON.stringify(Math.floor(opts.status / 100) > 4 ? { error: e } : { ok: e }),
            optsWithJsonContentType,
        );
    }
}