const path = require('path');
const find = require('findit');
const {Client,ClientOptions,GatewayIntentBits,Message, Partials, ActivityType,EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle} = require('discord.js')
const roleRulesM = require('./models/autoRoleRule');
const feedM = require('./models/feeds');
const xmlparser = require('xml-js')
const GuildM = require('./models/guilds');
const Spawner = require('child_process');
const mongoose = require('mongoose');

module.exports.GatewayIntentBits = GatewayIntentBits;
module.exports.Partials = Partials;
module.exports.ActivityType = ActivityType;
module.exports.EmbedBuilder = EmbedBuilder;
module.exports.ActionRowBuilder = ActionRowBuilder;
module.exports.ButtonBuilder = ButtonBuilder;
module.exports.ButtonStyle = ButtonStyle;
module.exports.Message = Message;

//@ts-check
class CommandOptions 
{
    /**
     * 
     * @param {String} name 
     * @param {String[]} aliases 
     * @param {String} description 
     * @param {Boolean} needsAdmin 
     * @param {Boolean} hidden 
     */
    constructor (name, aliases, description, needsAdmin, hidden)
    {
        this.name = name;
        this.aliases = aliases;
        this.description = description;
        this.needsAdmin = needsAdmin;
        this.hidden = hidden;
    }
}
class command 
{
    /**
     * @param {_Client} client extends discord.js.Client
     * @param {CommandOptions} options extends Lib.Options
     */
    constructor(client, options)
    {
        this.name = options.name;
        this.aliases =  options.aliases;
        this.description = options.description;
        this.needsAdmin =options.needsAdmin;
        this.hidden = options.hidden;
        this.client = client;
    }
}module.exports.Command = command;


