require('dotenv').config()
const {
    Telegraf,
    Markup
} = require('telegraf')
const shortid = require('shortid');
const voucher_codes = require('voucher-code-generator');
const { createCanvas, loadImage } = require('canvas');
const fs = require('fs')
const bot = new Telegraf(process.env.BOT_TOKEN)
const weaponshop = require('./json/weaponshop.json')
const slots = require('./json/slots.json')
const rarecars = require('./json/rarecars.json')
const simplecars = require('./json/simplecars.json')
const houses = require('./presets/houses.json')
const cars = require('./presets/cars.json')
const phones = require('./presets/mobiles.json')
const weapons = require('./presets/weapons.json')
const equipment = require('./presets/equipment.json')
const sequelize = require('./db');
const { Op } = require('sequelize');
const UserModel = require('./models/user.model');
const WorldModel = require('./models/world.model');
const JobModel = require('./models/job.model');
const PropertyModel = require('./models/property.model');
const BusinessModel = require('./models/business.model');
const ReportModel = require('./models/report.model');
const BlockModel = require('./models/block.model');
const PromocodeModel = require('./models/promocode.model');
const mainChat = -1001895132127
const adminList = [275416286]
const expToUp = [0, 10, 20, 40, 60, 100, 250, 370, 450, 575, 666, 777, 860, 999, 1000, 1177, 1234, 1350, 1488, 1515, 1610]
const topSym = ['🥇', '🥈', '🥉', '4️⃣', '5️⃣', '6️⃣', '7️⃣', '8️⃣', '9️⃣', '🔟']

const start = async () => {
    try {
        await sequelize.authenticate()
        await sequelize.sync()
    } catch (e) {
        console.log('Подключение к бд сломалось', e)
    }
}

bot.telegram.setMyCommands([{
        command: "pay",
        description: "Перевести указанному пользователю сумму."
    },
    {
        command: "buy",
        description: "Приобрести указанное имущество."
    },
    {
        command: "business",
        description: "Создать организацию."
    },
    {
        command: "invite",
        description: "Пригласить пользователя в организацию."
    },
    {
        command: "percent",
        description: "Установить пользователю процент заработка."
    },
    {
        command: "report",
        description: "Создать жалобу/обращение/идею."
    }
])

bot.use(async (ctx, next) => {
    let id = ctx.from.id
    let username = ctx.from.username
    if(username == null) username = ctx.from.id
    try {
      console.log(getCurrentTime() + `: ` + username + `: ` + ctx.update.message.text)
    } catch (e) {
        console.log(getCurrentTime() + `: ${username}: ${ctx.update.callback_query.data}`)
    }
    let user = await UserModel.findByPk(id);
    let block = await BlockModel.findByPk(id);
    let property = await PropertyModel.findByPk(id);
    if (!user) ctx.reply(`❕ Первичная регистрация профиля.`);
    if (user === null) {
        await UserModel.create({
            telegram_id: id,
            username: username,
            name: ctx.from.first_name
        })
    } else {
      user.name = ctx.from.first_name
      if(user.username === null) user.username = ctx.from.id
      user.save()
    }
    if (property === null) {
        await PropertyModel.create({
            telegram_id: id
        })
    } else {}
    //if (whitelist.includes(id) == false) return ctx.reply(`У вас пока нет доступа к боту. Следите за обновлениями в группе: t.me/CampFireGameBotNews`)
    if (block !== null) {
        if (block.isBlocked == true && block.time > Date.now() / 1000) return ctx.reply(`📛 У вас активная блокировка по причине: ${block.reason}.\n⏲️ Оставшееся время: ${Math.trunc((block.time - Date.now()/1000)/60)} мин.`)
        block.isBlocked = false
        block.save()
    }
    const start = Date.now()
    return next().then(() => {
        const ms = Date.now() - start
        console.log('response time %sms', ms)
    })
})

bot.command('start', async (ctx) => {
    if (ctx.payload) {
        let id = ctx.from.id
        let user = await UserModel.findByPk(id);
        if (user.level == 1) {
            let ref = await UserModel.findByPk(ctx.payload)
            let world = await WorldModel.findByPk(1)
            world.balance -= 25000
            ref.money += Number(25000)
            await ref.save()
            await world.save()
            bot.telegram.sendMessage(ref.telegram_id, `${ctx.from.username} зарегистрировался по вашей реферальной ссылке. Получено ¤25.000`)
            console.log("Transaction to Ref")
        } else {
            console.log("Exist")
        }
    }
    return await ctx.reply('Главное меню', Markup
        .keyboard([
            ['😎 Профиль'], // Row1 with 2 buttons
            ['🗄️ Работать', '🌐 Организация', '🎁 Бонус', '🏯 Казино'], // Row2 with 2 buttons
            ['📦 Контейнеры'],
            ['📢 Вакансии', '🔵 Имущество', '📞 Пригласить'] // Row3 with 3 buttons
        ])
        .resize()
    )
})

bot.hears('▶️ Меню', async (ctx) => {
    return await ctx.reply('Main Menu', Markup
        .keyboard([
            ['😎 Профиль'],
            ['🗄️ Работать', '🌐 Организация', '🎁 Бонус', '🏯 Казино'],
            ['📦 Контейнеры'],
            ['📢 Вакансии', '🔵 Имущество', '📞 Пригласить']
        ])
        .resize()
    )
});

bot.hears('Чат', async (ctx) => {
    ctx.telegram.sendMessage(mainChat, `Automatic message`)
});

bot.hears('😎 Профиль', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id);
    let property = await PropertyModel.findByPk(ctx.from.id);
    if (!user) return ctx.reply(`Ошибка #1`);
    return ctx.replyWithMarkdownV2(`
      👤${escape(user.username)} ${user.status == 'bronze' ? `\\[🔺\\]` : ""}${user.status == 'silver' ? `\\[🔹\\]` : ""}${user.status == 'gold' ? `\\[🔸\\]` : ""}${user.status == 'admin' ? "✅" : ""}
      🆔: ${ctx.from.id}

      📶 Уровень: ${user.level} \\| ${user.exp} / ${expToUp[user.level]}
      ⏩ Повышается за различные действия\\.
      
      💰 Баланс
      ¤${spacesWithMarkdown(user.money)}

      🔵 Имущество
      🏠 Жилье: ${property.house == 0 ? "Бездомный" : property.house.name}
      🚗 Автомобиль: ${property.car == 0 ? "Пешком" : escape(property.car.name)}
      📱 Телефон: ${property.mobile == 0 ? "Нет" : property.mobile.name}
      🔫 Оружие: ${property.weapon == 0 ? "Безоружный" : property.weapon.name}
      🥼 Экипировка: ${property.equipment == 0 ? "Нет" : property.equipment.name}
      `);

});

bot.command('getprofile', async (ctx) => {
    if(!ctx.message.reply_to_message) return await ctx.reply(`Только на пересланное сообщение.`)
    let id = ctx.message.reply_to_message.from.id
    let user = await UserModel.findByPk(id);
    let property = await PropertyModel.findByPk(id);
    return ctx.replyWithMarkdownV2(`
      👤${escape(user.username)} ${user.status == 'bronze' ? `\\[🔺\\]` : ""}${user.status == 'silver' ? `\\[🔹\\]` : ""}${user.status == 'gold' ? `\\[🔸\\]` : ""}${user.status == 'admin' ? "Administrator" : ""}
      🆔: ${ctx.from.id}

      📶 Уровень: ${user.level} \\| ${user.exp} / ${expToUp[user.level]}
      ⏩ Повышается за различные действия\\.
      
      💰 Баланс
      ¤${spacesWithMarkdown(user.money)}

      🔵 Имущество
      🏠 Жилье: ${property.house == 0 ? "Бездомный" : property.house.name}
      🚗 Автомобиль: ${property.car == 0 ? "Пешком" : property.car.name}
      📱 Телефон: ${property.mobile == 0 ? "Нет" : property.mobile.name}
      🔫 Оружие: ${property.weapon == 0 ? "Безоружный" : property.weapon.name}
      🥼 Экипировка: ${property.equipment == 0 ? "Нет" : property.equipment.name}
      `);

});

bot.hears('Рандом', async (ctx) => {
    let users = await UserModel.findAll();
    let chosenOne = users.random()
    return ctx.reply(`
      👤 ${chosenOne.username} 
      🆔: ${chosenOne.telegram_id}
      `);

});

