# JSDoc: Source: schemas/statSchema.js

# Source: schemas/statSchema.js

    /*Canopy - The next generation of stoner streaming software
    Copyright (C) 2024-2025 Rainbownapkin and the TTN Community

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as
    published by the Free Software Foundation, either version 3 of the
    License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.*/

    //NPM Imports
    const {mongoose} = require('mongoose');

    //Local Imports
    const config = require('./../../config.json');

    /**
     * DB Schema for single document for keeping track of server stats
     */
    const statSchema = new mongoose.Schema({
        //This does NOT handle deleted accounts/channels. Use userModel.estimatedDocumentCount() for number of active users.
        userCount: {
            type: mongoose.SchemaTypes.Number,
            required: true,
            default: 0
        },
        channelCount: {
            type: mongoose.SchemaTypes.Number,
            required: true,
            default: 0
        },
        launchCount: {
            type: mongoose.SchemaTypes.Number,
            required: true,
            default: 0
        },
        firstLaunch: {
            type: mongoose.SchemaTypes.Date,
            required: true,
            default: new Date()
        },
        tokes: [{
            toke: {
                type: mongoose.SchemaTypes.Map,
                required: true,
                default: new Map()
            },
            date: {
                type: mongoose.SchemaTypes.Date,
                required: true,
                default: new Date()
            }
        }]
    });

    //statics
    /**
     * Get's servers sole stat document from the DB
     * @returns {Mongoose.Document} Server's sole statistics document
     */
    statSchema.statics.getStats = async function(){
        //Get the first document we find
        var stats = await this.findOne({});

        if(stats){
            //If we found something then the statistics document exist and this is it,
            //So long as no one else has fucked with the database it should be the only one. (is this forshadowing for a future bug?)
            return stats;
        }else{
            //Otherwise this is the first launch of the install, say hello
            console.log("First launch detected! Initializing statistics document in Database!");

            //create and save the statistics document
            stats = await this.create({});
            await stats.save();

            //live up to the name of the function
            return stats;
        }
    }

    /**
     * Increments Lunach count upon server launch and prints out amount of launches since server initialization
     */
    statSchema.statics.incrementLaunchCount = async function(){
        //get our statistics document
        const stats = await this.getStats();

        //increment counter and save
        stats.launchCount++;
        stats.save();

        //print bootup message to console.
        console.log(`${config.instanceName}(Powered by Canopy) initialized. This server has booted ${stats.launchCount} time${stats.launchCount == 1 ? '' : 's'}.`)
        console.log(`First booted on ${stats.firstLaunch}.`);
    }

    /**
     * Increments user count upon new user registration
     * @returns {Number} Number of users before count was incremented
     */
    statSchema.statics.incrementUserCount = async function(){
        //get our statistics document
        const stats = await this.getStats();
        //temporarily keep old count so we can return it for the users ID
        const oldCount = stats.userCount;

        //increment counter and save
        stats.userCount++;
        stats.save();

        //return the count from beggining of function for user ID
        return oldCount;
    }

    /**
     * Increments channel count upon new channel registration
     * @returns {Number} Number of channels before count was incremented
     */
    statSchema.statics.incrementChannelCount = async function(){
        //get our statistics document
        const stats = await this.getStats();
        //temporarily keep old count so we can return it for the channel ID
        const oldCount = stats.channelCount;

        //increment counter and save
        stats.channelCount++;
        stats.save();

        //return the count from beggining of function for channel ID
        return oldCount;
    }

    /**
     * Tattoo's toke to the server statistics document
     * @param {Map} toke - Tokemap handed down from Tokebot
     */
    statSchema.statics.tattooToke = async function(toke){
        //Get the statistics document
        const stats = await this.getStats();

        //Add the toke to the stat document
        stats.tokes.push({toke});

        //Save the stat document
        await stats.save();
    }

    /**
     * Gets toke count from statistics document
     * @returns {Number} Number of tokes across the entire site
     */
    statSchema.statics.getTokeCount = async function(){
        //get stats doc
        const stats = await this.getStats();

        //return toke count
        return stats.tokes.length;
    }

    /**
     * Gets toke counts for each individual callout in a map
     * @returns {Map} Map of toke counts for each individual callout registered to the server
     */
    statSchema.statics.getTokeCommandCounts = async function(){
        //get stats doc
        const stats = await this.getStats()
        //Create empty map to hold toke command counts
        const count = new Map();

        //for each toke
        stats.tokes.forEach((toke) => {
            //For each toke command called in the current toke
            toke.toke.forEach((command) => {
                //Get the current count for the current command
                var curCount = count.get(command);

                //if the current count is null
                if(curCount == null){
                    //Set it to one
                    count.set(command, 1);
                }else{
                    //Set it to ++curCount
                    count.set(command, ++curCount);
                }
            });
        });

        //return the toke command count
        return count;
    }

    module.exports = mongoose.model("statistics", statSchema);