function metaTagFromTags(tags) {
    if (tags.includes('hospital') || tags.includes('medical') || tags.includes('medcom')) {
        return 'Ambulance';
    }

    if (tags.includes('fire-ems')) {
        return 'Fire/EMS';
    }

    if (tags.includes('law')) {
        return 'Law';
    }

    if (tags.includes('court')) {
        return 'Court';
    }

    if (tags.includes('jail')) {
        return 'Jail';
    }

    if (tags.includes('airport')) {
        return 'Airport';
    }

    if (tags.includes('bus')) {
        return 'Bus';
    }

    if (tags.includes('pubwks') || tags.includes('trash')) {
        return 'Pubwks/Trash';
    }

    if (tags.includes('animal')) {
        return 'Animal';
    }

    if (tags.includes('govt')) {
        return 'Gov';
    }

    if (tags.includes('military')) {
        return 'Military';
    }
    return 'Other';
}

let metaTagEmojiMap = {
    'Ambulance': '🚑',
    'Fire/EMS': '🚒',
    'Law': '👮',
    'Court': '🏛️',
    'Jail': 'Ⅲ',
    'Airport': '✈️',
    'Bus': '🚌',
    'Pubwks/Trash': '👷',
    'Animal': '🐶',
    'Gov': '🏢',
    'Military': '🪖',
    'Other': '🤷'
}

 function ptime (timestamp){
    timestamp = parseInt(timestamp, 10)
    if (timestamp < 1000000000000){
        timestamp = timestamp * 1000;
    }
    var d = new Date(timestamp);
    h = d.getHours();
    m = d.getMinutes();
    s = d.getSeconds();
    if (h < 10){
        h = "0" + h;
    }
    if (m < 10){
        m = "0" + m;
    }
    if (s < 10){
        s = "0" + s;
    }

    return h + ":" + m + ":" + s
}

function talkerIdPlusSystemToColor (talkerId, systemName, lightMode=false) {
    if (talkerId === 'UNKNOWN') {
        if (lightMode) {
            return 'rgb(192, 192, 192)';
        } else {
            return 'rgb(128,128,128)';
        }
    }
    let string = talkerId + talkerId.split('').reverse().join('');
    for (var i=0; i<talkerId.length; i++) {
        string += systemName[parseInt(talkerId[i])];
    }
    let lightness = 40 + parseInt(talkerId) % 50;
    if (lightMode) {
         lightness = 50 + parseInt(talkerId) % 50;
    }
    let saturation = 35 + parseInt(talkerId) % 65;

    let hash = 0;
    for (var i=0; i<string.length; i++) {
        hash = string.charCodeAt(i) + ((hash << 5) - hash);
        hash = hash & hash;
    }

    return `hsl(${(hash % 360)}, ${saturation}%, ${lightness}%)`;
}

function relativeTimeOffset (timeDef, millis=false) {
    let now = Date.now();
    let mult = 1;
    if (millis) {
        mult = 1000;
    }
    if (!millis) {
        now = parseInt(now / 1000);
    }
    if (timeDef.endsWith('d')) {
        let num = parseInt(timeDef.split('d')[0]);
        return now + num * 86400 * mult;
    }
    if (timeDef.endsWith('h')) {
        let num = parseInt(timeDef.split('h')[0]);
        return now + num * 3600 * mult;
    }
    if (timeDef.endsWith('m')) {
        let num = parseInt(timeDef.split('m')[0]);
        return now + num * 60 * mult;
    }
    if (timeDef.endsWith('s')) {
        let num = parseInt(timeDef.split('s')[0]);
        return now + num * mult;
    }
}

var pdate = function(timestamp){
    timestamp = parseInt(timestamp, 10)
    if (timestamp < 1000000000000){
        timestamp = timestamp * 1000;
    }
    return new Date(timestamp).toLocaleString();
}

var pdate_short = function (timestamp) {
    var z = pdate(timestamp);
    //return z.split(' ')[0].replace(',', '') + ' ' + z.split(' ')[1].split(':')[0] + ':' + z.split(' ')[1].split(':')[1] + ' ' + z.split(' ')[2];
    return z.split('/')[2].replace(',', '').split(' ')[0] + '/' + leftPad(z.split('/')[0], 2) + '/' + leftPad(z.split('/')[1], 2) + ' ' + z.split(' ')[1].split(':')[0] + ':' + z.split(' ')[1].split(':')[1] + ' ' + z.split(' ')[2];
}

function horizBarChart(canvas, values, maxVal, bgColor='#010101', colors=["#14cc70", 'blue', 'red'], border=true, borderColor='#14cc70') {
    var ctx = canvas.getContext("2d");
    ctx.fillStyle = bgColor;
    ctx.fillRect(0, 0, canvas.width, canvas.height);
    barHeight = canvas.height / values.length;
    for (var i=0; i<values.length; i++) {
        ctx.fillStyle = colors[i % colors.length];
        ctx.fillRect(0, i * barHeight, canvas.width * (values[i] / maxVal), (i + 1) * barHeight);
    }
    if (border) {
        ctx.strokeStyle = borderColor;
        ctx.strokeRect(0, 0, canvas.width, canvas.height);

    }
}

function toFixed(n, fixed) {
    return ~~(Math.pow(10, fixed) * n) / Math.pow(10, fixed);
}