bot.hears('💳 Баланс', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id);
    return ctx.reply(`
      ⏩ Аккаунт игрока ${user.username}
      🆔 Игрока: ${user.telegram_id}

      📶 Уровень: ${user.level}
      ⏩ Повышается за различные действия.

      💰 Баланс: 
      ¤${user.money}
    `);
})

bot.hears('🎁 Бонус', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id);
    if (!user) return ctx.reply(`Ошибка #1`);
    let bonustime = user.bonustime
    let cooldown = setCooldown(user, 3600, bonustime)
    if (user.bonustime > cooldown.currentTime) return ctx.reply(`📛 Забрать бонус можно будет через ${cooldown.timeLeftInMinutes} минут(у/ы)`);
    user.bonus = 1;
    user.bonustime = cooldown.endTime
    let world = await WorldModel.findByPk(1)
    let text = ``;
    let money = [100, 200, 300, 400, 500, 1000].random();
    if (user.level >= 5) {
        money += money;
    }
    let r = rand(1, 2);
    let x = rand(2, 7);
    if (r == 1) {
        text += `⏩ ¤${money}\n`;
    }
    if (r == 2) {
        money = money*x
        text += `⏩ ¤${money}\n`;
    }
    switch(user.status){
        case 'bronze':
            user.money += 5000
            text += `⭐ Дополнительный бонус за Bronze:\n⏩ ¤5.000\n`
            break;
        case 'silver':
            user.money += 15000
            text += `⭐ Дополнительный бонус за Silver:\n⏩ ¤15.000\n`
            break;
        case 'gold':
            user.money += 30000
            text += `⭐ Дополнительный бонус за Gold:\n⏩ ¤30.000\n`
            break;
    }
    user.money += money;
    world.balance -= money
    if (user.business.id == 0){
      await user.save();
      await world.save();
      return ctx.reply(`
      ⭐ Из ежечасного бонуса Вам выпало:
${text}
      `)
    }
    let business = await BusinessModel.findOne({
      where: {
        owner: user.business.id
      }
    })
    if(business != null){
      let mats = rand(3, 10)
      switch(user.status){
        case 'bronze':
            business.materials += 5
            text += `⭐ Дополнительный бонус за Bronze:\n⏩ 5 материалов\n`
            break;
        case 'silver':
            business.materials += 10
            text += `⭐ Дополнительный бонус за Silver:\n⏩ 10 материалов\n`
            break;
        case 'gold':
            business.materials += 20
            text += `⭐ Дополнительный бонус за Gold:\n⏩ 20 материалов\n`
            break;
    }
      text += `⏩ ${mats} материалов в организацию\n`
      business.materials += mats
      business.save()
    }
    await user.save();
    await world.save();
    return ctx.reply(`
      ⭐ Из ежечасного бонуса Вам выпало:
${text}
      `)
})

bot.command('pay', async (ctx) => {
    ctx.args = ctx.update.message.text.split(' ')
    if (!ctx.args[1] || !ctx.args[2]) return ctx.reply(`/pay [Никнейм] [Сумма]`)
    if (!Number(ctx.args[2])) return ctx.reply(`❕ Сумма должна быть числовая.`)
    let sender = await UserModel.findByPk(ctx.from.id);
    let receiver = await UserModel.findOne({
        where: {
            username: ctx.args[1]
        }
    });
    let world = await WorldModel.findByPk(1)
    let fee = Number(Math.trunc(ctx.args[2] / 100 * world.transactionfee))
    if (ctx.args[2] == 0 || ctx.args[2] < 100) return ctx.reply(`❕ Минимальная сумма перевода ¤100.`)
    if (sender.money < ctx.args[2]) return ctx.reply(`❕ Недостаточно средств!`)
    if (sender.money < Number(ctx.args[2]) + fee) return ctx.reply(`❕ Недостаточно средств для перевода с комиссией!`)
    sender.money -= Number(ctx.args[2])
    sender.money -= Number(fee)
    world.balance += Number(fee)
    await sender.save();
    await world.save();
    receiver.money += Number(ctx.args[2])
    await receiver.save();
    let pmToReceiver = `🔽 Входящий перевод.\n\n🔼 Отправитель: ${sender.username}\n🆔 Отправителя: ${sender.telegram_id}\n🔢 Сумма: ¤${ctx.args[2]}\n🆕 Ваш баланс: ¤${receiver.money}
    `
    bot.telegram.sendMessage(receiver.telegram_id, pmToReceiver)
    return ctx.reply(`🔼 Исходящий перевод.\n\n🔽 Получатель: ${receiver.username}\n🆔 Получателя: ${receiver.telegram_id}\n🔢 Сумма: ¤${ctx.args[2]}\nℹ️ Комиссия: ¤${fee}\n🆕 Ваш баланс: ¤${sender.money}
      `)
})

bot.hears('Мир', async (ctx) => {
    let world = await WorldModel.findByPk(1)
    return ctx.reply(`🔰 Баланс мира: ¤${spaces(world.balance)}\nℹ️ Стоимость материалов: ¤${spaces(world.matPrice)}
      `)
})

bot.hears('📞 Пригласить', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id);
    return ctx.reply(`
    ℹ️ Для приглашения друга по реферальной системе, отправьте ему ссылку-приглашение 
Как только он перейдет по ней и начнет игру, Вы получите ¤25.000.

Ваша ссылка: https://t.me/CampFireGameBot?start=${user.telegram_id}
      `)
})

bot.hears('📢 Вакансии', async (ctx) => {
    return await ctx.reply('Список работы', Markup
        .inlineKeyboard([
            [{
                text: `Дворник [1 уровень]`,
                callback_data: 'job_1'
            }, {
                text: `Промоутер [1 уровень]`,
                callback_data: 'job_2'
            }], [{
                text: `Официант [2 уровень]`,
                callback_data: 'job_3'
            }, {
                text: `Бармен [3 уровень]`,
                callback_data: 'job_4'
            }], [{
                text: `Кассир [4 уровень] `,
                callback_data: 'job_5'
            }, {
                text: `ПВЗ Дикие Ягоды [4 уровень]`,
                callback_data: 'job_6'
            }], [{
                text: `Слесарь [5 уровень]`,
                callback_data: 'job_7'
            }], [{
                text: `💤 Уволиться`,
                callback_data: 'job_leave'
            }]
        ])
        .resize()
    )
})

bot.action(/job_(1|2|3|4|5|6|7|leave)/, async (ctx) => {
    let data = ctx.update.callback_query.data;
    let user = await UserModel.findByPk(ctx.from.id);
    let job = null
    switch(data){
        case `job_1`:
            job = await JobModel.findByPk(1);
            if (user.level < job.level) {
                return await ctx.reply(`❕ У вас не хватает уровня для этой работы.`)
            }
            if (user.job == 0) {
                user.job = 1
                user.save()
                return await ctx.reply(`ℹ️ Вы устроились на работу дворником.\nВаш оклад: ¤${job.salary}\nПриступайте к работе командой "Работать"`)
            }
            return await ctx.reply(`❕ Вы уже устроены на другую работу`)
        case `job_2`:
            job = await JobModel.findByPk(2);
            if (user.level < job.level) {
                return await ctx.reply(`❕ У вас не хватает уровня для этой работы.`)
            }
            if (user.job == 0) {
                user.job = 2
                user.save()
                return await ctx.reply(`ℹ️ Вы устроились на работу промоутером. \nВаш оклад: ¤${job.salary}\nПриступайте к работе командой "Работать"`)
            }
            return await ctx.reply(`❕ Вы уже устроены на другую работу`)
        case `job_3`:
            job = await JobModel.findByPk(3);
            if (user.level < job.level) {
                return await ctx.reply(`❕ У вас не хватает уровня для этой работы.`)
            }
            if (user.job == 0) {
                user.job = 3
                user.save()
                return await ctx.reply(`ℹ️ Вы устроились на работу официантом. \nВаш оклад: ¤${job.salary}\nПриступайте к работе командой "Работать"`)
            }
            return await ctx.reply(`❕ Вы уже устроены на другую работу`)
        case `job_4`:
            job = await JobModel.findByPk(4);
            if (user.level < job.level) {
                return await ctx.reply(`❕ У вас не хватает уровня для этой работы.`)
            }
            if (user.job == 0) {
                user.job = 4
                user.save()
                return await ctx.reply(`ℹ️ Вы устроились на работу барменом. \nВаш оклад: ¤${job.salary}\nПриступайте к работе командой "Работать"`)
            }
            return await ctx.reply(`❕ Вы уже устроены на другую работу`)
        case `job_5`:
            job = await JobModel.findByPk(5);
            if (user.level < job.level) {
                return await ctx.reply(`❕ У вас не хватает уровня для этой работы.`)
            }
            if (user.job == 0) {
                user.job = 5
                user.save()
                return await ctx.reply(`❕ Вы устроились на работу кассиром. \nВаш оклад: ¤${job.salary}\nПриступайте к работе командой "Работать"`)
            }
            return await ctx.reply(`ℹ️ Вы уже устроены на другую работу`)
        case `job_6`:
            job = await JobModel.findByPk(6);
            if (user.level < job.level) {
                return await ctx.reply(`❕ У вас не хватает уровня для этой работы.`)
            }
            if (user.job == 0) {
                user.job = 6
                user.save()
                return await ctx.reply(`ℹ️ Вы устроились на работу в ПВЗ Дикие Ягоды. \nВаш оклад: ¤${job.salary}\nПриступайте к работе командой "Работать"`)
            }
            return await ctx.reply(`❕ Вы уже устроены на другую работу`)
        case `job_7`:
            job = await JobModel.findByPk(7);
            if (user.level < job.level) {
                return await ctx.reply(`❕ У вас не хватает уровня для этой работы.`)
            }
            if (user.job == 0) {
                user.job = 7
                user.save()
                return await ctx.reply(`ℹ️ Вы устроились на работу слесарем. \nВаш оклад: ¤${job.salary}\nПриступайте к работе командой "Работать"`)
            }
            return await ctx.reply(`❕ Вы уже устроены на другую работу`)
        case `job_leave`:
            if (user.job != 0) {
                user.job = 0
                user.save()
                return await ctx.reply(`ℹ️ Теперь вы безработный.`)
            }
            return await ctx.reply(`❕ Вы итак безработный.`)
    }
})