class _Client extends Client
{
    /**
     * 
     * @param {ClientOptions} options 
     */
    commands = new Map();
    constructor(options, mongoDBURI)
    {
        super(options);
        let finder = find(path.resolve('commands'));
        finder.on('file', file=>
        {
            let command = require(file);
            if(typeof command === 'function')
            {
                let c = new command(this);
                
                this.commands.set(c.name,{
                    needsAdmin: c.needsAdmin?c.needsAdmin:false,
                    command: command,
                });
                if(c.aliases)
                {
                    for(var i =0; i<c.aliases.length+1; i++)
                    {
                        this.commands.set(c.aliases[i],{
                            needsAdmin: c.needsAdmin,
                            command: command,
                        });
                    }
                }
            }
        })
        
        finder.on('end', ()=>
        {
            this.enableCommands();
        })
        connectToDB();
        function connectToDB()
        {
            try {
                mongoose.connect(mongoDBURI);
            } catch (err) {
                console.log('Server: Error: There was an Error with the connection to the database, attempting to restart it.', err)
                connectToDB();
            }
        }
        mongoose.Promise = global.Promise;
        this.setGuilds();
        this.RoleSetter();
        this.rustCommits = new rustCommits(this);
        this.freegames = new FreeGames(this);
        this.strikes = new Strikes(this);
        this.on('disconnect', (event) => {
            console.log(`Client disconnected: ${event.reason}`);
        });
        this.on('reconnecting', () => {
            console.log('Client is reconnecting...');
        });
        this.YTFeed();
        this.music();
        setInterval(() => {
            this.YTFeed()
            this.music();
        }, 60*60*1000);
    }
    setGuilds()
    {
        this.on('ready', ()=>
        {

            this.guilds.cache.forEach(guild=>
            {
                GuildM.find({gID:guild.id})
                .then(
                    (guild_,err)=>
                    {
                        if(err || guild_.length==0)
                        {
                            var nGuild = GuildM();
                            nGuild.name = guild.name;
                            nGuild.memberCount = guild.members.cache.size;
                            nGuild.gID = guild.id;
                            nGuild.allowInvites = false;
                            nGuild.strikes = false;
                            nGuild.music = false;
                            nGuild.save(err=>
                                {
                                    if(err) console.log('Server: Adding non existing guilds to the DB. Error ocurred:', err)
                                });
                        }
                    }
                )
            })
        })
        this.on('guildCreate', guild=> 
        {
            var guildModel = new GuildM();
            guildModel.name = guild.name;
            guildModel.memberCount = guild.members.cache.size;
            guildModel.gID = guild.id;
            guildModel.allowInvites = false;
            guildModel.strikes = false;
            guildModel.music = false;
            guildModel.save()
        });
        this.on('guildDelete', guild => 
        {
            GuildM.find({gID:guild.id}).then(guild=>
                {
                    if(guild.length==0) return sendMessage(false, 'ID not on the list.')
                    GuildM.findOneAndRemove(guild.id, (err)=>
                    {
                        if(err) console.log('Server: Deleting guild from DB: There was an error:', err)
                    })
                })
        });


    }
    /**
     * Register a group of commands under the folder commands
     * @param {String} name - Name of the group.
     * @param {String} folderName - Name of the folder.
     */
    async enableCommands()
    {
        this.on("messageCreate", message=>
        {
            this.checkForInvites(message);
            if(message.content.startsWith(process.env.prefix)) //Test prefix t!
            {
                let commandName=message.content.split('!')[1].split(' ')[0];
                let args = message.content.split(' ');
                args = args.slice(1);
                if(this.commands.get(commandName))
                {
                    let needsAdmin = this.commands.get(commandName).needsAdmin;
                    let isAdmin =false;
                    try 
                    {
                        isAdmin = this.guilds.cache.get(message.guild.id).members.cache.get(message.author.id).permissions.has('ADMINISTRATOR');
                    } catch (error) 
                    {
                        console.log('Lib: Command: Permission Verification: Failed')
                    }
                    let command = this.commands.get(commandName).command
                    if((needsAdmin && isAdmin) || !needsAdmin) return   new command(this).run(message, args);
                    if(needsAdmin && !isAdmin) return new ErrorMessage(this).send(ErrorType.Permissions, message);
                }
                new ErrorMessage(this).send(ErrorType.NotOnTheList,message)
            }
        })
    }
    /**
     * 
     * @param {String} name - Command Name
     * @returns {command}
     */
    async RoleSetter ()
    {
        this.on('messageReactionAdd', (reaction, user)=>
            {
                console.log('Lib: Message: Reaction: Added');
                (async ()=>
                {
                    const rule = await roleRulesM.findOne({mID:reaction.message.id,roleEmoji:reaction._emoji.id}).then(rule =>{return rule}).catch(err=>{return null})
                    if(rule)
                    {
                        console.log(`RoleAssignment: Guild:${this.guilds.cache.get(rule.gID)}: Adding role ${rule.roleName} given to ${user.username}`)
                        this.channels.cache.get(reaction.message.channelId).members.get(user.id).roles.add(rule.roleID)
                    }
                })()
            })
            this.on('messageReactionRemove', (reaction, user)=>
            {
                (async ()=>
                {
                    const rule = await roleRulesM.findOne({mID:reaction.message.id,roleEmoji:reaction._emoji.id}).then(rule =>{return rule}).catch(err=>{return null})
                    if(rule)
                    {
                        console.log(`RoleAssignment: Guild:${this.guilds.cache.get(rule.gID)}: Removing ${user.username}'s ${rule.roleName} role. `)
                        this.channels.cache.get(reaction.message.channelId).members.get(user.id).roles.remove(rule.roleID)
                    }
                })()
            })
    }
    async YTFeed()
    {
        const feeds = await feedM.find().then(feeds=>{return feeds})
        if(feeds.length<1) return 
        for(var feed of feeds)
        {
            (async (feed)=>{
                if(!feed.YTChannelId) return
                if(feed.YTChannelId=='false') return
                var res = await fetch(`https://www.youtube.com/feeds/videos.xml?channel_id=${feed.YTChannelId}`)
                                .then(handleResponse)
                                .then(handleData)
                                .catch(handleError);
                                function handleResponse(response) 
                                {
                                return response.text()
                                }
                                function handleError(error) 
                                {
                                return error;
                                }
                                function handleData(data) 
                                {
                                    data = xmlparser.xml2json(data,
                                                    {
                                                        compact: true,
                                                        space: 4
                                                    });
                                    data = JSON.parse(data);
                                    return {
                                                link:data.feed.entry[0].link._attributes.href,
                                                published:data.feed.entry[0].published._text,
                                                link:data.feed.entry[0].link._attributes.href,
                                                image:data.feed.entry[0].link._attributes.href.split('=')[1],
                                                title:data.feed.entry[0].title._text,
                                                author:
                                                {
                                                    name:data.feed.entry[0].author.name._text,
                                                    url:data.feed.entry[0].author.uri._text
                                                }        
                                            }
                                } 
                if(!res) return false;
                const channel = this.channels.cache.get(feed.ChannelId);
                if(!channel) return false;
                var ytChannelName = await fetch('https://www.youtube.com/feeds/videos.xml?channel_id='+feed.YTChannelId,
                                        {
                                            method: "GET",
                                            mode: "cors", 
                                        })
                                        .then(response=>
                                            {
                                                if(response.ok) return response.text();
                                            })
                                        .then(data=>
                                            {
                                                data = xmlparser.xml2json(data,
                                                    {
                                                        compact: true,
                                                        space: 4
                                                    });
                                                    data = JSON.parse(data);
                                                return data.feed.author.name._text
                                            })
                                        .catch(error=>
                                            {
                                                return error;
                                            });
                console.log('Lib: YTFeed:',ytChannelName, res?.author?.name, channel.name,feed?.ChannelId ,channel.id)
                var aux = res;
                const lastSentMessage= await channel.messages.fetch().then(res=>
                    {
                        for(var item of res)
                        {
                            if(item[1].embeds)
                            {
                                if(item[1].embeds[0])
                                {
                                    var fields = item[1].embeds[0].fields.filter(x=>x.name === 'PublishedTimeStamp');
                                    var isFeed = fields.length>0;
                                    if(!aux.author) return null;
                                    if(isFeed && item[1].embeds[0].title == aux.author.name) return item[1].embeds[0];
                                }
                            }
                        }
                    })
                if(!lastSentMessage) return sendMessage(res, feed, channel);
                const lastSentMessagePublished = lastSentMessage.fields.filter(x=>x.name === 'PublishedTimeStamp')[0].value;
                // console.log(lastSentMessagePublished != res.published , 'lastSentPublished',lastSentMessagePublished,'published', res.published)
                if(!lastSentMessagePublished) sendMessage(res, feed, channel)
                else if(lastSentMessagePublished != res.published) sendMessage(res, feed, channel);
            })(feed);
        }
        function sendMessage(res, feed, channel)
        {
            if(!res?.author?.name) return 
            console.log('Lib: YTFeed: SendMessage: Res: Author: Name:', res?.author?.name)
            const embed = new EmbedBuilder()
            embed.setFooter({text:'Rem-chan on ', iconURL:"https://i.imgur.com/g6FSNhL.png"})
            embed.setAuthor({name:"Rem-chan", iconURL:"https://i.imgur.com/g6FSNhL.png",url:'https://rem.wordfights.com/addtodiscord'}); 
            embed.setColor(0x110809);
            embed.setTimestamp();
            embed.setURL(res?.author?.url)
            embed.setTitle(res?.author?.name);
            embed.setImage(`https://i3.ytimg.com/vi/${res?.image}/maxresdefault.jpg`)
            embed.setDescription(feed?.CostumMessage);
            embed.addFields({name:res?.title, value:' '},
                            {name:'PublishedTimeStamp', value:res?.published},
                            {name:'Link:', value:res?.link});
            channel.send({embeds:[embed]});
        }
    }
    async checkForInvites(message)
    {
        let content = message.content;
        let guild = message.guildId;
        if(!content?.includes('discord.gg')) return 

        await GuildM.find({gID:guild})
        .then((g, err)=>
        {
            if(err) return;
            if(!g.allowInvites) 
            {
                message.delete();
            }
            return;
        });
    }
    async music()
    {
        const ServersWithMusicOn = await this.serversWithMusicOn();
        const ISGONNABEOFFFORAWHILE = true
        if(!ServersWithMusicOn && !ISGONNABEOFFFORAWHILE) return 
        for(var server of ServersWithMusicOn)
        {
            if(!Childs[server.name])
            {
                console.log('Index: Starting Music Worker:', server.name,`(${server.gID})`)
                Childs[server.name] = Spawner.fork('./musicWorker.js',[server.gID, server.name]);
            }
            else
            {       //Health check
            (function (server)
            {
                    Childs[server.name].on('exit', ()=>
                    {
                        console.log('Child DIED, spawning another.')
                        Childs[server.name] = Spawner.fork('./musicWorker.js',[server.gID, server.name]);
                    })
                })(server);
            }

        } 
    }
    async serversWithMusicOn()
    {
        return await GuildM.find({music:true}).then(g=>{return g})
    }

}module.exports.Client = _Client;
const ErrorType = 
{
    Permissions: "Permissions",
    Arguments: "Arguments",
    NoArguments: "No Arguments Given",
    NotOnTheList: "Unknown Command",
    OldMessages: "Can't delete this messages."

}
module.exports.ErrorType = ErrorType;