function niceDuration(seconds, limitAfter=false, limitCount=2) {
    let result = ''
    let count = 0;
    remaining = seconds;

    if (remaining >= 86400) {
        result += toFixed(remaining / 86400, 0) + 'd';
        count ++ ;
    }
    if (limitAfter && count >= limitCount) {return result; }
    remaining = remaining % 86400;
    if (remaining >= 3600){
        result += toFixed(remaining / 3600, 0) + 'h';
        count ++;
    }
    if (limitAfter && count >= limitCount) {return result; }
    remaining = remaining % 3600;
    if (remaining >= 60) {
        result += toFixed(remaining / 60, 0) + 'm';
        count ++ ;
    }
    if (limitAfter && count >= limitCount) {return result; }
    remaining = remaining % 60;
    if (remaining > 0) {
        result += toFixed(remaining, 0) + 's';
    }
    return result;
}

function toggleBlockNone(elementName) {
    let e = document.getElementById(elementName);
    if (e.style.display == 'block') {
        e.style.display = 'none';
    } else {
        e.style.display = 'block';
    }
}

function leftPad(n, targetLength) {
    result = n.toString();
    while (result.length < targetLength) {
        result = '0' + result;
    }
    return result;
}

function intervalDeconflict(intervalStart, intervalEnd, existingIntervals) {
    //console.log(intervalStart);
    //console.log(intervalEnd);
    //console.log(existingIntervals.toString());
    
    let intersectingIntervals = [];
    let intervalsToGet = [];
    let earliestExistingStart = intervalEnd;
    for (i of existingIntervals) {
        if (i[0] >= intervalStart || i[1] <= intervalEnd) {
            intersectingIntervals.push(i);
        }
        if (earliestExistingStart > i[0]) {
            earliestExistingStart = i[0];
        }
    }
    let earliestTime = intervalStart;
    let latestTime = intervalEnd;
    for (i of intersectingIntervals) {
        if (i[0] < earliestTime) { earliestTime = i[0]; }
        if (i[1] > latestTime) { latestTime = i[1]; }
    }
    //console.log(earliestTime);
    //console.log(latestTime);
    
    let currentIntervalStart = earliestTime;
    let currentIntervalEnd = earliestTime + 1;
    let inVoidInterval = false;

    if (earliestExistingStart > intervalStart) {
        inVoidInterval = true;
    }
    
    let t;
    for (t=earliestTime; t<latestTime; t+=1000) {
        let haveThisSecond = false;
        for (i of intersectingIntervals) {
            if (t >= i[0] && t <= i[1]) {
                haveThisSecond = true;
                t = i[1];
                break;
            }
        }
        if (haveThisSecond) {
            if (inVoidInterval) {
                currentIntervalEnd = t;
                inVoidInterval = false;
                intervalsToGet.push([currentIntervalStart, currentIntervalEnd]);
            } 
        } else {
            if (!inVoidInterval) {
                inVoidInterval = true;
                currentIntervalStart = t;
            } 
        }
    }
    if (inVoidInterval) {
        currentIntervalEnd = t;
        intervalsToGet.push([currentIntervalStart, currentIntervalEnd]);
    }
    return intervalsToGet;
}

function consolidateIntervals(intervals, millis=true) {
    if (intervals.length <= 1) {
        return intervals;
    }
    let earliestTime = Date.now();
    let latestTime = 0;
    if (!millis) { earliestTime = parseInt(earliestTime / 1000); }

    for (let i=0; i<intervals.length; i++){
        if (intervals[i][0] < earliestTime) { earliestTime = intervals[i][0]; }
        if (intervals[i][1] > latestTime) { latestTime = intervals[i][1]; }
    }

    // we'll always use seconds internally because millis are too fucking small

    if (millis) {
        earliestTime = parseInt(earliestTime / 1000);
        latestTime = parseInt(latestTime / 1000);
    }

    let consolidated = [];
    let inInterval = true;
    let currentIntervalStart = earliestTime;
    let i;
    for (i=earliestTime; i<=latestTime; i++) {
        //console.log(i);
        let foundOne = false;
        for (let j=0; j<intervals.length; j++) {
            //console.log(intervals[j][0]);
            if ((millis && (i >= intervals[j][0] / 1000 && i <= intervals[j][1] / 1000)) || (!millis && (i >= intervals[j][0] && i <= intervals[j][1]))) {
                foundOne = true;
                i = parseInt(intervals[j][1] / 1000);
                //console.log('found');
                break;
            }
        }
        if (foundOne) {
            if (!inInterval) {
                inInterval = true;
                currentIntervalStart = i;
            }
        } else {
            if (inInterval){
                consolidated.push([currentIntervalStart, i]);
                inInterval = false;
            }
        }
    }
    if (inInterval) {
        consolidated.push([currentIntervalStart, i]);
    }

    if (millis) {
        for (i=0; i<consolidated.length; i++) {
            consolidated[i][0] = consolidated[i][0] * 1000;
            consolidated[i][1] = consolidated[i][1] * 1000;
        }
    }

    return consolidated;
}

function intervalReport(intervals) {
    for (let i=0; i<intervals.length; i++) {
        console.log('' + i + ': ' + pdate(intervals[i][0]) + ' - ' + pdate(intervals[i][1]) + ' diff ' + niceDuration(intervals[i][1] / 1000 - intervals[i][0] / 1000));
    }
}

function sortVerify(calls) {
    let sorted = true;
    let lastValue = 0;
    for (let i=0; i<calls.length; i++) {
        console.log('' + i + ': ' + calls[i]['start_time'] + ' vs ' + lastValue + ' diff ' + (calls[i]['start_time'] - lastValue));
        if (calls[i]['start_time'] >= lastValue){
            lastValue = calls[i]['start_time'];
        } else {
            console.log('sortVerify failed! ' + calls[i]['start_time'] + ' is less than ' + lastValue);
            sorted = false;
            break
        }
    }
    return sorted;
}