bot.hears('🏯 Казино', async (ctx) => {
    return await ctx.reply('🏯 Добро пожаловать в казино "杜明"\n', Markup
        .keyboard([
            ['🎰 Слоты'],
            ['▶️ Меню']
        ])
        .resize()
    )
})

bot.hears('🗄️ Работать', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id);
    let job = await JobModel.findByPk(user.job);
    let world = await WorldModel.findByPk(1)
    let timer = user.jobtime
    let cooldown = setCooldown(user, 3600, timer)
    if (user.jobtime > cooldown.currentTime) return ctx.reply(`📛 Работать можно будет через ${cooldown.timeLeftInMinutes} минут(у/ы)`);
    if (user.job == 0) {
        return await ctx.reply(`📛 Вы безработный.`)
    }
    user.jobtime = Number(cooldown.endTime)
    let jobExp = job.exp;
    user.jobcheck++
    switch (user.job) {
        case 1:
            if (user.jobcheck >= 4) {
                let paydayfee = job.salary / 100 * world.transactionfee
                let payday = job.salary - paydayfee
                world.balance -= payday
                user.money += payday
                giveExp(user, jobExp)
                user.jobcheck = 0
                user.save()
                world.save()
                return ctx.reply(`👔 Вы отработали смену дворника. \n🧾 Расчетный лист: \n⏳ Отработано часов: 4/4 \n💸 Оклад: ¤${job.salary} \nℹ️ Подоходный налог: ${world.transactionfee}% \n💹 К выплате: ¤${payday}`)
            } else {
                user.save()
                return ctx.reply(`👔 Вы подмели дворы. \n⏳ Отработано часов: ${user.jobcheck}/4`)
            }
            break;
        case 2:
            if (user.jobcheck >= 2) {
                let paydayfee = job.salary / 100 * world.transactionfee
                let payday = job.salary - paydayfee
                world.balance -= payday
                user.money += payday
                giveExp(user, jobExp)
                user.jobcheck = 0
                user.save()
                world.save()
                return ctx.reply(`👔 Вы отработали смену промоутера. \n🧾 Расчетный лист: \n⏳ Отработано часов: 2/2 \n💸 Оклад: ¤${job.salary} \nℹ️ Подоходный налог: ${world.transactionfee}% \n💹 К выплате: ¤${payday}`)
            } else {
                user.save()
                return ctx.reply(`👔 Вы раздавали листовки целый час. \n⏳ Отработано часов: ${user.jobcheck}/2`)
            }
            break;
        case 3:
            if (user.jobcheck >= 4) {
                let paydayfee = job.salary / 100 * world.transactionfee
                let payday = job.salary - paydayfee
                world.balance -= payday
                let tips = [50, 100, 200, 500, 1000].random()
                user.money += tips
                user.money += payday
                giveExp(user, jobExp)
                user.jobcheck = 0
                user.save()
                world.save()
                return ctx.reply(`👔 Вы отработали смену официанта. \n🧾 Расчетный лист: \n⏳ Отработано часов: 4/4 \n💸 Оклад: ¤${job.salary} \nℹ️ Подоходный налог: ${world.transactionfee}% \n💹 К выплате: ¤${payday} \n💰 Получено чаевых: ¤${tips}`)
            } else {
                let tips = [50, 100, 200, 500, 1000].random()
                user.money += tips
                user.save()
                return ctx.reply(`👔 Вы целый час бегали и отрабатывали заказы. \n🧾 Получено чаевых: ¤${tips} \n⏳ Отработано часов: ${user.jobcheck}/4`)
            }
            break;
        case 4:
            if (user.jobcheck >= 5) {
                let paydayfee = job.salary / 100 * world.transactionfee
                let payday = job.salary - paydayfee
                world.balance -= payday
                let tips = [50, 100, 200, 300, 500, 1000, 2000].random()
                world.balance -= tips
                user.money += tips
                user.money += payday
                giveExp(user, jobExp)
                user.jobcheck = 0
                user.save()
                world.save()
                return ctx.reply(`👔 Вы отработали смену бармена. \n🧾 Расчетный лист: \n⏳ Отработано часов: 5/5 \n💸 Оклад: ¤${job.salary} \nℹ️ Подоходный налог: ${world.transactionfee}% \n💹 К выплате: ¤${payday} \n💰 Получено чаевых: ¤${tips}`)
            } else {
                let tips = [50, 100, 200, 300, 500, 1000, 2000].random()
                world.balance -= tips
                user.money += tips
                user.save()
                world.save()
                return ctx.reply(`👔 Вы целый час стояли за стойкой и разливали пойло. \n🧾 Получено чаевых: ¤${tips} \n⏳ Отработано часов: ${user.jobcheck}/5`)
            }
            break;
        case 5:
            if (user.jobcheck >= 5) {
                let paydayfee = job.salary / 100 * world.transactionfee
                let payday = job.salary - paydayfee
                world.balance -= payday
                user.money += payday
                giveExp(user, jobExp)
                user.jobcheck = 0
                user.save()
                world.save()
                return ctx.reply(`👔 Вы отработали смену кассира. \n🧾 Расчетный лист: \n⏳ Отработано часов: 5/5 \n💸 Оклад: ¤${job.salary} \nℹ️ Подоходный налог: ${world.transactionfee}% \n💹 К выплате: ¤${payday}`)
            } else {
                user.save()
                return ctx.reply(`👔 Вы целый час обслуживали покупателей и кричали: "Гаааляяя, отмена!". \n⏳ Отработано часов: ${user.jobcheck}/5`)
            }
            break;
        case 6:
            if (user.jobcheck >= 6) {
                let paydayfee = job.salary / 100 * world.transactionfee
                let payday = job.salary - paydayfee
                let stealed = [{
                    name: "Помада",
                    price: 200
                }, {
                    name: "Бюстгалтер",
                    price: 1300
                }, {
                    name: "Прокладки",
                    price: 250
                }, {
                    name: "Перцовый балончик",
                    price: 600
                }, {
                    name: "Гитара",
                    price: 6500
                }, {
                    name: "Комбик",
                    price: 9000
                }, {
                    name: "Кроссовки",
                    price: 2000
                }, {
                    name: "Шампунь",
                    price: 180
                }, {
                    name: "Смартфон Texno",
                    price: 6999
                }, {
                    name: "TWS Гарнитура",
                    price: 2800
                }, {
                    name: "Геймпад GameStation 5",
                    price: 1400
                }, {
                    name: "Дилдо",
                    price: 600
                }, {
                    name: "Вагиноимитатор",
                    price: 600
                }].random()
                world.balance -= payday
                world.balance -= Number(stealed.price)
                user.money += payday
                user.money += Number(stealed.price)
                giveExp(user, jobExp)
                user.jobcheck = 0
                user.save()
                world.save()
                return ctx.reply(`👔 Вы отработали смену в Диких Ягодах. \n🧾 Расчетный лист: \n⏳ Отработано часов: 6/6 \n💸 Оклад: ¤${job.salary} \nℹ️ Подоходный налог: ${world.transactionfee}% \n💹 К выплате: ¤${payday} \n💰 Вы украли и продали со склада: ${stealed.name} (¤${stealed.price})`)
            } else {
                user.save()
                return ctx.reply(`👔 Вы целый час выдавали заказы в Диких Ягодах. \n⏳ Отработано часов: ${user.jobcheck}/6`)
            }
            break;
        case 7:
            if (user.jobcheck >= 6) {
                let paydayfee = job.salary / 100 * world.transactionfee
                let payday = job.salary - paydayfee
                world.balance -= payday
                user.money += payday
                giveExp(user, jobExp)
                user.jobcheck = 0
                user.save()
                world.save()
                return ctx.reply(`👔 Вы отработали смену слесарем. \n🧾 Расчетный лист: \n⏳ Отработано часов: 6/6 \n💸 Оклад: ¤${job.salary} \nℹ️ Подоходный налог: ${world.transactionfee}% \n💹 К выплате: ¤${payday}`)
            } else {
                user.save()
                return ctx.reply(`👔 Вы целый час работали на заводе, вы молодец! \n⏳ Отработано часов: ${user.jobcheck}/6`)
            }
            break;
    }
})

