import { urlJoin, defer, jsonToString, stringToJson, IRequest, IRequestBase, IRequestInit, IInterceptors, IUrl, IObject, IRequestBody, IRequestOptions } from "./index.js"
import { request } from "http"
import { parse } from "url"
class Interceptors implements IInterceptors {
    private requestSuccess: Function
    private responseSuccess: Function
    private error: Function
    use(type, fn) {
        switch (type) {
            case "request":
                this.requestSuccess = fn
                break;
            case "response":
                this.responseSuccess = fn
                break;
            case "error":
                this.error = fn
                break;
        }
        return this
    }
    get reqFn() {
        return this.requestSuccess
    }
    get resFn() {
        return this.responseSuccess
    }
    get errFn() {
        return this.error
    }
}
abstract class RequestBase extends Interceptors implements IRequestBase {
    readonly origin: string
    constructor(origin) {
        super()
        this.origin = origin ?? ''
    }
    abstract fetch(url, opts): Promise<void>
    abstract http(url, opts): Promise<void>

    chackUrl = (url: string) => {
        return url.startsWith('/')
    }

    fixOrigin = (fixStr: string) => {
        if (this.chackUrl(fixStr)) return this.origin + fixStr
        return fixStr
    }

    envDesc = () => {
        if (typeof Window !== "undefined") {
            return "Window"
        }
        return "Node"
    }

    errorFn = reject => err => reject(this.errFn?.(err) ?? err)

    clearTimer = opts => !!opts.timer && (clearTimeout(opts.timer), opts.timer = null)

    initAbort = (params) => {
        const { controller, timer, timeout } = params
        !!!timer && (params.timer = setTimeout(() => controller.abort(), timeout))
        return params
    }

    requestType = () => {
        switch (this.envDesc()) {
            case "Window":
                return this.fetch
            case "Node":
                return this.http
        }
    }

    getDataByType = (type, response) => {
        switch (type) {
            case "text":
            case "json":
            case "blob":
            case "formData":
            case "arrayBuffer":
                return response[type]()
            default:
                return response['json']()
        }
    }
    formatBodyString = (bodyString) => {
        return {
            text: () => bodyString,
            json: () => stringToJson(bodyString) ?? bodyString,
            blob: () => stringToJson(bodyString),
            formData: () => stringToJson(bodyString),
            arrayBuffer: () => stringToJson(bodyString),
        }
    }

}
abstract class RequestInit extends RequestBase implements IRequestInit {
    constructor(origin) {
        super(origin)
    }
    abstract fetch(url, opts): Promise<void>
    abstract http(url, opts): Promise<void>
    initDefaultParams = (url, { method = "GET", query = {}, headers = {}, body = null, timeout = 30 * 1000, controller = new AbortController(), type = "json", ...others }) => ({
        url: urlJoin(this.fixOrigin(url), query), method, headers, body: method === "GET" ? null : jsonToString(body), timeout, signal: controller?.signal, controller, type, timer: null, ...others
    })

    initFetchParams = (url, opts) => {
        const params = this.initAbort(this.initDefaultParams(url, opts))
        return this.reqFn?.(params) ?? params
    }

    initHttpParams = (url, opts) => {
        const params = this.initAbort(this.initDefaultParams(url, opts))
        const options = parse(params.url, true)
        return this.reqFn?.({ ...params, ...options }) ?? { ...params, ...options }
    }
}
export class Request extends RequestInit implements IRequest {
    private request: Function
    constructor(origin) {
        super(origin)
        this.request = this.requestType()
    }

    fetch = (_url, _opts) => {
        const { promise, resolve, reject } = defer()
        const { url, ...opts } = this.initFetchParams(_url, _opts)
        const { signal } = opts
        promise.finally(() => this.clearTimer(opts))
        signal.addEventListener('abort', () => this.errorFn(reject));
        fetch(url, opts).then((response) => {
            if (response?.status >= 200 && response?.status < 300) {
                return this.getDataByType(opts.type, response)
            }
            return this.errorFn(reject)
        }).then(res => resolve(this.resFn?.(res) ?? res)).catch(this.errorFn(reject))
        return promise
    }

    http = (_url, _opts) => {
        const { promise, resolve, reject } = defer()
        const params = this.initHttpParams(_url, _opts)
        const { signal } = params
        promise.finally(() => this.clearTimer(params))
        const req = request(params, (response) => {
            if (response?.statusCode >= 200 && response?.statusCode < 300) {
                let data = "";
                response.setEncoding('utf8');
                response.on('data', (chunk) => data += chunk);
                return response.on("end", () => {
                    const result = this.getDataByType(params.type, this.formatBodyString(data))
                    resolve(this.resFn?.(result) ?? result)
                });
            }
            return this.errorFn(reject)(response?.statusMessage)
        })
        signal.addEventListener('abort', () => this.errorFn(reject)(req.destroy(new Error('request timeout'))));
        req.on('error', this.errorFn(reject));
        req.end();
        return promise
    }

    GET = (url?: IUrl, query?: IObject<any>, _?: IRequestBody | void, opts?: IRequestOptions) => {
        return this.request(url, { query, method: "GET", ...opts })
    }

    POST = (url?: IUrl, query?: IObject<any>, body?: IRequestBody, opts?: IRequestOptions) => {
        return this.request(url, { query, method: "POST", body, ...opts })
    }

    PUT = (url?: IUrl, query?: IObject<any>, body?: IRequestBody, opts?: IRequestOptions) => {
        return this.request(url, { query, method: "PUT", body, ...opts })
    }

    DELETE = (url?: IUrl, query?: IObject<any>, body?: IRequestBody, opts?: IRequestOptions) => {
        return this.request(url, { query, method: "DELETE", body, ...opts })
    }

    OPTIONS = (url?: IUrl, query?: IObject<any>, body?: IRequestBody, opts?: IRequestOptions) => {
        return this.request(url, { query, method: "OPTIONS", body, ...opts })
    }

    HEAD = (url?: IUrl, query?: IObject<any>, body?: IRequestBody, opts?: IRequestOptions) => {
        return this.request(url, { query, method: "HEAD", body, ...opts })
    }

    PATCH = (url?: IUrl, query?: IObject<any>, body?: IRequestBody, opts?: IRequestOptions) => {
        return this.request(url, { query, method: "PATCH", body, ...opts })
    }
}