class Channel 
{
    /**
     * 
     * @param {String} channelID
     */
    constructor(channelID)
    {
        this.channel = channelID;
    }

}

module.exports.Channel = Channel;
/**
 * 
 * @param {Number} length 
 * @returns {String}
 */
function  Random(length) 
{
    length?length:length=5;
    var result           = '';
    var characters       = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    var charactersLength = characters.length;
    for ( var i = 0; i < length; i++ ) {
        result += characters.charAt(Math.floor(Math.random() * charactersLength));
    }
    return result;
}module.exports.Random = Random;

class ErrorMessage 
{
    /**
     * @param {_Client} client 
     */
    constructor(client)
    {
        this.client = client;
    }
    /**
     * 
     * @param {ErrorType} errorType 
     * @param {Message} message 
     * @param {[String]} extraMessages 
     */
   
    async send(errorType,message, extraMessages)
    {
        if (!message.channel.id) return;
        const embed = new EmbedBuilder()
        .setColor(0x4d0000)
        .setAuthor({name:"Rem-chan", iconURL:"https://i.imgur.com/g6FSNhL.png",url:'https://rem.wordfights.com/addtodiscord'})
        .setTimestamp()
        .setFooter({text:'Rem-chan on ', iconURL:"https://i.imgur.com/g6FSNhL.png"})
        .addFields({name: 'Error:', value: 'something'})
        .addFields({name: 'Try:', value: 'something'});
        
        switch (errorType) {
            case ErrorType.Arguments:
                embed.data.fields[0].value =ErrorType.Arguments;
                embed.data.fields[1].value = 'Verify the arguments provided.'
                break;
            case ErrorType.NoArguments:
                embed.data.fields[0].value =ErrorType.NoArguments;
                embed.data.fields[1].value = 'Provide the required arguments for this command.'
                break;
            case ErrorType.Permissions:
                embed.data.fields[0].value =ErrorType.Permissions;
                embed.data.fields[1].value = 'Ask this servers administrator to use the command.'
                break;
            case ErrorType.NotOnTheList:
                embed.data.fields[0].value =ErrorType.NotOnTheList;
                embed.data.fields[1].value = 'Use !help for the list of available.'
                break;
            case ErrorType.OldMessages:
                embed.data.fields[0].value =ErrorType.OldMessages;
                break;
            default:
                break;
        }
        if(extraMessages)
        {
            for(var i = 0; i<extraMessages.length; i++)
            {
                embed.addFields({name:'Tip:', value:extraMessages[i]});
            }
        }
        const randomID =  Random();
        const row = new ActionRowBuilder()
        .addComponents(
                new ButtonBuilder()
                .setCustomId(randomID)
                .setLabel('Remove this.')
                .setStyle(ButtonStyle.Primary)
                .setEmoji('❌')
        );
        await this.client.channels.cache.get(message.channel.id).send({ephemeral: true, embeds: [embed], components: [row] }); 
    
        const filter = i => i.customId === randomID;

        const collector = message.channel.createMessageComponentCollector({ filter, time: 60000 });

        collector.on('collect', async m => 
        {
            message.delete().then(()=>m.message.delete())
            .catch(()=>m.message.delete());
        });
    }

}module.exports.ErrorMessage = ErrorMessage;