bot.hears('Топ', async (ctx) => {
    let topPlayer = await UserModel.findAll({
        attributes: ['username', [sequelize.fn('sum', sequelize.col('money')), 'money'], 'status'],
        group: ['username', 'status'],
        where: {
            telegram_id: {
                [Op.ne]: 275416286
            }
        },
        order: [
            [sequelize.literal('money'), 'DESC']
        ],
        limit: 10
    })
    let text = `🏆 Топ 10 игроков по балансу.\n\n`
    for(i=0; i<topPlayer.length; i++){
        text += `${topSym[i]}. ${topPlayer[i].status == 'bronze' ? `[🔺]` : ""}${topPlayer[i].status == 'silver' ? `[🔹]` : ""}${topPlayer[i].status == 'gold' ? `[🔸]` : ""} ${topPlayer[i].username} [¤${spaces(topPlayer[i].money)}]\n`
    }
    return await ctx.reply(text)

})

bot.hears('🔵 Имущество', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id);
    return await ctx.reply(`Выберите тип`, Markup
        .inlineKeyboard([
            [
            {text: 'Жилье', callback_data: `shop_house`}, 
            {text: 'Телефоны', callback_data: `shop_phone`}, 
            {text: 'Автосалон', callback_data: `shop_car`}
        ]
        ])
        .resize())
})

bot.action('shopmenu', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id);
    return await ctx.editMessageText(`Выберите тип`, Markup
        .inlineKeyboard([
            [
            {text: 'Жилье', callback_data: `shop_house`}, 
            {text: 'Телефоны', callback_data: `shop_phone`}, 
            {text: 'Автосалон', callback_data: `shop_car`}
        ]
        ])
        .resize())
})

bot.action(/shop_(house|phone|car)/, async (ctx) => {
    let data = ctx.update.callback_query.data;
    let prodArray = []
    let text = `Доступно к покупке:\n`
    switch(data){
        case `shop_house`:
            for (i in houses) {
                prodArray.push({text: i, callback_data: `{"action": "buy", "type": "house", "value": "${i}"}`})
                text += i + `. ${houses[i].name} (¤${houses[i].price})\n`
            }
        break;
        case `shop_phone`:
            for (i in phones) {
                prodArray.push({text: i, callback_data: `{"action": "buy", "type": "phone", "value": "${i}"}`})
                text += i + `. ${phones[i].name} (¤${phones[i].price})\n`
            }
        break;
        case `shop_car`:
            for (i in cars) {
                prodArray.push({text: i, callback_data: `{"action": "buy", "type": "car", "value": "${i}"}`})
                text += i + `. ${cars[i].name} (¤${cars[i].price})\n`
            }
        break;
    }
    prodArray.push({text: `Назад`, callback_data: `shopmenu`})
    let rows = []
    while (prodArray.length > 0) {
        rows.push(prodArray.splice(0, 5)) // разбиваем на подмассивы по 5 кнопок
    }
    return await ctx.editMessageText(text, Markup
        .inlineKeyboard(rows)
        .resize())
})

bot.action(/{"action": "buy"*/, async (ctx) => {
    let data = ctx.update.callback_query.data;
    data = JSON.parse(data)
    let user = await UserModel.findByPk(ctx.from.id)
    let property = await PropertyModel.findByPk(ctx.from.id);
    let world = await WorldModel.findByPk(1)
    if (data.type == "house") {
        if (user.money < houses[data.value].price) return await ctx.reply(`У вас недостаточно средств!`)
        if (property.house.name) return await ctx.reply(`У вас уже есть дом.`)
        user.money -= houses[data.value].price
        world.balance += houses[data.value].price
        property.house = houses[data.value]
        await user.save()
        await world.save()
        await property.save()
        return await ctx.reply(`Вы купили ${houses[data.value].name}`)
    }
    if (data.type == "car") {
        if (user.money < cars[data.value].price) return await ctx.reply(`У вас недостаточно средств!`)
        if (property.car.name) return await ctx.reply(`У вас уже есть автомобиль.`)
        if (!property.house.name) return await ctx.reply(`Для покупки автомобиля, у Вас должен быть дом.`)
          user.money -= cars[data.value].price
          world.balance += cars[data.value].price
          property.car = cars[data.value]
          await user.save()
          await world.save()
          await property.save()
          return await ctx.reply(`Вы купили ${cars[data.value].name}`)
      }
      if (data.type == "phone") {
        if (user.money < phones[data.value].price) return await ctx.reply(`У вас недостаточно средств!`)
        if (property.mobile.name) return await ctx.reply(`У вас уже есть телефон.`)
          user.money -= phones[data.value].price
          world.balance += phones[data.value].price
          property.mobile = phones[data.value]
          await user.save()
          await world.save()
          await property.save()
          return await ctx.reply(`Вы купили ${phones[data.value].name}`)
      }
      if (data.type == "equipment") {
        if (user.money < weaponshop[data.value].price) return await ctx.reply(`У вас недостаточно средств!`)
          if (data.type == weaponshop[data.value].type) {
              if (property.equipment.name) return await ctx.reply(`У вас уже есть экипировка.`)
              user.money -= weaponshop[data.value].price
              world.balance += weaponshop[data.value].price
              property.equipment = weaponshop[data.value]
              await user.save()
              await world.save()
              await property.save()
              return await ctx.reply(`Вы купили ${weaponshop[data.value].name}`)
          }
          if (property.weapon.name) return await ctx.reply(`У вас уже есть оружие.`)
          user.money -= weaponshop[data.value].price
          world.balance += weaponshop[data.value].price
          property.weapon = weaponshop[data.value]
          await user.save()
          await world.save()
          await property.save()
          return await ctx.reply(`Вы купили ${weaponshop[data.value].name}`)
      }
})

bot.hears('Поставщик', async (ctx) => {
    let text = `[Hatkeis Gunsmith](https://telegra.ph/Hatkeis-Gunsmith-09-27)`
    let shop = `\n  Вы подходите к зданию с вывеской "Ништяки Хаткейса".\n      Вот ассортимент на сегодня\n`
    for (i = 0; i < 10; i++) {
        shop += `${i}. ${weaponshop[i].name} (¤${spaces(weaponshop[i].price)})\n`
    }
    weaponShopUpdate()
    return await ctx.replyWithMarkdownV2(text + escape(shop), {disable_web_page_preview: true})
})

bot.command('sell', async (ctx) => {
    ctx.args = ctx.update.message.text.split(' ')
    let user = await UserModel.findByPk(ctx.from.id)
    let property = await PropertyModel.findByPk(ctx.from.id);
    let world = await WorldModel.findByPk(1)
    if (!ctx.args[1]) return ctx.reply(`Не указан аргумент.`)
    if (ctx.args[1] == "house") {
        if (!property.house.name) return await ctx.reply(`У вас нет дома.`)
        let name = property.house.name
        user.money += Math.round(property.house.price/2)
        world.balance -= Math.round(property.house.price/2)
        property.house = 0
        await user.save()
        await world.save()
        await property.save()
        return await ctx.reply(`Вы продали ${name}`)
    }
    if (ctx.args[1] == "car") {
        if (!property.car.name) return await ctx.reply(`У вас нет автомобиля.`)
        let name = property.car.name
        user.money += Math.round(property.car.price/2)
        world.balance -= Math.round(property.car.price/2)
        property.car = 0
        await user.save()
        await world.save()
        await property.save()
        return await ctx.reply(`Вы продали ${name}`)
    }
    if (ctx.args[1] == "phone") {
        if (!property.mobile.name) return await ctx.reply(`У вас нет телефона.`)
        let name = property.mobile.name
        user.money += Math.round(property.mobile.price/2)
        world.balance -= Math.round(property.mobile.price/2)
        property.mobile = 0
        await user.save()
        await world.save()
        await property.save()
        return await ctx.reply(`Вы продали ${name}`)
    }
    if (ctx.args[1] == "equipment") {
        if (!property.equipment.name) return await ctx.reply(`У вас нет экипировки.`)
        let name = property.equipment.name
        user.money += Math.round(property.equipment.price/2)
        world.balance -= Math.round(property.equipment.price/2)
        property.equipment = 0
        await user.save()
        await world.save()
        await property.save()
        return await ctx.reply(`Вы продали ${name}`)
    }
    if (ctx.args[1] == "weapon") {
        if (!property.weapon.name) return await ctx.reply(`У вас нет оружия.`)
        let name = property.weapon.name
        user.money += Math.round(property.weapon.price/2)
        world.balance -= Math.round(property.weapon.price/2)
        property.weapon = 0
        await user.save()
        await world.save()
        await property.save()
        return await ctx.reply(`Вы продали ${name}`)
    }
})

bot.hears('🌐 Организация', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id)
    if (user.business.id == 0) return await ctx.reply(`Вы не состоите в организации.`)
    let business = await BusinessModel.findOne({
      where: {
        owner: ctx.from.id.toString()
      }
    })
    if(business === null){
      business = await BusinessModel.findOne({
        where: {
        owner: user.business.id
      }
    })
        return await ctx.replyWithMarkdownV2(`🏭 Организация\n_${business.name}_\n💹 Баланс: ¤${escape(spaces(business.balance))}\n🧰 Сырье: ${business.materials}\n👥 Рабочих: ${business.users.length}\n\nВаши отработки: ${user.business.checks}`, Markup.inlineKeyboard([
            [{
                text: `📶 Отработка`,
                callback_data: "workoff"
            }, {
                text: `⬅️ Покинуть`,
                callback_data: "покинуть"
            }]
        ])
        .oneTime()
        .resize())
    }
    if (business.owner == ctx.from.id){
        return await ctx.replyWithMarkdownV2(`🏭 Ваша организация\n_${business.name}_\n💹 Баланс: ¤${escape(spaces(business.balance))}\n🧰 Сырье: ${business.materials}\n👥 Рабочих: ${business.users.length}\n🔨 Отработок: ${business.checks}\n\nВаши отработки: ${user.business.checks}`, Markup.inlineKeyboard([
            [{
                text: `📶 Отработка`,
                callback_data: "workoff"
            }, {
                text: `💸 Payday`,
                callback_data: "payday"
            }]
        ])
        .oneTime()
        .resize())
    }
})

