export interface CollectionDocument {
    id?: string
    insertTime?: Date
    updateTime?: Date
    [key: string]: any
}

export interface DbReadOptions {
    filter?: {
        [key: string]: any
    }
    selector?: {
        [key: string]: any
    }
    projection?: string
    offset?: number
    limit?: number
    sort?: string[]
    pipelineMod?: (pipe: { [key: string]: any }[]) => { [key: string]: any }[]
}

interface GetHookGetOnlyData {
    /**
     * true if only one document was requested via /COLLECTION/ID
     */
    one?: boolean
    /**
     * get list of documents (only valid after stage "read" in "get" hook)
     */
    results(): CollectionDocument[]
}

interface GetHookData {
    /**
     * filter map only valid for "get" hooks
     */
    filter?: {
        [key: string]: any
    }
    /**
     * selector map only valid for "get" hooks
     */
    selector?: {
        [key: string]: any
    }
    /**
     * offset only valid for "get" hooks
     */
    offset?: number
    /**
     * limit only valid for "get" hooks
     */
    limit?: number
    /**
     * sort only valid for "get" hooks
     */
    sort?: string[] | string
    /**
     * pipelineMod is a function to modify the mongodb query pipeline
     */
    pipelineMod?: (pipe: { [key: string]: any }[]) => { [key: string]: any }[]
}

interface PostHookData {
    /**
     * post data only valid in "post" and "put" hooks
     */
    data?: CollectionDocument
}

interface DbPackage {
    /**
     * read results from a collection
     *
     * @param colName collection name
     * @param options options map
     */
    find(colName: string, options?: DbReadOptions): CollectionDocument[]

    /**
     * read count of documents for filter from a collection
     *
     * @param colName collection name
     * @param options options map (only filter is valid)
     */
    count(colName: string, options?: DbReadOptions): number

    /**
     * create a document in a collection
     *
     * @param colName collection name
     * @param data data map
     */
    create(colName: string, data: CollectionDocument): CollectionDocument

    /**
     * update a document in a collection
     *
     * @param colName collection name
     * @param id id of entry
     * @param data new/changed data
     */
    update(
        colName: string,
        id: string,
        data: CollectionDocument
    ): CollectionDocument

    /**
     * deletes one document by id from collection
     *
     * @param colName collection name
     * @param id id of entry
     */
    delete(colName: string, id: string): { message: "ok" }

    /**
     * deletes documents by filter from collection
     *
     * @param colName collection name
     * @param options options map, only filter valid
     */
    deleteMany(
        colName: string,
        options?: DbReadOptions
    ): { message: "ok"; removed: number }
}

interface SmtpPackage {
    /**
     * send an email
     *
     * @param options email options map
     */
    sendMail(options: {
        to: string | string[]
        cc?: string | string[]
        bcc?: string | string[]
        subject?: string
        from: string
        fromName?: string
        replyTo?: string
        plain?: string
        html?: string
        attach?: string | string[]
    }): void
}

interface FsPackage {

    /**
     * get directory path of api config file
     * 
     */
    configPath(): string

    /**
     * read a file relative to config dir and return its content
     *
     * @param path relative file path
     * @param options optional options
     */
    readFile(path: string, options?: {
        bytes: boolean // if true return []byte instead of string
    }): string | any

    /**
     * stat file or directory
     *
     * @param path
     */
    stat(path: string): {
        name: string
        size: number
        isDir: boolean
        modTime: string
    }

    /**
     * list directory entries
     *
     * @param path
     */
    readDir(path: string): {
        name: string
        size: number
        isDir: boolean
        modTime: string
    }[]

    /**
     * make directory and all missing sub directories, no error if directory already exists
     *
     * @param path
     */
    mkDir(path: string): void

    /**
     * remove file or empty directory
     *
     * @param path
     */
    remove(path: string): void
}

interface TplPackage {
    /**
     * execute a template code and return result
     *
     * @param code template code
     * @param contextData template context map
     */
    execute(
        code: string,
        contextData?: {
            [key: string]: any
        }
    ): string
}