/**
 * Anilist Client -> Search Functions
 */
class AnimeInfo
{
    /**
     * 
     * @param {String} title 
     * @param {String} status 
     * @param {String} url
     * @param {String} episodes 
     * @param {String} trailer 
     * @param {String} description 
     * @param {String} coverImage 
     */
    constructor(title, status, episodes, url , trailer, description, coverImage)
    {
        this.title = title; 
        this.status = status;
        this.url = url
        this.episodes=episodes;
        this.trailer = trailer;
        this.description = description;
        this.coverImage = coverImage;
    }
}
class CharInfo
{
    /**
     * 
     * @param {String} name 
     * @param {String} gender 
     * @param {String} image 
     * @param {String} url
     * @param {String} description 
     */
    constructor(name, gender, image, description)
    {
        this.name = name; 
        this.gender = gender;
        this.url = url
        this.image=image;
        this.description = description;
    }
}
class MangaInfo
{
    /**
     * 
     * @param {String} title 
     * @param {String} status 
     * @param {String} url
     * @param {String} description 
     * @param {String} coverImage 
     */
    constructor(title, status, description, coverImage)
    {
        this.title = title; 
        this.status = status;
        this.url = url
        this.description = description;
        this.coverImage = coverImage;  
    }
}
class Options
{
    /**
     * 
     * @param {String} method 
     * @param {String} headers 
     * @param {String} body 
     */
    constructor(method, headers, body)
    {

        this.method = method;
        this.headers = headers;
        this.body = body;  
    }
}