bot.action('workoff', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id)
    let business = await BusinessModel.findOne({
      where: {
        owner: user.business.id.toString()
      }
    })
    if (user.business == null) return await ctx.reply(`Вы не работаете в организации.`)
    let timer = user.worktime
    let cooldown = setCooldown(user, 3600, timer)
    if (user.worktime > cooldown.currentTime) return ctx.telegram.answerCbQuery(ctx.callbackQuery.id, `📛 Работа в организации будет доступна через ${cooldown.timeLeftInMinutes} минут(у/ы)`, {show_alert: true});
    if (business.materials < 10) return ctx.telegram.answerCbQuery(ctx.callbackQuery.id, `📛 В организации недостаточно материалов для отработки.`);
    user.worktime = cooldown.endTime
    user.business = {
        id: user.business.id,
        checks: user.business.checks + 1,
        percent: user.business.percent
    }
    business.materials -= 10
    business.checks += 1
    await user.save()
    await business.save()
    if (business.owner == ctx.from.id){
        return await ctx.editMessageText(`🏭 Ваша организация\n_${business.name}_\n💹 Баланс: ¤${escape(spaces(business.balance))}\n🧰 Сырье: ${business.materials} \n👥 Рабочих: ${business.users.length}\n🔨 Отработок: ${business.checks}\n\nВаши отработки: ${user.business.checks}`,
        { 
            reply_markup: {
                inline_keyboard: [
                    [{
                        text: `📶 Отработка`,
                        callback_data: "workoff"
                    }, {
                        text: `💸 Payday`,
                        callback_data: "payday"
                    }]
                ]},
            parse_mode: `MarkdownV2`
        }
        )
    }else{
        return await ctx.editMessageText(`🏭 Организация\n_${business.name}_\n💹 Баланс: ¤${escape(spaces(business.balance))}\n🧰 Сырье: ${business.materials}\n👥 Рабочих: ${business.users.length}\n\nВаши отработки: ${user.business.checks}`,
        { 
            reply_markup: {
                inline_keyboard: [
                    [{
                        text: `📶 Отработка`,
                        callback_data: "workoff"
                    }, {
                        text: `⬅️ Покинуть`,
                        callback_data: "покинуть"
                    }]
                ]},
            parse_mode: `MarkdownV2`
        }
        ) 
    }
})

bot.action('покинуть', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id)
    if (user.business.id == 0) return await ctx.reply(`Вы не состоите в организации.`)
    let business = await BusinessModel.findOne({
      where: {
        owner: ctx.from.id.toString()
      }
    })
    if(business === null){
      business = await BusinessModel.findOne({
        where: {
        owner: user.business.id
      }
    })
        await ctx.reply(`Подтвердите в личных сообщениях.`)
        return await bot.telegram.sendMessage(ctx.from.id, `🏭 Вы действительно хотите покинуть ${business.name}`, Markup.inlineKeyboard([
            [{
                text: `Да`,
                callback_data: "user_leave_business"
            }, {
                text: `Нет`,
                callback_data: "cancel"
            }]
        ])
        .oneTime()
        .resize()
        )
    }
    if (business.owner == ctx.from.id){
        return await ctx.reply(`Вы не можете покинуть свою организацию.`)
    }
})

bot.action('cancel', async (ctx) => {
    await ctx.deleteMessage()
    await bot.telegram.answerCbQuery(ctx.callbackQuery.id, `Отмена.`)
})

bot.action('user_leave_business', async (ctx) => {
    let data = ctx.update.callback_query.data;
    let user = await UserModel.findByPk(ctx.from.id)
    if (user.business.id == 0) return await ctx.reply(`Вы не состоите в организации.`)
    let business = await BusinessModel.findOne({
        where: {
        owner: user.business.id
      }
    })
    user.business = {
        id: 0,
        checks: 0,
        percent: 0
    }
    business.users = business.users.filter(value => value != ctx.from.id);
    business.save()
    user.save()
    return await bot.telegram.sendMessage(ctx.from.id, `🏭 Вы покинули ${business.name}`)
})

