nrdb-language-override.js.tail.in

// regenerate the DB on a version update
if (localStorage.getItem("version") != version) {
    localStorage.setItem("version", version)
    indexedDB.deleteDatabase("ForerunnerDB")
}

var lang = localStorage.getItem("language")
if (lang == null) {
    lang = locale
    localStorage.setItem("language", lang)
}

function updateLanguage() {
    if (lang == locale) {
        localStorage.setItem("language", "en")
    } else {
        localStorage.setItem("language", locale)
    }
    // nrdb releases data regardless of updates if data is present, so we need to nuke the db to
    // make sure the language change applies on the first refresh
    indexedDB.deleteDatabase("ForerunnerDB")
    location.reload()
}

function insertLanguageSelector(document) {
    var text = document.createElement('a')
    var elem = document.createElement('li')

    text.setAttribute('href', "#")
    text.addEventListener("click", updateLanguage, false)
    if (lang == locale) {
        text.innerHTML = 'English'
    } else {
        text.innerHTML = locale_text
    }

    elem.appendChild(text)
    document.querySelector('.navbar-right').appendChild(elem)
}

function updateCardData(response, db) {
    var data = JSON.parse(response.text)
    data.data.forEach(entry => {
        var card = cards[entry.code]
        if (card) {
            if (card.title) {
                entry.title = card.title
            }
            if (card.text) {
                entry.text = card.text
            }
            if (card.keywords) {
                entry.keywords = card.keywords
            }
        }
    })
    response.text = JSON.stringify(data)
    response.headers["content-language"] = lang
}

function updateData(response, db) {
    var data = JSON.parse(response.text)
    data.data.forEach(entry => {
        if (db[entry.code] && db[entry.code].name) {
            entry.name = db[entry.code].name
        }
    })
    response.text = JSON.stringify(data)
    response.headers["content-language"] = lang
}

xhook.after(function(request, response) {
    // only override info if we're actually using not english
    if (lang != locale) {
        return
    }
    if (request.url == "/api/2.0/public/cards") {
        updateCardData(response, cards)
    } else if (request.url == "/api/2.0/public/types") {
        updateData(response, types)
    } else if (request.url == "/api/2.0/public/cycles") {
        updateData(response, cycles)
    } else if (request.url == "/api/2.0/public/packs") {
        updateData(response, packs)
    } else if (request.url == "/api/2.0/public/factions") {
        updateData(response, factions)
    }
})

// missing
// - replace 'strength' in hover window. hover window is under div class qtip-content, but strength text has no id/element itself
// - swapping info in /api/2.0/public/sides but it doesn't seem to be used for anything
// things to be careful about
// - there's card links that don't have card names (i.e. printings under card page), make sure they don't get swapped
// - card list for e.g. jinteki has translated names which will break that flow. have to switch to english when doing that
// currently broken
// - card dropdown search only works with japanese. don't think it's possible to do both, at least not without overriding the entire JS of that function
// - likewise, card search will return translated names locally but the actual server query only uses canonical names

function swapCodeName(basename, entries) {
    Object.values(entries).map((entry) => {
        var re = new RegExp(entry.code.charAt(0).toUpperCase() + entry.code.slice(1))
        basename = basename.replace(re, entry.name)
    })
    return basename
}

function swapEntryNames(basename, entries) {
    Object.entries(entries).map((entry) => {
        var re = new RegExp(entry[0] + ":")
        basename = basename.replace(re, entry[1] + ":")
    })
    return basename
}

function swapUIText(basename, entries) {
    Object.entries(entries).map((entry) => {
        var re = new RegExp(entry[0])
        basename = basename.replace(re, entry[1])
    })
    return basename
}