class AnilistCli {
    /**
     * 
     * @param {Options} options 
     * @returns {Info}
     */
    async getInfo(options)
    {
        return await fetch('https://graphql.Anilist.co', options).then(handleResponse)
                     .then(handleData)
                     .catch(handleError);
          function handleResponse(response) 
          {
              return response.json().then(function (json) 
              {
                  return response.ok ? json : Promise.reject(json);
              });
          }
          function handleData(data)
          {
            return data
          }
          function handleError(error) {
              return error;
          }
    }
    /**
     * 
     * @param {String} ss - Search Query
     * @returns {AnimeInfo} 
     */
    async searchAnime(ss)
    {
        var variables = {
            ss,
            "page": 0,
            "perPage": 4
        };
        var query = `query ($ss: String, $page: Int, $perPage: Int) {
            Page(page: $page, perPage: $perPage) {
              media(search: $ss, type: ANIME) {
                id
                title {
                  romaji
                  english
                }
                coverImage {
                    medium
                }
              }
            }
          }
          `
          var options = {
              method: 'POST',
              headers: {
                  'Content-Type': 'application/json',
                  'Accept': 'application/json', 
              },
              body: JSON.stringify({
                  query,
                  variables
              })
          };
        var data =  await this.getInfo(options);

        data = data.data.Page.media
        if(!data[0]) return 'Error'
        var aux = [];
        for(var anime of data)
        {
            aux.push({
                title:anime.title,
                id:anime.id,
                coverImage:anime.coverImage.medium
            });
        }
            return aux;
    }   
    async getAnimeInfo(id)
    {
        var variables = {
            id
        };
        var query = `query ($id: Int) {
            Media(id:$id) {
              id
              idMal
              title {
                romaji
                english
                native
              }
              siteUrl
              status
              episodes
              season
              seasonYear
              trailer {
                site
                id
              }
              description(asHtml:false)
              coverImage {
                large
              }
            }
          }`;
        var options = {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Accept': 'application/json', 
            },
            body: JSON.stringify({
                query,
                variables
            })
        };
        var data =  await this.getInfo(options);
        data = data.data;
        return {
            title:data.Media.title,
            malLink:'https://myanimelist.net/anime/'+data.Media.idMal,
            status:data.Media.status,
            url:data.Media.siteUrl,
            episodes:data.Media.episodes,
            trailer:data.Media.trailer,
            description:data.Media.description,
            coverImage:data.Media.coverImage.large,
            season: (data.Media.season?data.Media.season:'') + ' ' + (data.Media.seasonYear?data.Media.seasonYear:'')
        }        
    }
    /**
     * 
     * @param {String} ss - Search Query
     * @returns {CharInfo}
     */
    async searchChar(ss)
    {
        var variables = {
            ss,
            "page": 0,
            "perPage": 4
        };
        var query = `query ($ss: String, $page: Int, $perPage: Int) {
            Page(page: $page, perPage: $perPage) {
              characters(search: $ss, sort: SEARCH_MATCH) {
                id
                name {
                  full
                  native
                }
                siteUrl
                gender
                image {
                  medium
                }
              }
            }
          }
          `;
        var options = {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Accept': 'application/json',
            },
            body: JSON.stringify({
                query,
                variables
            })
        };
        var data =  await this.getInfo(options);
        var chars = data.data.Page.characters
        var aux = [];
        if(!chars[0]) return 'Error'
        for(var char of chars)
        {
            aux.push({
                id:char.id,
                name:char.name,
                gender:char.gender,
                url:char.siteUrl,
                image:char.image.medium
            })
        }
        return aux;
    }
    async getCharInfo(id)
    {
        
        var variables = {
            id
        };
        var query = `query ($id: Int) {
            Character(id: $id, ) {
              id
              name {
                full
                native
              }
              gender
              siteUrl
              image {
                medium
              }
              description(asHtml:false)
            }
          }
          `;
        var options = {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Accept': 'application/json',
            },
            body: JSON.stringify({
                query,
                variables
            })
        };
        var data =  await this.getInfo(options);
        data = data.data;
        return {
            name:data.Character.name,
            gender:data.Character.gender,
            url:data.Character.siteUrl,
            image:data.Character.image.medium,
            description:data.Character.description,
        }

        
    }
    /**
     * 
     * @param {String} ss - Search Query
     * @returns {MangaInfo}
     */
    async searchManga(ss)
    {
        var variables = 
        {
            ss,
            "page": 0,
            "perPage": 4
        }
        var query = `query ($ss: String, $page: Int, $perPage: Int) {
            Page(page: $page, perPage: $perPage) {
              media(search: $ss, type: MANGA) {
                id
                title {
                  romaji
                  english
                }
                coverImage {
                  medium
                }
              }
            }
          }`
        var options = {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Accept': 'application/json',
            },
            body: JSON.stringify({
                query,
                variables
            })
        };
        var data =  await this.getInfo(options);
        var mangas = data.data.Page.media;
        var aux = [];
        if(!mangas[0]) return 'Error'
        for(var manga of mangas)
        {
            aux.push({
                id:manga.id,
                title:manga.title,
                image:manga.coverImage.medium
            })
        }
        return aux;
        
    }   
    async getMangaInfo(id)
    {  
        var variables = {
            id
        };
        var query = `query ($id: Int) {
            Media(id: $id) {
              title {
                romaji
                english
                native
              }
              siteUrl
              status
              description(asHtml: false)
              coverImage {
                large
              }
            }
          }
          `;
        var options = {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Accept': 'application/json',
            },
            body: JSON.stringify({
                query,
                variables
            })
        };
        var data =  await this.getInfo(options);
        data = data.data;
        return {
            title:data.Media.title,
            status:data.Media.status,
            url:data.Media.siteUrl,
            description:data.Media.description,
            coverImage:data.Media.coverImage.large,
        }     
    }

}module.exports.Anilist = AnilistCli;