bot.action('payday', async (ctx) => {
    let user = null
    let business = await BusinessModel.findOne({
      where: {
        owner: ctx.from.id.toString()
      }
    })
    let world = await WorldModel.findByPk(1)
    if (business === null) return await ctx.reply(`У вас нет организации.`)
    if (business.checks < 12) return await ctx.reply(`Недостаточно отработок для формирования выплаты.`)
    let percentSum = 0
    let text = ``
    let percentErrorText = ``
    let profit = 0
    let piece = 0
    let moneyList = rand(1000, 3000)
    moneyList = moneyList*business.users.length
    for (i = 0; i < business.users.length; i++) { // Summary percent
        user = await UserModel.findByPk(business.users[i])
        percentSum += Number(user.business.percent)
        percentErrorText += `ℹ️ ${user.username} ${user.business.percent}% [/percent ${user.username} [проценты]]\n`
    }
    if (percentSum > 100) return await ctx.reply(`⚠️ Общий процент всех сотрудников превышает 100%\n    ➕ Остаток процентов перенесется в баланс организации.\n\n${percentErrorText}\n`)
    for (x = 0; x < business.users.length; x++) { // Общая внесенная сумма всеми участниками
        user = await UserModel.findByPk(business.users[x])
        profit += user.business.checks * moneyList * user.level
        text += `ℹ️ ${user.username} отработал ${user.business.checks} раз.\n`
        user.business = {
            id: user.business.id,
            checks: 0,
            percent: user.business.percent
        }
        user.save()
    }
    text += `   💹 Наработка за текущий период: ${profit}\n`
    let profitCheck = profit
    for (n = 0; n < business.users.length; n++) { // Процент выплаты участникам
        user = await UserModel.findByPk(business.users[n])
        piece = Math.round(profit / 100 * user.business.percent)
        profitCheck -= piece
        user.money += piece
        text += `➕ ${user.username} получает ¤${piece}\n`
        await bot.telegram.sendMessage(user.telegram_id, `ℹ️ Директор организации сформировал выплаты.\n➕ На ваш баланс поступило: ${spaces(piece)}`)
        giveExp(user, business.checks)
        user.save()
    }
    if (profitCheck > 0) {
        business.balance += profitCheck
        text += `➕ На баланс бизнеса поступило ¤${profitCheck}`
    }
    business.checks = 0
    business.save()
    console.log(`Payday: ${business.name}\n${text}`)
    return await ctx.reply(text)
})

bot.command('orgmessage', async (ctx) => {
    if (!ctx.args[1]) return ctx.reply(`Не указан аргумент.`)
    let business = await BusinessModel.findOne({
      where: {
        owner: ctx.from.id.toString()
      }
    })
    if (business === null) return await ctx.reply(`У вас нет организации.`)
    for (i = 0; i < business.users.length; i++) {
        user = await UserModel.findByPk(business.users[i])
        await bot.telegram.sendMessage(user.telegram_id, `Директор организации сообщает:\n ${ctx.payload}`)
    }
    console.log(`Директор организации сообщает:\n ${ctx.payload}`)
    return await ctx.reply(`Сообщение отправлено.`)
})

bot.command('materials', async (ctx) => {
    ctx.args = ctx.update.message.text.split(' ')
    let user = await UserModel.findByPk(ctx.from.id)
    if (user.business.id == 0) return await ctx.reply(`🚫 Вы не владеете организацией.`)
    let world = await WorldModel.findByPk(1)
    let business = await BusinessModel.findOne({
      where: {
        owner: ctx.from.id.toString()
      }
    })
    if (business === null) return await ctx.reply(`🚫 У вас нет организации.`)
    if (!ctx.args[1]) return ctx.reply(`🚫 Не указан аргумент.`)
    if (!Number(ctx.args[1])) return ctx.reply(`ℹ️ Количество должно быть числом.`)
    if (ctx.args[1] < 1) return ctx.reply(`ℹ️ Минимальное количество для покупки - 1`)
    if (ctx.args[1]*world.matPrice > business.balance) return ctx.reply(`🚫 Недостаточно средств на балансе организации.`)
    if (business.materials >= 700) return ctx.reply(`🚫 Склады полны.`)
    if (business.materials + Number(ctx.args[1]) > 700) return ctx.reply(`🚫 Нет столько места на складах.\n Можно закупить еще ${700 - business.materials}`)
    let count = Number(ctx.args[1])
    business.balance -= world.matPrice*count
    business.materials += count
    business.save()
    return await ctx.reply(`➕ Закуплено ${ctx.args[1]} материалов для организации на сумму ¤${world.matPrice*count}`)
})

bot.command('percent', async (ctx) => {
    ctx.args = ctx.update.message.text.split(' ')
    let user = await UserModel.findByPk(ctx.from.id)
    if (user.business.id == 0) return await ctx.reply(`Вы не владеете организацией.`)
    let business = await BusinessModel.findOne({
      where: {
        owner: ctx.from.id.toString()
      }
    })
    if (business === null) return await ctx.reply(`У вас нет организации.`)
    if (!ctx.args[1] || !ctx.args[2]) return ctx.reply(`Не указан аргумент.`)
    if (!Number(ctx.args[2])) return ctx.reply(`Процент должен быть числом от 1 до 100.`)
    if (ctx.args[2] < 1 || ctx.args[2] > 100) return ctx.reply(`Минимальный процент 1 | Максимальный процент 100.`)
    ctx.args[1] = ctx.args[1]
  console.log(ctx.args)
    let change = await UserModel.findOne({
      where: {
        username: ctx.args[1]
      }
    })
    if (change === null) return await ctx.reply(`Нет такого игрока.`)
    change.business = {
        id: change.business.id,
        checks: change.business.checks,
        percent: ctx.args[2]
    }
    change.save()
    return await ctx.reply(`Участнику ${change.username} установлен процент ${ctx.args[2]}`)
})

bot.command('business', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id)
    if (user.business.id != 0){
    let business = await BusinessModel.findOne({
      where: {
        owner: ctx.from.id.toString()
      }
    })
  }
    let business = null
    let world = await WorldModel.findByPk(1)
    ctx.args = ctx.update.message.text.split(' ')
    if (business != null) return await ctx.reply(`У вас уже есть организация.`)
    if (!ctx.args[1]) return ctx.reply(`/business [Название организации]`)
    if (user.money < 100000) return await ctx.reply(`Регистрация организации стоит ¤100.000`)
    if (user.level < 5) return await ctx.reply(`Регистрация организации доступна с 5 уровня.`)
    user.money -= 100000
    world.balance += 100000
    let text = ``
    for (i = 1; i < ctx.args.length; i++) {
        text += `${ctx.args[i]} `
    }
    if (business === null) {
        BusinessModel.create({
            name: text,
            owner: user.telegram_id,
            balance: 50000,
            users: [user.telegram_id]
        })
        user.business = {
            id: user.telegram_id,
            checks: 0,
            percent: 100
        }
    } else {}
    user.save()
    world.save()
    return await ctx.reply(`Организация "${text}" успешно создана!\n Регистрация организации в реестре: ¤50.000 \n Капитал: ¤50.000`)
})

bot.command('invite', async (ctx) => {
    ctx.args = ctx.update.message.text.split(' ')
    if (!ctx.args[1]) return ctx.reply(`/invite [Nick]`)
    let user = await UserModel.findByPk(ctx.from.id)
    if (user.business.id == 0) return await ctx.reply(`🚫 У вас нет организации в которую можно пригласить игрока.`)
    let business = await BusinessModel.findOne({
        where: {
          owner: ctx.from.id.toString()
        }
      })
    if (business.users.length >= 5) return await ctx.reply(`📛 Достигнуто максимальное количество сотрудников в организации.`)
    let invited = await UserModel.findOne({
        where: {
            username: ctx.args[1]
        }
    });
    await bot.telegram.sendMessage(invited.telegram_id, '⤵️ Приглашение', Markup
        .inlineKeyboard([
            [{
                text: `Принять`,
                callback_data: `{"type": "business_invite_accept", "invitor": "${user.telegram_id}"}`
            }, {
                text: `Отклонить`,
                callback_data: `{"type": "business_invite_refuse", "invitor": "${user.telegram_id}"}`
            }]
        ]).oneTime())
    return await ctx.reply(`Приглашение отправлено.`)
})

bot.action(/{"type": "business_invite_(accept|refuse)"*/, async ctx => {
    let data = ctx.update.callback_query.data;
    data = JSON.parse(data)
    let user = await UserModel.findByPk(ctx.update.callback_query.from.id)
    if (data.type == 'business_invite_accept') {
      if(user.business.id == 0){
        let business = await BusinessModel.findOne({
          where: {
            owner: data.invitor
          }
        })
        user.business = {
            id: data.invitor,
            checks: 0,
            percent: 10
        }
        business.users = sequelize.fn('array_append', sequelize.col('users'), ctx.update.callback_query.from.id);
        business.save()
        user.save()
        await ctx.telegram.answerCbQuery(ctx.callbackQuery.id, `✔️ Приглашение принято.`, {show_alert: true})
      }
      await ctx.telegram.answerCbQuery(ctx.callbackQuery.id, `ℹ️ Вы уже в организации.`, {show_alert: true})
    } 
    if (data.type == 'business_invite_refuse'){
        await ctx.telegram.answerCbQuery(ctx.callbackQuery.id, `❌ Приглашение отклонено.`, {show_alert: true})
    }
})

bot.command('report', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id)
    ctx.args = ctx.update.message.text.split(' ')
    if (!ctx.args[1]) return ctx.reply(`/report [Текст обращения]`)
    let uID = shortid.generate()
    await ReportModel.create({
        uid: uID,
        author: user.telegram_id,
        text: ctx.payload,
        status: 1
    })
    let report = await ReportModel.findOne({
        where: {
            uid: uID
        }
    })
    await bot.telegram.sendMessage(adminList[0], `Обращение от пользователя ${user.username}\nТекст обращения:\n${ctx.payload}\n\nДля ответа /answer ${report.id} [Ответ]`)
    return await ctx.reply(`Обращение #${report.id}[${report.uid}] создано.`)
})

