/**
 * Defines usefull default text styles.
 */
export class FontInfo {

    static get small() {
        return app.theme.textStyleSmall
    }

    static get normal() {
        return app.theme.textStyle
    }

    static get centered() {
        return Object.assign({}, app.theme.textStyle, { align: 'center' })
    }
}

/**
 * Static methods to support hyphenation of lines.
 * 
 * @class Hypenate
 */
export class Hypenate {

    static splitPart(part) {
        let parts = part.split('-')
        if (parts.length == 1)
            return [part]
        let result = []
        let last = parts.pop()
        for (let p of parts) {
            result.push(p + '-')
        }
        result.push(last)
        return result.filter(p => p.length > 0)
    }

    static splitWord(word) {
        if (typeof (language) == 'undefined') {
            if (word.indexOf('-') > -1) {
                return word.split('-')
            }
            return [word]
        }
        let parts = language.hyphenate(word)
        let result = []
        for (let part of parts) {
            for (let splitted of this.splitPart(part)) {
                result.push(splitted)
            }
        }
        return result
    }

    static abbreviateLine(label, style, width) {
        const pixiStyle = new PIXI.TextStyle(style)   
        let metrics = PIXI.TextMetrics.measureText(label, pixiStyle)
        while(metrics.width > width && label.length > 3) {
            label = label.slice(0, label.length-1)
            metrics = PIXI.TextMetrics.measureText(label, pixiStyle)
        }
        label = label.slice(0, label.length-1)
        return label + '…'
    }

    static splitLine(line, pixiStyle, width, space, minus) {
        let x = 0
        let result = ''
        let words = line.split(' ')
        for (let word of words) {
            let wordMetrics = PIXI.TextMetrics.measureText(word, pixiStyle)
            if (x + wordMetrics.width >= width) {
                let parts = this.splitWord(word)
                let newWord = ''
                if (parts.length == 1) {
                    newWord += '\n' + word + ' '
                    x = wordMetrics.width + space.width
                }
                else {
                    let first = true
                    let lastPart = ''
                    for (let part of parts) {
                        let partMetrics = PIXI.TextMetrics.measureText(part, pixiStyle)
                        if (x + partMetrics.width + space.width > width) {
                            newWord += ((first || lastPart.endsWith('-')) ? '\n' : '-\n') + part
                            x = partMetrics.width
                        }
                        else {
                            newWord += part
                            x += partMetrics.width
                        }
                        lastPart = part
                        first = false
                    }
                    x += space.width
                }
                result += newWord + ' '
            }
            else {
                result += word + ' '
                x += wordMetrics.width + space.width
            }
        }
        return result
    }

    /**
     *  Main method and entry point for text hyphenation 
     *
     * @static
     * @param {*} text
     * @param {*} style
     * @param {*} width
     * @returns
     * @memberof Hypenate
     */
    static splitLines(text, style, width) {
        const pixiStyle = new PIXI.TextStyle(style)
        const lines = text.split('\n')
        const space = PIXI.TextMetrics.measureText(' ', pixiStyle)
        const minus = PIXI.TextMetrics.measureText('-', pixiStyle)
        let result = []
        for (let line of lines) {
            result.push(this.splitLine(line, pixiStyle, width, space, minus))
        }
        return result.join('\n')
    }
}

class TextLabel extends PIXI.Text {

    /**
     *Creates an instance of TextLabel.
     * @param {string} text - The string that you would like the text to display
     * @param {object PIXI.TextStyle optional} style - The style parameters 
     * @param {canvas} 
     * @memberof TextLabel
     */
    constructor(text, style=null, canvas=null, { minZoom = 0.1, maxZoom = 10} = {}) {
        super(text, style, canvas )
        this.normFontSize = this.style.fontSize 
        this.minZoom = minZoom
        this.maxZoom = maxZoom
    }

    zoom(factor) {
        let oldValue = parseFloat(this.style.fontSize) / this.normFontSize
        let value = oldValue * factor
        this.setZoom(value)
    }

    setZoom(value) {
        let oldValue = parseFloat(this.style.fontSize) / this.normFontSize
        if (value > this.maxZoom) {
            value = this.maxZoom
        }
        if (value < this.minZoom) {
            value = this.minZoom
        }
        if (value != oldValue) {
            this.style.fontSize = Math.max(value * this.normFontSize, 1)
        }
    }

    setZoomAndScale(scale) {
        this.scale.set(1 / scale)
        this.setZoom(scale)
    }
}

/**
 * A specialization of the PIXI.Graphics class that allows to
 * resuse and place labels across different layout variants
 *
 * @export
 * @class LabeledGraphics
 * @extends {PIXI.Graphics}
 */
export class LabeledGraphics extends PIXI.Graphics {

    /**
     * Creates an instance of LabeledGraphics and defines a local label cache.
     * 
     * @memberof LabeledGraphics
     */
    constructor() {
        super()
        this.labels = new Map()
    }