interface HttpPackage {
    /**
     * http request
     *
     * @param url url for request
     * @param options request options
     */
    fetch(
        url: string,
        options?: {
            method?: string
            headers?: { [key: string]: string }
            body?: string
        }
    ): {
        status: number
        statusText: string
        headers: { [key: string]: string }
        trailer: { [key: string]: string }
        url: string
        body: {
            text(): string
            json(): any
        }
    }
}

interface DebugPackage {
    /**
     * dumps data to header and server log
     *
     * @param toDump data to dump
     */
    dump(...toDump: any): void

    /**
     * get Sentry trace id
     */
    sentryTraceId(): string
}

interface ResponsePackage {
    /**
     * set response header
     *
     * @param name header name
     * @param value value
     */
    header(name: string, value: any): void
}

interface UserPackage {
    /**
     * get JWT authentication
     */
    auth(): {
        id: string
        username: string
        role: number
        permissions: string[]
    }
}

interface BcryptPackage {
    /**
     * hash password via bcrypt algo
     *
     * @param password clear text password
     * @param options hashing options
     */
    hash(
        password: string,
        options?: {
            cost?: number
        }
    ): string

    /**
     * check password against hashed password via bcrypt algo
     *
     * @param password clear text password
     * @param hash hashed password
     */
    check(password: string, hash: string): boolean
}

interface JwtPackage {
    /**
     * create a jwt signed token string
     *
     * @param claims data object
     * @param options options (secret, validityDuration = expiry in X seconds)
     */
    create(
        claims: {
            [key: string]: any
        },
        options?: {
            secret?: string
            validityDuration?: number
        }
    ): string

    /**
     * parse jwt token string
     *
     * @param token token string
     * @param options options (secret)
     */
    parse(
        token: string,
        options?: {
            secret?: string
        }
    ): {
        error?: string
        valid: boolean
        method: {
            Name: string
            Hash: number
        }
        header: {
            alg: string
            typ: string
        }
        claims: {
            exp?: number
            [key: string]: any
        }
    }
}

interface CharsetPackage {
    /**
     * convert iso8859 to utf8
     *
     * @param iso8859 iso string
     */
    iso8859ToUtf8(iso8859: string): string
}

interface ImagePackage {
    /**
     * convert image from source file to target file with filters
     *
     * @param sourceFile
     * @param targetFile
     * @param filters
     */
    filter(
        sourceFile: string,
        targetFile: string,
        filters: {
            fit?: boolean
            fill?: boolean
            width?: number
            height?: number
            brightness?: number
            saturation?: number
            contrast?: number
            gamma?: number
            blur?: number
            sharpen?: number
            invert?: boolean
            grayscale?: boolean
            quality?: number
        }[]
    ): void
}

interface XmlPackage {
    /**
     * create xml string
     *
     * @param data object or array
     * @param options options
     */
    create(data: any, options?: {}): string

    /**
     * parse xml string to json
     *
     * @param xml xml string
     * @param options options
     */
    parse(xml: string, options?: {}): any
}

interface CookiePackage {
    /**
     * get cookie from http header
     *
     * @param name cookie name
     */
    get(name: string): string

    /**
     * set cookie via http header
     *
     * @param name cookie name
     * @param value cookie value
     * @param options cookie options
     */
    set(
        name: string,
        value: string,
        options?: {
            maxAge?: number
            path?: string
            domain?: string
            secure?: boolean
            httpOnly?: boolean
        }
    ): void
}