bot.hears('🎰 Слоты', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id)
    ctx.args = ctx.update.message.text.split(' ')
    await ctx.reply('Комбинации слотов:\n7️⃣7️⃣7️⃣ - x25\n🍋🍋🍋 - x20\n🍇🍇🍇 - x15\n🔤🔤🔤 - x10', Markup
        .inlineKeyboard([
            [{
                text: `1000`,
                callback_data: `slots1000`
            }, {
                text: `5000`,
                callback_data: `slots5000`
            }, {
                text: `25000`,
                callback_data: `slots25000`
            }, {
                text: `50000`,
                callback_data: `slots50000`
            }, {
                text: `100000`,
                callback_data: `slots100000`
            }]
        ]))
})

bot.action(/slots(1000|5000|25000|50000|100000)/, async (ctx) => {
    let data = ctx.update.callback_query.data;
    let bet = 1000
    switch(data){
        case `slots1000`:
            bet = 1000
            break;
        case `slots5000`:
            bet = 5000
            break;
        case `slots25000`:
            bet = 25000
            break;
        case `slots50000`:
            bet = 50000
            break;
        case `slots100000`:
            bet = 100000
            break;
    }
    let user = await UserModel.findByPk(ctx.from.id)
    let timer = user.slottime
    let cooldown = setCooldown(user, 10, timer)
    if (user.slottime > cooldown.currentTime) return ctx.reply(`📛 Слоты будут доступны через пару секунд`);
    if (user.money < bet) return ctx.reply(`Недостаточно средств.`)
    user.slottime = cooldown.endTime
    let world = await WorldModel.findByPk(1)
    let result = await ctx.replyWithDice({emoji: `🎰`})
    let slot = slots[result.dice.value]
    let win = getSlot(result)
    console.log(user.username + `: Win: x` + win)
    user.money -= bet
    world.balance += bet
    if(win > 4){
        user.world -= bet*win
        user.money += bet*win
        user.save()
        world.save()
        return setTimeout(() => {
            ctx.reply(`➕ Вы выиграли ¤${spaces(bet*win)}`)
        }, 1700);
    }
    if(win > 0 && win <= 4){
        await giveExp(user, win*2)
        return setTimeout(() => {
            ctx.reply(`➕ Вы выиграли ${win*2} опыта.`)
        }, 1700);
    }
    if(win == 0){
        return setTimeout(() => {
            world.save()
            user.save()
            ctx.reply(`➖ Вы проиграли ¤${spaces(bet)}.`)
        }, 1700);
    }
    
})

bot.hears('Помощь', async (ctx) => {
    return await ctx.replyWithMarkdownV2(`• [Функционал](https://telegra.ph/CampFire-Bot-Info-09-25)\n• [Правила](https://telegra.ph/PRAVILA-BOTA-09-25)`, {
        disable_web_page_preview: true
    })
})

bot.command('promocode', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id)
    ctx.args = ctx.update.message.text.split(' ')
    if (!ctx.args[1]) return ctx.reply(`/promocode [Code]`)
    let promocode = await PromocodeModel.findOne({
        where: {
          code: ctx.args[1]
        }
      })
    if(promocode === null) return await ctx.reply(`➖ Нет такого кода.`)
    if(promocode.users.length-1 >= promocode.activations && promocode.users != null) return await ctx.reply(`⚠️ Промокод уже активировали максимальное количество раз.`)
    if(promocode.users.includes(ctx.from.id.toString())) return await ctx.reply(`⚠️ Вы уже активировали этот промокод.`)
    console.log(promocode.users)
    promocode.users = sequelize.fn('array_append', sequelize.col('users'), ctx.from.id.toString());
    user.money += promocode.money
    user.save()
    promocode.save()
    await bot.telegram.sendMessage(adminList[0], `${user.username} активировал промокод.`)
    return await ctx.reply(`✅ Вы активировали промокод.`)
})

bot.hears('📦 Контейнеры', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id)
    let containers = []
    let superWin = rarecars.random()
    let values = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    let oneValue = []
    for(i = 0; i < 10; i++){
        oneValue = values.random()
        values = values.filter(value => value != oneValue);
        containers.push({name: `📦 Контейнер ${i+1}`, value: oneValue})
    }
    let keyboardButtons = containers.map(container => {
        return {text: container.name, callback_data: `container_${container.value}`}
    })
    let rows = []
    while (keyboardButtons.length > 0) {
        rows.push(keyboardButtons.splice(0, 2)) // разбиваем на подмассивы по 5 кнопок
    }
    await ctx.replyWithMarkdownV2('[Sueta Logistic International](https://telegra.ph/OOO-Sueta-Logistic-International-09-27)\nДоступные контейнеры в порту:',
    {
            reply_markup: {
                inline_keyboard: rows
            },
            disable_web_page_preview: true
        })
})


bot.action(/container_(1|2|3|4|5|6|7|8|9|10)/, async (ctx) => {
    let data = ctx.update.callback_query.data;
    let user = await UserModel.findByPk(ctx.from.id)
    let property = await PropertyModel.findByPk(ctx.from.id)
    if(user.money < 500000) return ctx.telegram.answerCbQuery(ctx.callbackQuery.id, `Открытие контейнера стоит ¤500.000`, {show_alert: true})
    if(property.car.name) return ctx.telegram.answerCbQuery(ctx.callbackQuery.id, `У вас уже есть автомобиль\nПродайте текущий автомобиль: /sell car`, {show_alert: true})
    user.money -= 500000
    let userWin = null
    switch(data){
        case `container_7`:
            userWin = rarecars.random()
            break;
        default:
            userWin = simplecars.random()
            break;
    }
    property.car = userWin
    user.save()
    property.save()
    ctx.deleteMessage()
    return await ctx.sendPhoto(userWin.image, { caption: `В контейнере была: ${userWin.name} стоимостью ¤${spaces(userWin.price)}`})
})

bot.action(/{"action": "sueta_*/, async (ctx) => {
    let data = ctx.update.callback_query.data;
    data = JSON.parse(data)
    console.log(data.car)
    let user = await UserModel.findByPk(ctx.from.id)
    let property = await PropertyModel.findByPk(ctx.from.id)
    switch(data.action){
        case `sueta_accept`:
            user.money += data.carprice
            await ctx.editMessageText(`➕ ${data.carprice}`)
            break;
        case `sueta_refuse`:
            user.money += Math.round(property.car.price/2)
            property.car = {
                name: data.carname,
                price: data.carprice
            }
            await ctx.editMessageText(`➕ ${data.carname}`)
            break;
    }
    user.save()
    property.save()
})
/////////////////////////////////////Admin Commands//////////////////////////////////////////////////


bot.command('answer', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id)
    if(user.status != 'admin') return await ctx.reply(`Admin Only.`)
    ctx.args = ctx.update.message.text.split(' ')
    if (!ctx.args[1]) return ctx.reply(`Нужен номер обращения`)
    let report = await ReportModel.findByPk(ctx.args[1])
    if (report === null) return await ctx.reply(`Нет обращения с таким ID.`)
    if (report.status == 0) return await ctx.reply(`Данное обращение уже закрыто.`)
    let answer = ctx.args
    answer.shift()
    answer.shift()
    answer = answer.join(' ')
    await bot.telegram.sendMessage(report.author, `Ответ на обращение #${report.id}[${report.uid}]\n\n` + answer)
    report.status = 0
    report.save()
    return await ctx.reply(`Ответ отправлен, обращение закрыто!`)
})

bot.command('fastblock', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id)
    if(!ctx.message.reply_to_message) return await ctx.reply(`Только на пересланное сообщение.`)
    let blocked = ctx.message.reply_to_message.from.id
    if(user.status != 'admin') return await ctx.reply(`Admin Only.`)
    await BlockModel.create({
        telegram_id: blocked,
        isBlocked: true,
        reason: `|AutoFastBlock|`,
        time: Math.trunc(Date.now() / 1000 + 3600)
    })
    await bot.telegram.sendMessage(blocked, `Вы были заблокированы администратором ${user.username}.`)
    return await ctx.reply(`Пользователь заблокирован.`)
})