const channelM = require('./models/channels');

class rustCommits
{
    /**
     * 
     * @param {_Client} client 
     */
    constructor(client)
    {
        this.client = client;
        this.update();
        setInterval(() => {
            this.update();
        }, 3*60*1000);
        this.channels;
    }
    async update ()
    {
        const channels = await channelM.find({for:'rust'}).then(channels=>{return channels});
        this.channels = await this.resolveChannels(channels);
        const Res = await fetch("https://commits.facepunch.com/?format=json").then(handleResponse)
                   .then(handleData)
                   .catch(handleError);
        function handleResponse(response) 
        {
            return response.json().then(function (json) 
            {
                return response.ok ? json : Promise.reject(json);
            });
        }
        function handleError(error) {
            return error;
        }
        function handleData(data) {
            data.results.splice(30, 20);
            return data.results.filter(x=>x.repo.search(/rust/i)!=-1)
        }
        if(!Res.length)
        {
            //console.log('Framework: Rustcommits: Res', Res);
            return this.update();
        }
        for(var j = 0; j<this.channels.length; j++)
        {
            if(!this.channels[j].lastid) this.channels[j].lastid = 0;
            const Pos = Res.map(e => e.id).indexOf(this.channels[j].lastid);
            Res.splice(Pos, Res.length-Pos);
            for(var i = Res.length-1; i>0; i--)
            {
                if(Res[i].id > this.channels[j].lastid)
                {
                    send(
                    {
                        Author:Res[i].user.name,
                        Avatar:Res[i].user.avatar,
                        Time:Res[i].created.split("T")[1]+ " of "+ Res[i].created.split("T")[0],
                        Content:Res[i].message,
                        ID:Res[i].id,
                        Repo:Res[i].repo,
                        Branch:Res[i].branch
                    }, this.channels[j].cID, this.client);
                }
            }
        }
        /**
         * 
         * @param {RustCommit} commit 
         * @param {Channel} channel 
         */
        function send(commit, channel, client)
        {
            client.channels.cache.get(channel).send({embeds:[
                new EmbedBuilder()
                .setColor(0xc23811)
                .setTitle(commit.Time)
                .setURL('https://commits.facepunch.com')
                .setAuthor({name:commit.Author, iconURL:commit.Avatar==''?"https://i.imgur.com/g6FSNhL.png":commit.Avatar,url:`https://commits.facepunch.com/${commit.Author.split(' ').join('')}`})
                .setDescription(commit.Content)
                .addFields(
                    { name:`${commit.Repo}`, value:`[${commit.Repo}/${commit.Branch}](https://commits.facepunch.com/r/${commit.Repo}/${commit.Branch.split(' ')? commit.Branch.split(' ').join('%20'):commit.Branch} 'Branch Link')`},
                    { name: 'ID', value: commit.ID.toString() },
                    )
                .setTimestamp()
                .setFooter({text:'Rem-chan on ', iconURL:"https://i.imgur.com/g6FSNhL.png"})
            ]});
        }
        
    }
     /**
     * 
     * @param {channelM} channels 
     */
      async resolveChannels(channels)
      {
          for await(var channel of channels )
          {
              if(this.client.channels.cache.get(channel.cID))
              {
                  const Channel = this.client.channels.cache.get(channel.cID)
                  const lastid = await Channel.messages.fetch({limit:1}).then(message=>
                      {
                            if(!message) return 0
                            const [content] = message.values();
                            if(!content||!content.embeds||!content.embeds.length>0) return 0;
                            return parseInt(content.embeds[0].fields[1].value)
                      })
                      channel['lastid'] = lastid;  
              }
          }
          return channels;
      }
}
class RustCommit 
{
    /**
     * 
     * @param {String} Author 
     * @param {String} Avatar - IMAGE URL
     * @param {String} Time 
     * @param {String} Content 
     * @param {Number} ID 
     * @param {String} Repo 
     * @param {String} Branch 
     */
    constructor(Author, Avatar, Time, Content, ID, Repo, Branch)
    {
        this.Author = Author
        this.Avatar = Avatar
        this.Time = Time
        this.Content = Content
        this.ID = ID
        this.Repo = Repo
        this.Branch = Branch
    }
}
class FreeGames
{
    /**
     * 
     * @param {_Client} client 
     */
    constructor(client)
    {
        this.client = client;
        this.update()
        setTimeout(() => {
            this.update();
        }, 3*60*1000);
    }
    async update()
    {
        const channels = await channelM.find({for:'freegames'}).then(channels=>{return channels});
        this.channels = await this.resolveChannels(channels);
        
        const Res = await fetch('https://www.gamerpower.com/api/giveaways').then(handleResponse)
            .then(handleData)
            .catch(handleError);
        function handleResponse(response) 
        {
            return response.json().then(function (json) 
            {
                    return response.ok ? json : Promise.reject(json);
            });
        }
        function handleError(error) {
            return error;
        }
        function handleData(data) {
            data.splice(10, data.length-10);
            return data
        }
        //if(!Res.length) console.log('FrameWork -> FreeGames: Res:',Res);
        if(!Res.length) return setTimeout(() => 
        {
            this.update();
        }, 60*1000); 
        for(var j = 0; j<this.channels.length; j++)
        { 
            const Pos = Res.map(e => e.id).indexOf(this.channels[j].lastid);
            Res.splice(Pos, Res.length-Pos)

            for(var i = Res.length-1; i>0; i--)
            {
                if(Res[i].id > this.channels[j].lastid)
                {
                    send(
                    {
                        ID:Res[i].id, //
                        Title:Res[i].title, //
                        Type:Res[i].type, //
                        Thumb:Res[i].thumbnail, //
                        Image:Res[i].image, //
                        Description:Res[i].description, //
                        Instructions:Res[i].instructions,//
                        URL:Res[i].open_giveaway_url,//
                        Platform:Res[i].platforms,//
                        EndDate:Res[i].end_date,
                        
                    }, this.channels[j].cID, this.client);
                }
            }
        }
        /**
         * 
         * @param {FreeGameModel} game 
         * @param {Channel} channel 
         */
        function send(game, channel, client)
        {
            client.channels.cache.get(channel).send({embeds:[
                new EmbedBuilder()
                .setColor(0x2d9134)
                .setURL(game.URL)
                .setTitle(game.Title)
	            .setAuthor({name:"Rem-chan", iconURL:"https://i.imgur.com/g6FSNhL.png",url:'https://rem.wordfights.com/addtodiscord'})
                .setDescription(game.Description)
                .setImage(game.Image)
                .setThumbnail(game.Thumb)
                .addFields(
                    { name: 'Platforms', value: game.Platform},
                    { name: 'Type of offer:', value: game.Type},
                    { name:'Instructions:', value:game.Instructions},
                    { name:`End date:`, value:`${game.EndDate}`},
                    )
                .setTimestamp()
                .setFooter({text:`(${game.ID}) Rem-chan on `, iconURL:"https://i.imgur.com/g6FSNhL.png"})
            ]});
        }
    }
    /**
     * 
     * @param {channelM} channels 
     */
    async resolveChannels(channels)
    {
        for await(var channel of channels )
        {
            if(this.client.channels.cache.get(channel.cID))
            {
                const Channel = this.client.channels.cache.get(channel.cID)
                const lastid = await Channel.messages.fetch({limit:1}).then(message=>
                    {
                        if(!message) return 0
                        const [content] = message.values();
                        if(!content||!content.embeds||!content.embeds.length>0) return 0;
                        return parseInt(content.embeds[0].footer.text.split('(')[1].split(')')[0])
                    })
                    channel.lastid = lastid;  
            }
        }
        return channels;
    }
}

