// #!/usr/bin/env babel-node
// -*- coding: utf-8 -*-
/** @module web-documentation */
'use strict'
/* !
    region header
    [Project page](https://github.com/web-documentation)

    Copyright Torben Sickert (info["~at~"]tsickert.com) 16.12.2012

    License
    -------

    This library written by Torben Sickert stands under a creative commons
    naming 3.0 unported license.
    See https://creativecommons.org/licenses/by/3.0/deed.de
    endregion
*/
// region imports
import type {Mapping} from 'clientnode'
import type {WebComponentAPI} from 'web-component-wrapper/type'

import type {DefaultOptions, Options} from './type'

import {
    camelCaseToDelimited,
    closest,
    createDomNodes,
    extend,
    format,
    getAll,
    getText,
    globalContext,
    interruptableScrollTo,
    Logger,
    NOOP,
    wrap
} from 'clientnode'
import {func, object} from 'clientnode/property-types'
import {property} from 'web-component-wrapper/decorator'
import {Web} from 'web-component-wrapper/Web'
import {api as websiteUtilitiesAPI} from 'website-utilities'
import {api as webInternationalizationAPI} from 'web-internationalization'
// endregion
export const log = new Logger({name: 'web-documentation'})
// region plugins/classes
/**
 * This plugin holds all needed methods to extend a whole documentation site.
 * @property _defaultOptions - Options extended by the options given to the
 * initializer method.
 * @property _defaultOptions.selectors - Object with a mapping of needed dom
 * node descriptions to their corresponding selectors.
 * @property _defaultOptions.showExample - Options object to configure code
 * example representation.
 * @property _defaultOptions.showExample.pattern - Regular expression to
 * introduce a code example section.
 * @property _defaultOptions.showExample.domNodeName - Dom node name to
 * indicate a declarative example section.
 * @property _defaultOptions.showExample.htmlWrapper - HTML example wrapper.
 * @property _defaultOptions.section - Configuration object for section
 * switches between the main page and legal notes descriptions.
 * @property self - Reference to this class.
 * @property doRender - Indicates that this components should evaluate given
 * body content.
 * @property options - Finally configured given options.
 */
export class WebDocumentation<
    TElement = HTMLElement,
    ExternalProperties extends Mapping<unknown> = Mapping<unknown>,
    InternalProperties extends Mapping<unknown> = Mapping<unknown>