    _createText(label, fontInfo) {
        return new TextLabel(label, fontInfo)
    }

    
    /**
     * Main additional method. Ensures that a text object is created that is cached
     * under the given key.
     *
     * @param {*} key - The cache key
     * @param {*} label - The label to show
     * @param {*} [attrs={}] - Defines attributes of the text object. 
     *                               align: 'right', 'left', or 'center'
     *                               justify: 'top', 'bottom', or 'center'
     *                               maxLines: {integer} truncates the text and adds ellipsis
     *                               maxHeight: {number} truncates text that needs more space and adds ellipsis
     *                               maxWidth: {number} word wraps text using hyphenation if possible
     * @param {*} [fontInfo=FontInfo.normal] - Defines PIXI.TextStyle attributes
     * @returns {PIXI.Text} instance
     * @memberof LabeledGraphics
     */
    ensureLabel(key, label, attrs = {}, fontInfo = FontInfo.normal) {

        if (attrs.maxWidth && attrs.maxLines == 1) {
            label = Hypenate.abbreviateLine(label, fontInfo, attrs.maxWidth)
        }
        else {
            if (attrs.maxWidth) {
                label = Hypenate.splitLines(label, fontInfo, attrs.maxWidth)
            }
            if (attrs.maxLines) {
                label = this.truncateLabel(label, fontInfo, attrs.maxLines)
            }
            if (attrs.maxHeight) {
                let styleInfo = new PIXI.TextStyle(fontInfo)
                let metrics = PIXI.TextMetrics.measureText(label, styleInfo)
                let maxLines = Math.max(attrs.maxHeight / metrics.lineHeight, 1)
                label = this.truncateLabel(label, fontInfo, maxLines)
            }
        }
       
        if (!this.labels.has(key)) {
            let text = this._createText(label, fontInfo)
            this.labels.set(key, text)
            this.addChild(text)
        }
        let text = this.labels.get(key)
        for (let k in attrs) {
            text[k] = attrs[k]
        }
        if (label != text.text)
            text.text = label
        // We do not follow the flexbox jargon and use align for x and justify for y axis
        // This deviation is needed to ensure backward compatability
        switch (attrs.justify || null) {
            case 'top':
                text.anchor.y = 0
                break
            case 'bottom':
                text.anchor.x = 1
                break
            default:
                text.anchor.y = 0.5
                break
        }
        switch (attrs.align) {
            case 'right':
                text.anchor.x = 1
                break
            case 'center':
                text.anchor.x = 0.5
                break
            default:
                text.anchor.x = 0
                break
        }
        text.visible = true
        return text
    }

    /**
     * Private method that truncates the text and adds an ellipsis if there are more lines
     * than wanted
     *
     * @param {*} text
     * @param {*} style
     * @param {*} [maxLines=Infinity]
     * @returns
     * @memberof LabeledGraphics
     */
    truncateLabel(text, style, maxLines = Infinity) {
        if (maxLines === Infinity) {
            return text
        }
        const { wordWrapWidth } = style
        const pixiStyle = new PIXI.TextStyle(style)
        const { lines } = PIXI.TextMetrics.measureText(text, pixiStyle)
        let newText = text
        if (lines.length > maxLines) {
            const truncatedLines = lines.slice(0, maxLines)
            const lastLine = truncatedLines[truncatedLines.length - 1]
            const words = lastLine.split(' ')
            const wordMetrics = PIXI.TextMetrics.measureText(`\u00A0\n...\n${words.join('\n')}`, pixiStyle)
            const [spaceLength, dotsLength, ...wordLengths] = wordMetrics.lineWidths
            const { text: newLastLine } = wordLengths.reduce((data, wordLength, i) => {
                if (data.length + wordLength + spaceLength >= wordWrapWidth) {
                    return { ...data, length: wordWrapWidth }
                }
                return {
                    text: `${data.text}${i > 0 ? ' ' : ''}${words[i]}`,
                    length: data.length + wordLength + spaceLength,
                };
            }, { text: '', length: dotsLength })
            truncatedLines[truncatedLines.length - 1] = `${newLastLine}...`
            newText = truncatedLines.join('\n')
        }
        return newText
    }

    /**
     * Returns the label for the given key.
     *
     * @param {*} key
     * @returns
     * @memberof LabeledGraphics
     */
    getLabel(key) {
        return this.labels.get(key)
    }

    /** 
     * Hides the label with the given key.
     * @param {*} key
     * @memberof LabeledGraphics
     */
    hideLabel(key) {
        let label = this.labels.get(key)
        if (label) {
            label.visible = false
        }
    }

    /** 
     * Removes the label with the given key.
     * @param {*} key
     * @memberof LabeledGraphics
     */
    removeLabel(key) {
        let label = this.labels.get(key)
        this.labels.delete(key)
        label.destroy()
    }

   
    /**
     * Ensures that labels are hidden on clear.
     *
     * @memberof LabeledGraphics
     */
    clear() {
        super.clear()
        for (let key of this.labels.keys()) {
            this.hideLabel(key)
        }
    }

    /**
     * Logs debugging infos
     *
     * @memberof LabeledGraphics
     */
    debugInfos() {
        console.log({ size: this.labels.size, labels: this.labels })
    }
}


const labelCache = new Map()

function getTexture(label, fontInfo = FontInfo.normal) {
    let key = label + fontInfo.fontFamily + fontInfo.fontSize

    if (labelCache.has(key)) {
        return labelCache.get(key)
    }
    let expandedFont = Object.assign({}, fontInfo)
    expandedFont.fontSize *= window.devicePixelRatio
    let text = new PIXI.Text(label, expandedFont)
    text.updateText()
    labelCache.set(key, text.texture)
    return text.texture
}

class SpriteLabel extends PIXI.Sprite {

    constructor(label, fontInfo) {
        let texture = getTexture(label, fontInfo)
        super(texture)
        this.label = label
        this.fontInfo = fontInfo
        this.scale.set(0.8 / window.devicePixelRatio)
    }

    set text(label) {
        this.label = label
        this.texture = getTexture(label, this.fontInfo)
    }

    get text() {
        return this.label
    }
}

export class BitmapLabeledGraphics extends LabeledGraphics {

    _createText(label, fontInfo) {
        let texture = getTexture(label, fontInfo)
        return new SpriteLabel(texture)
    }

}