interface PdfPackage {
    /**
     * generate pdf from html
     *
     * @param html html string
     * @param options options
     * 
     * @returns []byte of pdf data
     */
    fromHTML(
        html: string,
        options?: {
            copies?: number // Number of copies to print into the pdf file (default 1)
            dpi?: number // Change the dpi explicitly (this has no effect on X11 based systems)
            grayscale?: boolean // PDF will be generated in grayscale
            imageDpi?: number // When embedding images scale them down to this dpi (default 600)
            imageQuality?: number // When jpeg compressing images use this quality (default 94)
            lowQuality?: boolean // Generates lower quality pdf/ps. Useful to shrink the result document space
            marginBottom?: number // Set the page bottom margin
            marginLeft?: number // Set the page left margin (default 10mm)
            marginRight?: number // Set the page right margin (default 10mm)
            marginTop?: number // Set the page top margin
            noCollate?: boolean // Do not collate when printing multiple copies (default collate)
            noPdfCompression?: boolean // Do not use lossless compression on pdf objects
            orientation?: "Portrait" | "Landscape" // Set orientation to Landscape or Portrait (default Portrait)
            pageHeight?: number // Page height
            pageSize?: string // Set paper size to: A4, Letter, etc. (default A4)
            pageWidth?: number // Page width
            title?: string // The title of the generated pdf file (The title of the first document is used if not specified)
            // page settings
            printMediaType?: boolean // Use print media-type instead of screen
            footerCenter?: string // Centered footer text
            footerFontName?: string // Set footer font name (default Arial)
            footerFontSize?: number // Set footer font size (default 12)
            footerLeft?: string // Left aligned footer text
            footerLine?: boolean // Display line above the footer
            footerRight?: string // Right aligned footer text
            footerSpacing?: number // Spacing between footer and content in mm (default 0)
            footerHTML?: string // URL to footer html
            headerCenter?: string // Centered header text
            headerFontName?: string // Set header font name (default Arial)
            headerFontSize?: number // Set header font size (default 12)
            headerLeft?: string // Left aligned header text
            headerLine?: boolean // Display line below the header
            headerRight?: string // Right aligned header text
            headerSpacing?: number // Spacing between header and content in mm (default 0)
            headerHTML?: string // URL to header html
        }
    ): any

    /**
     * process existing pdf data
     * 
     * @param command pdfcpu command
     * @param pdfData []byte of pdf data, multiple []byte as array of pdf's to merge or object with description to create
     * @param options options
     * 
     * @returns []byte of new pdf data
     */
    cpu(
        command: "watermark" | "stamp" | "merge" | "rotate" | "create",
        pdfData: any | any[],
        options?: {
            pages?: (string | number)[]
            description?: {
                fontname?: string
                points?: number
                rtl?: boolean
                position?: "full" | "tl" | "tc" | "tr" | "l" | "c" | "r" | "bl" | "bc" | "br"
                offset?: string
                scalefactor?: number | string
                aligntext?: "left" | "center" | "right" | "justified"
                strokecolor?: string
                fillcolor?: string
                backgroundcolor?: string
                rotation?: number
                diagonal?: 1|2
                opacity?: number
                rendermode?: 0|1|2
                margins?: number | string
                border?: number | string
                url?: string
            }
            mode?: "text" | "image" | "pdf"
            bytes?: any // []byte of watermark image
            file?: string // file for pdf watermark
            text?: string // text for text watermark
            rotation?: number
        }
    ): any
}

export interface HookContext
    extends GetHookData,
        GetHookGetOnlyData,
        PostHookData {
    request(): {
        method: string
        remoteAddr: string
        host: string
        url: string
        path: string
        param(p: string): string
        query(q: string): string
        header(h: string): string
        body(): string
        /**
         * bodyBytes return []byte go slice of post body for later use pe. in iso8859ToUtf8
         */
        bodyBytes(): string
    }

    db: DbPackage
    smtp: SmtpPackage
    fs: FsPackage
    tpl: TplPackage
    http: HttpPackage
    debug: DebugPackage
    response: ResponsePackage
    user: UserPackage
    bcrypt: BcryptPackage
    jwt: JwtPackage
    charset: CharsetPackage
    image: ImagePackage
    xml: XmlPackage
    cookie: CookiePackage
    pdf: PdfPackage
}

export interface HookException {
    status?: number
    html?: string
    string?: string
    bytes?: any
    file?: string
    [key: string]: any
}

export interface HookResponse extends GetHookData, PostHookData {
    data?: CollectionDocument
    results?: any
}

declare global {
    var context: HookContext
}