class FreeGameModel
{
    /** 
     * @param {String} ID 
     * @param {String} Title 
     * @param {String} Thumb 
     * @param {String} Type
     * @param {String} Image 
     * @param {String} Description 
     * @param {String} Instructions 
     * @param {String} URL 
     * @param {String} Platform 
     * @param {Date} EndDate 
     */
    constructor(ID, Title, Thumb,Type, Image, Description, Instructions, URL, Platform, EndDate)
    {
        this.ID = ID;
        this.Title = Title;
        this.Type = Type;
        this.Thumb = Thumb;
        this.Image = Image;
        this.Description = Description;
        this.Instructions = Instructions;
        this.URL = URL;
        this.Platform = Platform;
        this.EndDate = EndDate;
    }
}
const strikesM = require('./models/strikes');
const guildsM = require('./models/guilds');
class Strikes
{
    constructor(client)
    {
        this.client = client;
        this.check();
         setInterval(() => {
             this.check();
         }, 5*60*1000);

        //TODO: Handle old strikes
        //* Strikes life time should be difined by guild
        //* A default should be set
        //? 15 days

    }
    async check()
    {
        const Strikes = await strikesM.find().then(s=>{return s});
        //console.log(Strikes);
        const guilds = await guildsM.find({strikes:true}).then(g=>{return g});
        if(!guilds) return console.log('Striker: No Guilds')
        var guildIds = [];
        for(var i = 0; i<guilds.length; i++)
        {
            guildIds.push(guilds[i].gID);
        }
        var filtered = Strikes.filter(
            (e) => {
              return guildIds.indexOf(e.guildID)>=0;
            }            
          )
        guildIds.forEach(guild=>
            {
                filtered.forEach(strike=>
                    {
                        (async (guild, strike)=>
                        {
                            const ammount = await strikesM.find({guildID:guild, strokedID:strike.strokedID}).then(res=>{return res.length}); 
                            if(ammount>2) 
                            {
                                this.handleStroked(strike.strokedID, guild);
                            }
                        })(guild, strike)
                    })
            })
    }
    handleStroked(user, guild)
    {    
        strikesM.deleteMany({ guildID: guild, strokedID: user }, (err, res) => {
            if (!err) return console.log('Strikes Deleted')
          });
        // If the user is found, kick them from the server
        const member = this.client.guilds.cache.get(guild).members.cache.get(user);
        if (!member) return console.log('Strikes: Handle Strikened: Member not valid')
        console.log(member.user.username)
        member.kick('Optional reason that will be displayed in the audit logs')
            .then(() => console.log(`Successfully kicked ${user.user.username}`))
            .catch(err => console.log(`Unable to kick ${user.user.username}: ${err}`));
    } 
}