> extends Web<TElement, ExternalProperties, InternalProperties> {
    static content = `
        <website-utilities
            options="{sectionNames: {
                default: 'home',
                managed: ['home', 'about-this-website']
            }}"
        >
            <web-internationalization
                options="{selectors: {
                    knownTranslation: '.wd-table-of-contents ul li'
                }}"
            >
                <slot>Please provide a template to transclude.</slot>
            </web-internationalization>
        </website-utilities>
    `

    static _name = 'WebDocumentation'

    static _defaultOptions: DefaultOptions = {
        selectors: {
            aboutThisWebsiteLink: 'a[href="#about-this-website"]',
            aboutThisWebsiteSection: '.wd-section__about-this-website',

            codeWrapper: 'pre',
            code: 'code',

            headlines:
                '.wd-section__home h1, .wd-section__home h2, ' +
                '.wd-section__home h3, .wd-section__home h4, ' +
                '.wd-section__home h5, .wd-section__home h6',
            tableOfContent: '.wd-table-of-contents',
            tableOfContentLinks: '.wd-table-of-contents ul li a[href^="#"]'
        },

        showExample: {
            domNodeName: '#comment',
            htmlWrapper: `
                <div class="wd-show-example-wrapper">
                    <h3>
                        Example:
                        <!--deDE:Beispiel:-->
                        <!--frFR:Exemple:-->
                    </h3>
                    {1}
                </div>
            `,
            pattern: '^ *showExample(: *([^ ]+))? *$'
        }
    }

    static doRender = true

    readonly self = WebDocumentation
    // region api properties
    @property({type: object})
        options = {} as Options
    @property({type: func})
        onExamplesLoaded: (this: WebDocumentation) => void = NOOP
    // endregion
    // region domNodes
    aboutThisWebsiteLinkDomNodes: NodeListOf<HTMLElement> | null = null
    aboutThisWebsiteSectionDomNode: HTMLDivElement | null = null

    codeDomNodes: NodeListOf<HTMLElement> | null = null

    headlineDomNodes: NodeListOf<HTMLElement> | null = null
    tableOfContentDomNode: HTMLElement | null = null
    tableOfContentLinkDomNodes: NodeListOf<HTMLAnchorElement> | null = null
    // endregion
    // region public
    /// region live-cycle
    /**
     * Defines dynamic getter and setter interface and resolves configuration
     * object. Initializes the map implementation.
     */
    constructor() {
        super()
        /*
            Babels property declaration transformation overwrites defined
            properties at the end of an implicit constructor. So we have to
            redefined them as long as we want to declare expected component
            interface properties to enable static type checks.
        */
        this.defineGetterAndSetterInterface()
    }
    /**
     * Triggered when ever a given attribute has changed and triggers to update
     * configured dom content.
     * @param name - Attribute name which was updates.
     * @param newValue - New updated value.
     * @returns A promise resolving when attribute has been updated.
     */
    async onUpdateAttribute(name: string, newValue: string): Promise<void> {
        await super.onUpdateAttribute(name, newValue)

        if (name === 'options')
            this._extendOptions()
    }
    /**
     * Updates controlled dom elements.
     * @param reason - Why an update has been triggered.
     * @param resolveRendering - Indicates whether rendering should be resolved
     * finally. Should be set to "false" via super calls in inherited render
     * methods which do further dom manipulations afterward and resolve the
     * rendering process by their own.
     * @returns A promise resolving when rendering has finished. A promise may
     * be needed for classes inheriting from this class.
     */
    async render(reason = 'unknown', resolveRendering = true): Promise<void> {
        await super.render(reason, false)

        if (Object.keys(this.options).length === 0)
            this._extendOptions()

        await this.waitForNestedComponentRendering()

        this.grabDomNodes()

        /*
            NOTE: We have to render examples first to avoid having dots in
            example code.
        */
        await this._showExamples()

        this._makeCodeEllipsis()

        this._generateTableOfContentsLinks()

        await this.resolveRenderingPromiseIfSet(reason, resolveRendering)
    }
    /// endregion
    grabDomNodes(): void {
        this.aboutThisWebsiteLinkDomNodes = this.hostDomNode.querySelectorAll(
            this.options.selectors.aboutThisWebsiteLink
        )
        this.aboutThisWebsiteSectionDomNode = this.hostDomNode.querySelector(
            this.options.selectors.aboutThisWebsiteSection
        )

        this.codeDomNodes =
            this.hostDomNode.querySelectorAll(this.options.selectors.code)

        this.headlineDomNodes =
            this.hostDomNode.querySelectorAll(this.options.selectors.headlines)
        this.tableOfContentDomNode = this.hostDomNode.querySelector(
            this.options.selectors.tableOfContent
        )
    }
    // endregion
    // region protected methods
    /**
     * Extends given options by default options.
     */
    _extendOptions() {
        /*
            NOTE: Using the internal setter avoids to trigger an additinal
            rendering.
        */
        this.setPropertyValue(
            'options',
            extend<Options>(true, {}, this.self._defaultOptions, this.options)
        )
    }
    /**
     * Generates a table of contents via creating links referring to headlines.
     */
    _generateTableOfContentsLinks(): void {
        if (!this.tableOfContentDomNode)
            return

        let listItemsHTML = ''

        let level = 0
        let firstLevel = 0
        let first = true

        for (const domNode of this.headlineDomNodes ?? []) {
            if (closest(domNode, '.show-example-wrapper'))
                return

            const newLevel: number =
                parseInt(domNode.nodeName.replace(/\D/g, ''))

            if (first)
                firstLevel = newLevel

            if (newLevel > level)
                listItemsHTML += '<ul>'
            else if (newLevel < level)
                listItemsHTML += '</ul>'

            listItemsHTML += `
                <li>
                    <a href="#${domNode.getAttribute('id') ?? 'unknown'}">
                        ${domNode.innerText}
                    </a>
                </li>
            `

            level = newLevel
            first = false
        }
        // Close remaining inner lists.
        while (level < firstLevel) {
            listItemsHTML += '</ul>'
            level += 1
        }

        for (const domNode of this.tableOfContentDomNode.childNodes)
            if (
                domNode.nodeType === Node.COMMENT_NODE &&
                domNode.nodeValue === 'wd-table-of-contents'
            ) {
                domNode.after(createDomNodes(listItemsHTML))
                domNode.remove()
            }

        this.tableOfContentLinkDomNodes =
            this.tableOfContentDomNode.querySelectorAll<HTMLAnchorElement>(
                this.options.selectors.tableOfContentLinks
            )

        for (const domNode of this.tableOfContentLinkDomNodes)
            this.addSecureEventListener(
                domNode,
                'click',
                (event) => {
                    event.preventDefault()

                    const selector =
                        (event.target as Element | null)?.getAttribute('href')
                    if (selector) {
                        const targetDomNode =
                            this.hostDomNode.querySelector(selector)
                        if (targetDomNode)
                            interruptableScrollTo({targetDomNode})
                    }
                }
            )

        if (this.tableOfContentDomNode.style.display === 'none')
            this.tableOfContentDomNode.style.display = 'initial'
    }
    /**
     * This method makes dotes after code lines which are too long. This
     * prevents line wrapping.
     */
    _makeCodeEllipsis(): void {
        const lengthLimit = 89 // 79

        for (const domNode of this.codeDomNodes ?? []) {
            let newContent = ''
            const codeLines: Array<string> = domNode.innerHTML.split('\n')

            let subIndex = 0
            for (const value of codeLines) {
                /*
                    NOTE: Wrap a div object to grantee that $ will accept the
                    input.
                */
                const excess: number =
                    getText(createDomNodes(`<div>${value}</div>`)).length -
                    lengthLimit
                if (excess > 0)
                    newContent += this._replaceExcessWithDots(value, excess)
                else
                    newContent += value
                if (subIndex + 1 !== codeLines.length)
                    newContent += '\n'

                subIndex += 1
            }

            domNode.innerHTML = newContent
        }
    }
    /**
     * Replaces given html content with a shorter version trimmed by given
     * amount of excess.
     * @param content - String to trim.
     * @param excess - Amount of excess.
     * @returns Returns the trimmed content.
     */
    _replaceExcessWithDots(content: string, excess: number): string {
        // Add space for ending dots.
        excess += '...'.length
        let newContent = ''
        const contentDomNodes =
            getAll(createDomNodes(`<wrapper>${content}</wrapper>`))
        contentDomNodes.reverse()
        for (const domNode of contentDomNodes) {
            const wrapper = createDomNodes<HTMLElement>('<wrapper><wrapper>')
            wrap(domNode, wrapper)

            const textContent = domNode.textContent || ''

            let contentSnippet = wrapper.innerHTML
            if (!contentSnippet)
                contentSnippet = textContent

            if (excess)
                if (textContent.length < excess) {
                    excess -= textContent.length
                    contentSnippet = ''
                } else if (textContent.length >= excess) {
                    /*
                        NOTE: We have to ensure that no HTML tag will be
                        shortened: We work on "textContent" property only.
                    */
                    domNode.textContent =
                        textContent.substring(
                            0, textContent.length - excess - 1
                        ) +
                        '...'

                    excess = 0

                    contentSnippet = wrapper.innerHTML
                    if (!contentSnippet)
                        contentSnippet = domNode.textContent
                }
            newContent = contentSnippet + newContent
        }

        return newContent
    }
    /**
     * Shows marked example codes directly in browser.
     */
    async _showExamples(): Promise<void> {
        for (const domNode of getAll(this.hostDomNode))
            if (domNode.nodeName === this.options.showExample.domNodeName) {
                const match: null | RegExpMatchArray =
                    (domNode.textContent || '').match(
                        new RegExp(this.options.showExample.pattern)
                    )
                const codeDomNode = domNode.nextSibling as HTMLElement | null
                if (match && codeDomNode) {
                    const codeWrapper: HTMLElement | null =
                        codeDomNode.querySelector(
                            this.options.selectors.codeWrapper
                        )
                    let code = codeWrapper?.innerText

                    if (!code)
                        code = codeDomNode.innerText

                    try {
                        let domNode: HTMLElement | null = null
                        let reInjectScripts = false
                        if (match.length > 2 && match[2])
                            if (
                                ['javascript', 'javascripts', 'js']
                                    .includes(match[2].toLowerCase())
                            ) {
                                /*
                                    NOTE: We're using a data URI to import the
                                    code as a module.
                                */
                                const encodedCode =
                                    encodeURIComponent(code)
                                const dataURI =
                                    'data:text/javascript;charset=utf-8,' +
                                    encodedCode
                                try {
                                    await import(
                                        /* webpackIgnore: true */
                                        dataURI
                                    )
                                } catch (error) {
                                    void log.warn(
                                        'Error occurred during running ' +
                                        `code "${code}":`,
                                        error
                                    )
                                }
                            } else if ([
                                'css', 'cascadingstylesheet',
                                'cascadingstylesheets', 'stylesheet',
                                'stylesheets', 'sheet', 'sheets', 'style',
                                'styles'
                            ].includes(match[2].toLowerCase())) {
                                domNode = (globalContext.document as Document)
                                    .createElement('style')
                                domNode.setAttribute('type', 'text/css')
                                domNode.innerText = code
                            } else if (match[2].toLowerCase() === 'hidden') {
                                domNode = createDomNodes(code)
                                reInjectScripts = true
                            } else {
                                domNode = createDomNodes(format(
                                    this.options.showExample.htmlWrapper, code
                                ))
                                reInjectScripts = true
                            }
                        else {
                            domNode = createDomNodes(format(
                                this.options.showExample.htmlWrapper, code
                            ))
                            reInjectScripts = true
                        }

                        if (domNode) {
                            codeDomNode.after(domNode)

                            if (reInjectScripts)
                                /*
                                    Injected script tags are not executed by
                                    default. So we need to reinject those.
                                */
                                for (const scriptDomNode of
                                    domNode.querySelectorAll('script')
                                ) {
                                    const newScriptDomNode =
                                        document.createElement('script')
                                    for (const name of
                                        scriptDomNode.getAttributeNames()
                                    )
                                        newScriptDomNode.setAttribute(
                                            name,
                                            scriptDomNode.getAttribute(name) as
                                                string
                                        )
                                    newScriptDomNode.textContent =
                                        scriptDomNode.textContent
                                    /*
                                        NOTE: Inline scripts are executed
                                        synchronously while being inserted and
                                        never fire a "load" (or "error") event.
                                        So we have to wait for externally
                                        referenced scripts only. Waiting for an
                                        inline script would block forever.
                                    */
                                    const scriptFilePath =
                                        newScriptDomNode.getAttribute('src')
                                    /*
                                        NOTE: A script which was never inserted
                                        will never be loaded. So we have
                                        nothing to wait for.
                                    */
                                    if (!scriptDomNode.parentNode) {
                                        void log.warn(
                                            'Skipping example script ' +
                                            `"${scriptFilePath ?? 'inline'}" ` +
                                            'since it is not part of the ' +
                                            'document anymore.'
                                        )

                                        continue
                                    }
                                    let promise = Promise.resolve()
                                    if (scriptFilePath) {
                                        const errorMessage =
                                            'Failed to load example script ' +
                                            `"${scriptFilePath}".`
                                        promise = new Promise<void>((
                                            resolve, reject
                                        ) => {
                                            newScriptDomNode.addEventListener(
                                                'load',
                                                () => {
                                                    resolve()
                                                }
                                            )
                                            newScriptDomNode.addEventListener(
                                                'error',
                                                () => {
                                                    reject(new Error(
                                                        errorMessage
                                                    ))
                                                }
                                            )
                                        })
                                    }

                                    scriptDomNode.parentNode.replaceChild(
                                        newScriptDomNode, scriptDomNode
                                    )

                                    await promise
                                }
                        }
                    } catch (error) {
                        void log.critical(
                            `Error while integrating code "${code}":`,
                            String(error)
                        )

                        throw error
                    }
                }
            }

        this.onExamplesLoaded()
    }
    // endregion
}
// endregion
export const api: WebComponentAPI<
    HTMLElement, Mapping<unknown>, Mapping<unknown>, typeof Web
> = {
    component: WebDocumentation,
    register: (
        tagName: string = camelCaseToDelimited(WebDocumentation._name)
    ) => {
        websiteUtilitiesAPI.register()
        webInternationalizationAPI.register()

        customElements.define(tagName, WebDocumentation)
    }
}
export default WebDocumentation

if ((globalContext as Mapping<boolean>).AUTO_DEFINE_WEB_DOCUMENTATION)
    api.register()