function overrideCardImage(elem) {
    var url = elem.getAttribute("data-src")
    if (url) {
        elem.setAttribute('onerror', "this.src='" + url + "'")
        elem.setAttribute('data-src', url.replace(/\/v1\//, "/v1/" + locale + "/"))
    }
    if (elem.src) {
        elem.setAttribute('onerror', "this.src='" + elem.src + "'")
        elem.src = dataUrl.replace(/\/v1\//, "/v1/" + locale + "/")
    }
}

function handleCardImage(document) {
    document.querySelectorAll(".card-image").forEach(elem => {
        var dataUrl = elem.getAttribute("data-src")
        if (dataUrl) {
            overrideCardImage(elem)
        }
    })
}

function overrideCardInfo(elem, code) {
    var card = cards[code]

    if (card != null) {
        elem.querySelectorAll(".card-title").forEach(title => {
            if (card.title) {
                title.innerHTML = card.title
            }
        })
        elem.querySelectorAll(".card-text").forEach(text => {
            if (card.text) {
                text.innerHTML = NRDB.format.text(card)
            }
        })
        elem.querySelectorAll(".card-flavor").forEach(text => {
            if (card.flavor) {
                text.innerHTML = card.flavor.replace(/\n/, "<br>")
            }
        })
        elem.querySelectorAll(".card-type").forEach(type => {
            var basetype = type.innerHTML.split(/ +/)[1]
            basetype = swapCodeName(basetype, types)

            if (card.keywords != null) {
                type.innerHTML = basetype + ' ' + card.keywords
            } else {
                type.innerHTML = basetype
            }
        })
    }

    elem.querySelectorAll(".card-stats").forEach(stat => {
        stat.innerHTML = swapEntryNames(stat.innerHTML, stats)
    })
    elem.querySelectorAll(".card-influence").forEach(influence => {
        influence.innerHTML = swapEntryNames(influence.innerHTML, stats)
    })

    handleCardImage(elem)
}

function overrideCardResults(document) {
    document.querySelectorAll(".card").forEach(elem => {
        var code = elem.getAttribute("data-index")
        if (cards[code] && cards[code].title) {
            elem.innerHTML = cards[code].title
        }
    })
    Array.from(document.querySelector('.rwd-table').rows).forEach(row => {
        var code = 0
        Array.from(row.cells).forEach(cell => {
            var col = cell.getAttribute('data-th')
            if (col == 'Title') {
                code = cell.children[0].getAttribute('data-index')
                // Title is already overridden above
            } else if (col == 'Type') {
                cell.innerHTML = swapCodeName(cell.innerHTML, types)
            } else if (col == 'Subtype') {
                if (cards[code] && cards[code].keywords) {
                    cell.innerHTML = cards[code].keywords
                }
            } else if (col == 'Set') {
                // TODO handle this
                //<td data-th="Set"><span class="icon icon-kitara"></span> Kampala Ascendent 101</td>
            }
        })
    })
}

function moveCardCategory(parent, type, dest, child, source) {
    dest.appendChild(child)
    var count = parseInt(child.innerHTML.split('x')[0])
    Array.from(parent.getElementsByTagName('h5')).forEach(elem => {
        if (elem.children[0].attributes["aria-label"].value == type) {
            var old_count = parseInt(elem.children[1].innerHTML) || 0
            elem.children[1].innerHTML = old_count + count
            if (old_count == 0) {
                elem.setAttribute("style", "")
            }
        } else if (elem.children[0].attributes["aria-label"].value == source) {
            var old_count = parseInt(elem.children[1].innerHTML)
            elem.children[1].innerHTML = old_count - count
            if ((old_count - count) == 0) {
                elem.setAttribute("style", "display: none;")
            }
        }
    })
}

// ice categorization is based on english names rather than base types, so we need to fix these
// see: https://github.com/NetrunnerDB/netrunnerdb/blob/a63b9bdd5f58b316b49b7276c24509b8fb3e8ed8/src/AppBundle/Service/Judge.php#L81
function fixCardCategorization() {
    var deck = document.querySelector('#deck')
    Array.from(document.querySelector('.deck-none').children).forEach(elem => {
        var code = elem.children[0].getAttribute('data-index')
        if (cards[code] && cards[code].keywords) {
            var is_barrier = cards[code].keywords.includes(types["barrier"].name)
            var is_code_gate = cards[code].keywords.includes(types["code-gate"].name)
            var is_sentry = cards[code].keywords.includes(types["sentry"].name)
            if ((is_barrier && is_code_gate) || (is_barrier && is_sentry) || (is_code_gate && is_sentry)) {
                moveCardCategory(deck, "Multi", document.querySelector('.deck-multi'), elem, 'Other')
            } else if (is_barrier) {
                moveCardCategory(deck, "Barrier", document.querySelector('.deck-barrier'), elem, 'Other')
            } else if (is_code_gate) {
                moveCardCategory(deck, "Code Gate", document.querySelector('.deck-code-gate'), elem, 'Other')
            } else if (is_sentry) {
                moveCardCategory(deck, "Sentry", document.querySelector('.deck-sentry'), elem, 'Other')
            }
        }
    })
    Array.from(document.querySelector('.deck-program').children).forEach(elem => {
        var code = elem.children[0].getAttribute('data-index')
        if (cards[code] && cards[code].keywords) {
            var is_icebreaker = cards[code].keywords.includes(types["icebreaker"].name)
            if (is_icebreaker) {
                moveCardCategory(deck, "Icebreaker", document.querySelector('.deck-icebreaker'), elem, 'Program')
            }
        }
    })
}

window.addEventListener('DOMContentLoaded', function() {
    // swap header data (every page), but only if we're not in english mode
    if (lang == locale) {
      document.querySelectorAll('.navbar-nav').forEach(navbar => {
          Array.from(navbar.children).forEach(elem => {
              elem.innerHTML = swapUIText(elem.innerHTML, ui)
          })
      })
    }
    // insert our language dropdown
    insertLanguageSelector(document)
    // nothing else to do if we're in english mode
    if (lang != locale) {
        return
    }
    // card detail page
    if (document.location.pathname.startsWith("/en/card/")) {
        var code = document.URL.split('/').pop()
        overrideCardInfo(document, code)
    }

    // deck builder
    if (document.location.pathname.startsWith("/en/deck/") ||
        document.location.pathname.startsWith("/en/decklist/")) {
        // format selection
        document.querySelectorAll(".option-format").forEach(elem => {
            elem.innerHTML = swapCodeName(elem.innerHTML, formats)
        })
        // ID selection
        document.querySelectorAll(".identity").forEach(elem => {
            code = elem.getAttribute("data-code")
            var card = cards[code]
            // N.B. there's only one of the following for each, it could be simplified
            elem.querySelectorAll(".name").forEach(identity => {
                if (card && card.title != null) {
                    identity.innerHTML = card.title
                }
            })
            elem.querySelectorAll(".small").forEach(pack => {
                if (card && card.pack != null) {
                    // TODO derp, no pack info -- needs to be pulled from nrdb.cards instead
                    pack.innerHTML = card.pack
                }
            })
        })
        let deckStatsMO = new MutationObserver(function(mutations) {
            deckStatsMO.disconnect()
            mutations.forEach(function(mutation) {
                var elem = mutation.target
                var text = elem.innerHTML
                if (elem.id == "influence") {
                    // ex: 0 influence spent (max 15, available 15)
                    elem.innerHTML = text.replace(/(\d+) influence spent \(max (\d+), available (-?\d+)\)/, display["influence"])
                } else if (elem.id == "agendapoints") {
                    // ex: 9 agenda points (between 20 and 21)
                    elem.innerHTML = text.replace(/(\d+) agenda points \(between (\d+) and (\d+)\)/, display["agendapoints"])
                } else if (elem.id == "cardcount") {
                    // ex: 0 cards (min 45)
                    elem.innerHTML = text.replace(/(\d+) cards \(min (\d+)\)/, display["cardcount"])
                } else if (elem.id == "latestpack") {
                    // ex: Cards up to ...
                    elem.innerHTML = text.replace(/Cards up to (.*)/, display["latestpack"])
                }
            })
            // fix selection under collections tab. doesn't cover NSG only / Any / All
            Object.values(formats).map((format) => {
                document.querySelectorAll("#collection_" + format.code).forEach(element => {
                    element.innerHTML = format.name
                })
            })
            observeDeckStats()
        })

        const observeDeckStats = ()=> {
            deckStatsMO.observe(document.querySelector("#influence"), { attributes: true, characterData: true, childList: true, subtree: true, attributeOldValue: true, characterDataOldValue: true });
            deckStatsMO.observe(document.querySelector("#agendapoints"), { attributes: true, characterData: true, childList: true, subtree: true, attributeOldValue: true, characterDataOldValue: true });
            deckStatsMO.observe(document.querySelector("#cardcount"), { attributes: true, characterData: true, childList: true, subtree: true, attributeOldValue: true, characterDataOldValue: true });
        }
        observeDeckStats()

        let deckCardsMO = new MutationObserver(function(mutations) {
            deckCardsMO.disconnect()
            fixCardCategorization()
            observeDeckCards()
        })

        const observeDeckCards = ()=> {
            deckCardsMO.observe(document.querySelector("#deck-content"), { attributes: true, characterData: true, childList: true, subtree: true, attributeOldValue: true, characterDataOldValue: true });
        }
        observeDeckCards()
    }

    if (document.location.pathname.startsWith("/en/sets")) {
        document.querySelectorAll(".card").forEach(elem => {
            var code = elem.getAttribute("data-index")
            if (packs[code]) {
                // TODO childnode writes don't work
                elem.childNodes[2] = packs[code].name
            }
        })
    }

    if (document.location.pathname.startsWith("/en/set/") ||
        document.location.pathname.startsWith("/en/cycle/")) {
        overrideCardResults(document)
    } else if (document.location.pathname.startsWith("/find/")) {
        // find can either return card results or a card page
        var elem = document.querySelector(".card-image")
        if (elem) {
            var code = elem.children[0].getAttribute('data-src').split('/').pop().split('.')[0]
            overrideCardInfo(document, code)
        } else {
            overrideCardResults(document)
        }
    }
})

window.addEventListener('load', function() {
    if (lang != locale) {
        return
    }
    // swap link names to cards / sets
    for (var i = 0, l=document.links.length; i<l; i++) {
        var url = document.links[i].getAttribute('href')
        if (url.startsWith('/en/card/')) {
            var code = url.split('/')[3]
            var card = cards[code]
            if (card && card.title != null) {
                if (document.links[i].parentElement.className == "previous") {
                    document.links[i].innerHTML = "← " + card.title
                } else if (document.links[i].parentElement.className == "next") {
                    document.links[i].innerHTML = card.title + " →"
                }
            }
        } else if (url.startsWith('/en/set/')) {
            var code = url.split('/')[3]
            var set = packs[code]
            if (set && set.name != null) {
                if (document.links[i].parentElement.className == "previous") {
                    document.links[i].innerHTML = "← " + set.name
                } else if (document.links[i].parentElement.className == "next") {
                    document.links[i].innerHTML = set.name + " →"
                } else {
                    document.links[i].innerHTML = set.name
                }
            }
        }
    }

    let cardImageMO = new MutationObserver(function(mutations) {
        cardImageMO.disconnect()
        mutations.forEach(function(mutation) {
            var elem = mutation.target.querySelector(".modal-image")
            if (elem) {
                overrideCardImage(elem.children[0])
            }
        })
        observeCardImages()
    })

    const observeCardImages = ()=> {
        if (document.querySelector("#cardModal")) {
            cardImageMO.observe(document.querySelector("#cardModal"), { attributes: true, characterData: true, childList: true, subtree: true, attributeOldValue: true, characterDataOldValue: true });
        }
    }
    observeCardImages()
})