bot.command('createpromocode', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id)
    if(user.status != 'admin') return await ctx.reply(`Admin Only.`)
    ctx.args = ctx.update.message.text.split(' ')
    if (!ctx.args[1] || !ctx.args[2] || !ctx.args[3]) return ctx.reply(`/createpromo [activations] [money] [code]`)
    let promocode = await PromocodeModel.findOne({
        where: {
          code: ctx.args[3]
        }
      })
    if(promocode === null){
    await PromocodeModel.create({
        code: ctx.args[3],
        activations: ctx.args[1],
        money: ctx.args[2]
    })
    let voucherImage = await generateVoucher(ctx.args[3], ctx.args[1], ctx.args[2])
    return await ctx.sendPhoto({source: voucherImage, caption: `Создан промокод ${ctx.args[3]}` })
}
})

bot.command('genpromo', async (ctx) => {
    let user = await UserModel.findByPk(ctx.from.id)
    if(user.status != 'admin') return await ctx.reply(`Admin Only.`)
    ctx.args = ctx.update.message.text.split(' ')
    if (!ctx.args[1] || !ctx.args[2]) return ctx.reply(`/genpromo [activations] [money]`)
    let code = voucher_codes.generate({
        length: 6,
        count: 1,
        prefix: "CMP-",
        postfix: "-FIRE",
        charset: voucher_codes.charset("alphanumeric")
    });
    let promocode = await PromocodeModel.findOne({
        where: {
          code: code[0]
        }
      })
    if(promocode === null){
    await PromocodeModel.create({
        code: code[0],
        activations: ctx.args[1],
        money: ctx.args[2]
    })
    let voucherImage = await generateVoucher(code, ctx.args[1], ctx.args[2])
    return await ctx.sendPhoto({source: voucherImage, caption: `Создан промокод ${code[0]}` })
}
})

///////////////////////////////////////Functions//////////////////////////////////////////////////////

function rand(min, max) {
    return Math.round(Math.random() * (max - min)) + min
}
var parserInt = (str) => parseInt(str.replace(/k|к/ig, "000"));

function spaces(string) {
    if (typeof string !== "string") string = string.toString();
    return string.split("").reverse().join("").match(/[0-9]{1,3}/g).join(".").split("").reverse().join("");
};
function spacesWithMarkdown(string) {
    if (typeof string !== "string") string = string.toString();
    return string.split("").reverse().join("").match(/[0-9]{1,3}/g).join(".\\").split("").reverse().join("");
};
function escape(text) {
    text = text
   .replace(/\_/g, '\\_')
   .replace(/\*/g, '\\*')
   .replace(/\[/g, '\\[')
   .replace(/\]/g, '\\]')
   .replace(/\(/g, '\\(')
   .replace(/\)/g, '\\)')
   .replace(/\~/g, '\\~')
   .replace(/\`/g, '\\`')
   .replace(/\>/g, '\\>')
   .replace(/\#/g, '\\#')
   .replace(/\+/g, '\\+')
   .replace(/\-/g, '\\-')
   .replace(/\=/g, '\\=')
   .replace(/\|/g, '\\|')
   .replace(/\{/g, '\\{')
   .replace(/\}/g, '\\}')
   .replace(/\./g, '\\.')
   .replace(/\!/g, '\\!');
    return text
};
Array.prototype.random = function() {
    return this[Math.floor(this.length * Math.random())];
}

function getCurrentTime() {
  const now = new Date();
  const year = now.getFullYear();
  const month = now.getMonth() < 9 ? `0${now.getMonth() + 1}` : now.getMonth() + 1;
  const day = now.getDate() < 10 ? `0${now.getDate()}` : now.getDate();
  const hours = now.getHours() < 10 ? `0${now.getHours()}` : now.getHours();
  const minutes = now.getMinutes() < 10 ? `0${now.getMinutes()}` : now.getMinutes();
  const seconds = now.getSeconds() < 10 ? `0${now.getSeconds()}` : now.getSeconds();
  return `${day}.${month}.${year} ${hours}:${minutes}:${seconds}`;
}

function getSlot(result) {
    switch(result.dice.value){
        case 1:
            return 10
        case 22:
            return 15
        case 43:
            return 20
        case 64:
            return 25
        case 17: case 33: case 49:
            return 1
        case 6: case 38: case 54:
            return 2
        case 11: case 27: case 59:
            return 3
        case 16: case 32: case 48:
            return 4
        default:
            return 0
}}

function setCooldown(user, seconds, type) {
    let cooldown = {}
    cooldown.currentTime = Math.trunc(Date.now() / 1000)

    switch(user.status){
        case `user`:
            cooldown.endTime = Math.trunc(Date.now() / 1000 + seconds) 
            break;
        case `bronze`:
            cooldown.endTime = Math.trunc(Date.now() / 1000 + (seconds/100*85))
            break;
        case `silver`:
            cooldown.endTime = Math.trunc(Date.now() / 1000 + (seconds/100*75))
            break;
        case `gold`:
            cooldown.endTime = Math.trunc(Date.now() / 1000 + (seconds/100*50))
            break;
        case `admin`:
            cooldown.endTime = Math.trunc(Date.now() / 1000)
            break;
    }
    cooldown.timeLeft = cooldown.endTime - cooldown.currentTime
    cooldown.timeLeftInMinutes = Math.ceil((type - cooldown.currentTime) / 60)
    return cooldown
}

async function giveExp(user, experience) {
    user.exp += experience
    for(i in expToUp){
        if (user.exp >= expToUp[user.level]) {
            user.exp -= expToUp[user.level]
            user.level += 1
            user.save()
            await bot.telegram.sendMessage(user.telegram_id, `⤴️ Ваш уровень повысился до ${user.level}!`)}
    }
    user.save()
}

function weaponShopUpdate() {
    let weaponId = []
    let equipId = []
    let drop = 1
    let counter = 5
    for (i = 0; i < 5; i++) {
        drop = weaponId.push(rand(1, 10))
    }
    for (i = 0; i < 5; i++) {
        drop = equipId.push(rand(1, 10))
    }
    for (i = 0; i < 5; i++) {
        weaponshop[i] = weapons[weaponId[i]]
    }
    for (i = 0; i < 5; i++) {
        weaponshop[counter] = equipment[equipId[i]]
        counter++
    }
    fs.writeFileSync('json/weaponshop.json', JSON.stringify(weaponshop, null, "\t"))
}

async function matPriceUpdate() {
  let world = await WorldModel.findByPk(1)
  let price = rand(35, 170)
  world.matPrice = price
  world.save()
}

setTimeout(() => {
    generatePromo()
}, 360000*3);

setInterval(() => {
    var today = new Date();
    let hours = today.getHours();
    if (hours == "0" || hours == "12") {
        weaponShopUpdate()
        matPriceUpdate()
    }
}, 360000);

async function generatePromo() {
    let activs = rand(1, 3)
    let give = rand(1000, 10000)
    let code = voucher_codes.generate({
        length: 6,
        count: 1,
        prefix: "CMP-",
        postfix: "-FIRE",
        charset: voucher_codes.charset("alphanumeric")
    });
    let promocode = await PromocodeModel.findOne({
        where: {
          code: code[0]
        }
      })
    if(promocode === null){
    await PromocodeModel.create({
        code: code[0],
        activations: activs,
        money: give
    })
    let voucherImage = await generateVoucher(code[0], activs, give)
    return await bot.telegram.sendPhoto(mainChat, {source: voucherImage})
}
}

async function generateVoucher(code, activations, money) {
    // загружаем изображение фона
    const background = await loadImage('./media/imageDefault3.png');
    
    // создаем новый canvas
    const canvas = createCanvas(background.width, background.height);
    const ctx = canvas.getContext('2d');
    
    // рисуем фоновое изображение
    ctx.drawImage(background, 0, 0);
    
    // выводим текст на картинку
    ctx.font = 'bold 30px Srbija Sans';
    ctx.fillStyle = '#232323';
    ctx.textAlign = 'center';
    ctx.fillText(`${code}`, canvas.width/2, canvas.height/1.90);
    
    // сохраняем картинку в файл
    const out = fs.createWriteStream('./media/image.png');
    const stream = canvas.createPNGStream();
    stream.pipe(out);
    
    // возвращаем путь к сгенерированной картинке
    return './media/image.png';
  }

start()

bot.launch()